source: src/mlx/gui/flight.py@ 62:b9bf44d0c527

Last change on this file since 62:b9bf44d0c527 was 62:b9bf44d0c527, checked in by István Váradi <ivaradi@…>, 13 years ago

Implemented the cruise level and route page.
File size: 39.1 KB
Line 
1# The flight handling "wizard"
2
3from mlx.gui.common import *
4
5import mlx.const as const
6import mlx.fs as fs
7from mlx.checks import PayloadChecker
8
9import datetime
10import time
11
12#-----------------------------------------------------------------------------
13
14class Page(gtk.Alignment):
15 """A page in the flight wizard."""
16 def __init__(self, wizard, title, help):
17 """Construct the page."""
18 super(Page, self).__init__(xalign = 0.0, yalign = 0.0,
19 xscale = 1.0, yscale = 1.0)
20 self.set_padding(padding_top = 4, padding_bottom = 4,
21 padding_left = 12, padding_right = 12)
22
23 frame = gtk.Frame()
24 self.add(frame)
25
26 style = self.get_style() if pygobject else self.rc_get_style()
27
28 self._vbox = gtk.VBox()
29 self._vbox.set_homogeneous(False)
30 frame.add(self._vbox)
31
32 eventBox = gtk.EventBox()
33 eventBox.modify_bg(0, style.bg[3])
34
35 alignment = gtk.Alignment(xalign = 0.0, xscale = 0.0)
36
37 label = gtk.Label(title)
38 label.modify_fg(0, style.fg[3])
39 label.modify_font(pango.FontDescription("bold 24"))
40 alignment.set_padding(padding_top = 4, padding_bottom = 4,
41 padding_left = 6, padding_right = 0)
42
43 alignment.add(label)
44 eventBox.add(alignment)
45
46 self._vbox.pack_start(eventBox, False, False, 0)
47
48 table = gtk.Table(3, 1)
49 table.set_homogeneous(True)
50
51 alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
52 xscale = 1.0, yscale = 1.0)
53 alignment.set_padding(padding_top = 16, padding_bottom = 16,
54 padding_left = 16, padding_right = 16)
55 alignment.add(table)
56 self._vbox.pack_start(alignment, True, True, 0)
57
58 alignment = gtk.Alignment(xalign = 0.5, yalign = 0.0,
59 xscale = 0, yscale = 0.0)
60 alignment.set_padding(padding_top = 0, padding_bottom = 16,
61 padding_left = 0, padding_right = 0)
62
63 label = gtk.Label(help)
64 label.set_justify(gtk.Justification.CENTER if pygobject
65 else gtk.JUSTIFY_CENTER)
66 alignment.add(label)
67 table.attach(alignment, 0, 1, 0, 1)
68
69 self._mainAlignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
70 xscale = 1.0, yscale = 1.0)
71 table.attach(self._mainAlignment, 0, 1, 1, 3)
72
73 buttonAlignment = gtk.Alignment(xalign = 1.0, xscale=0.0, yscale = 0.0)
74 buttonAlignment.set_padding(padding_top = 4, padding_bottom = 10,
75 padding_left = 16, padding_right = 16)
76
77 self._buttonBox = gtk.HButtonBox()
78 self._defaultButton = None
79 buttonAlignment.add(self._buttonBox)
80
81 self._vbox.pack_start(buttonAlignment, False, False, 0)
82
83 self._wizard = wizard
84
85 def setMainWidget(self, widget):
86 """Set the given widget as the main one."""
87 self._mainAlignment.add(widget)
88
89 def addButton(self, label, default = False):
90 """Add a button with the given label.
91
92 Return the button object created."""
93 button = gtk.Button(label)
94 self._buttonBox.add(button)
95 button.set_use_underline(True)
96 if default:
97 button.set_can_default(True)
98 self._defaultButton = button
99 return button
100
101 def activate(self):
102 """Called when this page becomes active.
103
104 This default implementation does nothing."""
105 pass
106
107 def grabDefault(self):
108 """If the page has a default button, make it the default one."""
109 if self._defaultButton is not None:
110 self._defaultButton.grab_default()
111
112#-----------------------------------------------------------------------------
113
114class LoginPage(Page):
115 """The login page."""
116 def __init__(self, wizard):
117 """Construct the login page."""
118 help = "Enter your MAVA pilot's ID and password to\n" \
119 "log in to the MAVA website and download\n" \
120 "your booked flights."
121 super(LoginPage, self).__init__(wizard, "Login", help)
122
123 alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
124 xscale = 0.0, yscale = 0.0)
125
126 table = gtk.Table(2, 3)
127 table.set_row_spacings(4)
128 table.set_col_spacings(32)
129 alignment.add(table)
130 self.setMainWidget(alignment)
131
132 labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
133 label = gtk.Label("Pilot _ID:")
134 label.set_use_underline(True)
135 labelAlignment.add(label)
136 table.attach(labelAlignment, 0, 1, 0, 1)
137
138 self._pilotID = gtk.Entry()
139 self._pilotID.connect("changed", self._setLoginButton)
140 self._pilotID.set_tooltip_text("Enter your MAVA pilot's ID. This "
141 "usually starts with a "
142 "'P' followed by 3 digits.")
143 table.attach(self._pilotID, 1, 2, 0, 1)
144 label.set_mnemonic_widget(self._pilotID)
145
146 labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
147 label = gtk.Label("_Password:")
148 label.set_use_underline(True)
149 labelAlignment.add(label)
150 table.attach(labelAlignment, 0, 1, 1, 2)
151
152 self._password = gtk.Entry()
153 self._password.set_visibility(False)
154 self._password.connect("changed", self._setLoginButton)
155 self._password.set_tooltip_text("Enter the password for your pilot's ID")
156 table.attach(self._password, 1, 2, 1, 2)
157 label.set_mnemonic_widget(self._password)
158
159 self._rememberButton = gtk.CheckButton("_Remember password")
160 self._rememberButton.set_use_underline(True)
161 self._rememberButton.set_tooltip_text("If checked, your password will "
162 "be stored, so that you should "
163 "not have to enter it every time. "
164 "Note, however, that the password "
165 "is stored as text, and anybody "
166 "who can access your files will "
167 "be able to read it.")
168 table.attach(self._rememberButton, 1, 2, 2, 3, ypadding = 8)
169
170 self._loginButton = self.addButton("_Login", default = True)
171 self._loginButton.set_sensitive(False)
172 self._loginButton.connect("clicked", self._loginClicked)
173 self._loginButton.set_tooltip_text("Click to log in.")
174
175 config = self._wizard.gui.config
176 self._pilotID.set_text(config.pilotID)
177 self._password.set_text(config.password)
178 self._rememberButton.set_active(config.rememberPassword)
179
180 def _setLoginButton(self, entry):
181 """Set the login button's sensitivity.
182
183 The button is sensitive only if both the pilot ID and the password
184 fields contain values."""
185 self._loginButton.set_sensitive(self._pilotID.get_text()!="" and
186 self._password.get_text()!="")
187
188 def _loginClicked(self, button):
189 """Called when the login button was clicked."""
190 self._wizard.gui.beginBusy("Logging in...")
191 self._wizard.gui.webHandler.login(self._loginResultCallback,
192 self._pilotID.get_text(),
193 self._password.get_text())
194
195 def _loginResultCallback(self, returned, result):
196 """The login result callback, called in the web handler's thread."""
197 gobject.idle_add(self._handleLoginResult, returned, result)
198
199 def _handleLoginResult(self, returned, result):
200 """Handle the login result."""
201 self._wizard.gui.endBusy()
202 if returned:
203 if result.loggedIn:
204 config = self._wizard.gui.config
205
206 config.pilotID = self._pilotID.get_text()
207
208 rememberPassword = self._rememberButton.get_active()
209 config.password = self._password.get_text() if rememberPassword \
210 else ""
211
212 config.rememberPassword = rememberPassword
213
214 config.save()
215 self._wizard._loginResult = result
216 self._wizard.nextPage()
217 else:
218 dialog = gtk.MessageDialog(type = MESSAGETYPE_ERROR,
219 buttons = BUTTONSTYPE_OK,
220 message_format =
221 "Invalid pilot's ID or password.")
222 dialog.format_secondary_markup("Check the ID and try to reenter"
223 " the password.")
224 dialog.run()
225 dialog.hide()
226 else:
227 dialog = gtk.MessageDialog(type = MESSAGETYPE_ERROR,
228 buttons = BUTTONSTYPE_OK,
229 message_format =
230 "Failed to connect to the MAVA website.")
231 dialog.format_secondary_markup("Try again in a few minutes.")
232 dialog.run()
233 dialog.hide()
234
235#-----------------------------------------------------------------------------
236
237class FlightSelectionPage(Page):
238 """The page to select the flight."""
239 def __init__(self, wizard):
240 """Construct the flight selection page."""
241 super(FlightSelectionPage, self).__init__(wizard, "Flight selection",
242 "Select the flight you want "
243 "to perform.")
244
245
246 self._listStore = gtk.ListStore(str, str, str, str)
247 self._flightList = gtk.TreeView(self._listStore)
248 column = gtk.TreeViewColumn("Flight no.", gtk.CellRendererText(),
249 text = 1)
250 column.set_expand(True)
251 self._flightList.append_column(column)
252 column = gtk.TreeViewColumn("Departure time [UTC]", gtk.CellRendererText(),
253 text = 0)
254 column.set_expand(True)
255 self._flightList.append_column(column)
256 column = gtk.TreeViewColumn("From", gtk.CellRendererText(),
257 text = 2)
258 column.set_expand(True)
259 self._flightList.append_column(column)
260 column = gtk.TreeViewColumn("To", gtk.CellRendererText(),
261 text = 3)
262 column.set_expand(True)
263 self._flightList.append_column(column)
264
265 flightSelection = self._flightList.get_selection()
266 flightSelection.connect("changed", self._selectionChanged)
267
268 scrolledWindow = gtk.ScrolledWindow()
269 scrolledWindow.add(self._flightList)
270 scrolledWindow.set_size_request(400, -1)
271 scrolledWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
272 else gtk.POLICY_AUTOMATIC,
273 gtk.PolicyType.ALWAYS if pygobject
274 else gtk.POLICY_ALWAYS)
275 scrolledWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
276 else gtk.SHADOW_IN)
277
278 alignment = gtk.Alignment(xalign = 0.5, yalign = 0.0, xscale = 0.0, yscale = 1.0)
279 alignment.add(scrolledWindow)
280
281 self.setMainWidget(alignment)
282
283 self._button = self.addButton(gtk.STOCK_GO_FORWARD, default = True)
284 self._button.set_use_stock(True)
285 self._button.set_sensitive(False)
286 self._button.connect("clicked", self._forwardClicked)
287
288 self._activated = False
289
290 def activate(self):
291 """Fill the flight list."""
292 if not self._activated:
293 for flight in self._wizard.loginResult.flights:
294 self._listStore.append([str(flight.departureTime),
295 flight.callsign,
296 flight.departureICAO,
297 flight.arrivalICAO])
298 self._activated = True
299
300 def _selectionChanged(self, selection):
301 """Called when the selection is changed."""
302 self._button.set_sensitive(selection.count_selected_rows()==1)
303
304 def _forwardClicked(self, button):
305 """Called when the forward button was clicked."""
306 selection = self._flightList.get_selection()
307 (listStore, iter) = selection.get_selected()
308 path = listStore.get_path(iter)
309 [index] = path.get_indices() if pygobject else path
310
311 flight = self._wizard.loginResult.flights[index]
312 self._wizard._bookedFlight = flight
313
314 self._updateDepartureGate()
315
316 def _updateDepartureGate(self):
317 """Update the departure gate for the booked flight."""
318 flight = self._wizard._bookedFlight
319 if flight.departureICAO=="LHBP":
320 self._wizard._getFleet(self._fleetRetrieved)
321 else:
322 self._wizard.jumpPage(2)
323
324 def _fleetRetrieved(self, fleet):
325 """Called when the fleet has been retrieved."""
326 if fleet is None:
327 self._wizard.jumpPage(2)
328 else:
329 plane = fleet[self._wizard._bookedFlight.tailNumber]
330 if plane is None:
331 self._wizard.jumpPage(2)
332
333 if plane.gateNumber is not None and \
334 not fleet.isGateConflicting(plane):
335 self._wizard._departureGate = plane.gateNumber
336 self._wizard.jumpPage(2)
337 else:
338 self._wizard.nextPage()
339
340#-----------------------------------------------------------------------------
341
342class GateSelectionPage(Page):
343 """Page to select a free gate at LHBP.
344
345 This page should be displayed only if we have fleet information!."""
346 def __init__(self, wizard):
347 """Construct the gate selection page."""
348 help = "The airplane's gate position is invalid.\n\n" \
349 "Select the gate from which you\n" \
350 "would like to begin the flight."
351 super(GateSelectionPage, self).__init__(wizard,
352 "LHBP gate selection",
353 help)
354
355 self._listStore = gtk.ListStore(str)
356 self._gateList = gtk.TreeView(self._listStore)
357 column = gtk.TreeViewColumn(None, gtk.CellRendererText(),
358 text = 0)
359 column.set_expand(True)
360 self._gateList.append_column(column)
361 self._gateList.set_headers_visible(False)
362
363 gateSelection = self._gateList.get_selection()
364 gateSelection.connect("changed", self._selectionChanged)
365
366 scrolledWindow = gtk.ScrolledWindow()
367 scrolledWindow.add(self._gateList)
368 scrolledWindow.set_size_request(50, -1)
369 scrolledWindow.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
370 else gtk.POLICY_AUTOMATIC,
371 gtk.PolicyType.ALWAYS if pygobject
372 else gtk.POLICY_ALWAYS)
373 scrolledWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
374 else gtk.SHADOW_IN)
375
376 alignment = gtk.Alignment(xalign = 0.5, yalign = 0.0, xscale = 0.0, yscale = 1.0)
377 alignment.add(scrolledWindow)
378
379 self.setMainWidget(alignment)
380
381 self._button = self.addButton(gtk.STOCK_GO_FORWARD, default = True)
382 self._button.set_use_stock(True)
383 self._button.set_sensitive(False)
384 self._button.connect("clicked", self._forwardClicked)
385
386 def activate(self):
387 """Fill the gate list."""
388 self._listStore.clear()
389 occupiedGateNumbers = self._wizard._fleet.getOccupiedGateNumbers()
390 for gateNumber in const.lhbpGateNumbers:
391 if gateNumber not in occupiedGateNumbers:
392 self._listStore.append([gateNumber])
393
394 def _selectionChanged(self, selection):
395 """Called when the selection is changed."""
396 self._button.set_sensitive(selection.count_selected_rows()==1)
397
398 def _forwardClicked(self, button):
399 """Called when the forward button is clicked."""
400 selection = self._gateList.get_selection()
401 (listStore, iter) = selection.get_selected()
402 (gateNumber,) = listStore.get(iter, 0)
403
404 self._wizard._departureGate = gateNumber
405
406 #self._wizard._updatePlane(self._planeUpdated,
407 # self._wizard._bookedFlight.tailNumber,
408 # const.PLANE_HOME,
409 # gateNumber)
410 self._wizard.nextPage()
411
412 def _planeUpdated(self, success):
413 """Callback for the plane updating call."""
414 if success is None or success:
415 self._wizard.nextPage()
416 else:
417 dialog = gtk.MessageDialog(type = MESSAGETYPE_ERROR,
418 buttons = BUTTONSTYPE_OK,
419 message_format = "Gate conflict detected again")
420 dialog.format_secondary_markup("Try to select a different gate.")
421 dialog.run()
422 dialog.hide()
423
424 self._wizard._getFleet(self._fleetRetrieved)
425
426 def _fleetRetrieved(self, fleet):
427 """Called when the fleet has been retrieved."""
428 if fleet is None:
429 self._wizard.nextPage()
430 else:
431 self.activate()
432
433#-----------------------------------------------------------------------------
434
435class ConnectPage(Page):
436 """Page which displays the departure airport and gate (if at LHBP)."""
437 def __init__(self, wizard):
438 """Construct the connect page."""
439 help = "The flight begins at the airport given below.\n" \
440 "Park your aircraft there, at the gate below, if given.\n\n" \
441 "Then press the Connect button to connect to the simulator."
442 super(ConnectPage, self).__init__(wizard,
443 "Connect to the simulator",
444 help)
445
446 alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
447 xscale = 0.0, yscale = 0.0)
448
449 table = gtk.Table(2, 2)
450 table.set_row_spacings(4)
451 table.set_col_spacings(16)
452 table.set_homogeneous(True)
453 alignment.add(table)
454 self.setMainWidget(alignment)
455
456 labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
457 label = gtk.Label("ICAO code:")
458 labelAlignment.add(label)
459 table.attach(labelAlignment, 0, 1, 0, 1)
460
461 labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
462 self._departureICAO = gtk.Label()
463 self._departureICAO.set_width_chars(5)
464 self._departureICAO.set_alignment(0.0, 0.5)
465 labelAlignment.add(self._departureICAO)
466 table.attach(labelAlignment, 1, 2, 0, 1)
467
468 labelAlignment = gtk.Alignment(xalign=1.0, xscale=0.0)
469 label = gtk.Label("Gate:")
470 labelAlignment.add(label)
471 table.attach(labelAlignment, 0, 1, 1, 2)
472
473 labelAlignment = gtk.Alignment(xalign=0.0, xscale=0.0)
474 self._departureGate = gtk.Label()
475 self._departureGate.set_width_chars(5)
476 self._departureGate.set_alignment(0.0, 0.5)
477 labelAlignment.add(self._departureGate)
478 table.attach(labelAlignment, 1, 2, 1, 2)
479
480 self._button = self.addButton("_Connect", default = True)
481 self._button.set_use_underline(True)
482 self._button.connect("clicked", self._connectClicked)
483
484 def activate(self):
485 """Setup the departure information."""
486 icao = self._wizard._bookedFlight.departureICAO
487 self._departureICAO.set_markup("<b>" + icao + "</b>")
488 gate = self._wizard._departureGate
489 if gate!="-":
490 gate = "<b>" + gate + "</b>"
491 self._departureGate.set_markup(gate)
492
493 def _connectClicked(self, button):
494 """Called when the Connect button is pressed."""
495 self._wizard._connectSimulator()
496
497#-----------------------------------------------------------------------------
498
499class PayloadPage(Page):
500 """Page to allow setting up the payload."""
501 def __init__(self, wizard):
502 """Construct the page."""
503 help = "The briefing contains the weights below.\n" \
504 "Setup the cargo weight here and the payload weight in the simulator.\n\n" \
505 "You can also check here what the simulator reports as ZFW."
506
507 super(PayloadPage, self).__init__(wizard, "Payload", help)
508
509 alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
510 xscale = 0.0, yscale = 0.0)
511
512 table = gtk.Table(7, 3)
513 table.set_row_spacings(4)
514 table.set_col_spacings(16)
515 table.set_homogeneous(False)
516 alignment.add(table)
517 self.setMainWidget(alignment)
518
519 label = gtk.Label("Crew:")
520 label.set_alignment(0.0, 0.5)
521 table.attach(label, 0, 1, 0, 1)
522
523 self._numCrew = gtk.Label()
524 self._numCrew.set_width_chars(6)
525 self._numCrew.set_alignment(1.0, 0.5)
526 table.attach(self._numCrew, 1, 2, 0, 1)
527
528 label = gtk.Label("Passengers:")
529 label.set_alignment(0.0, 0.5)
530 table.attach(label, 0, 1, 1, 2)
531
532 self._numPassengers = gtk.Label()
533 self._numPassengers.set_width_chars(6)
534 self._numPassengers.set_alignment(1.0, 0.5)
535 table.attach(self._numPassengers, 1, 2, 1, 2)
536
537 label = gtk.Label("Baggage:")
538 label.set_alignment(0.0, 0.5)
539 table.attach(label, 0, 1, 2, 3)
540
541 self._bagWeight = gtk.Label()
542 self._bagWeight.set_width_chars(6)
543 self._bagWeight.set_alignment(1.0, 0.5)
544 table.attach(self._bagWeight, 1, 2, 2, 3)
545
546 table.attach(gtk.Label("kg"), 2, 3, 2, 3)
547
548 label = gtk.Label("_Cargo:")
549 label.set_use_underline(True)
550 label.set_alignment(0.0, 0.5)
551 table.attach(label, 0, 1, 3, 4)
552
553 self._cargoWeight = gtk.Entry()
554 self._cargoWeight.set_width_chars(6)
555 self._cargoWeight.set_alignment(1.0)
556 self._cargoWeight.connect("changed", self._cargoWeightChanged)
557 self._cargoWeight.set_tooltip_text("The weight of the cargo for your flight.")
558 table.attach(self._cargoWeight, 1, 2, 3, 4)
559 self._cargoWeightValue = 0
560 label.set_mnemonic_widget(self._cargoWeight)
561
562 table.attach(gtk.Label("kg"), 2, 3, 3, 4)
563
564 label = gtk.Label("Mail:")
565 label.set_alignment(0.0, 0.5)
566 table.attach(label, 0, 1, 4, 5)
567
568 self._mailWeight = gtk.Label()
569 self._mailWeight.set_width_chars(6)
570 self._mailWeight.set_alignment(1.0, 0.5)
571 table.attach(self._mailWeight, 1, 2, 4, 5)
572
573 table.attach(gtk.Label("kg"), 2, 3, 4, 5)
574
575 label = gtk.Label("<b>Calculated ZFW:</b>")
576 label.set_alignment(0.0, 0.5)
577 label.set_use_markup(True)
578 table.attach(label, 0, 1, 5, 6)
579
580 self._calculatedZFW = gtk.Label()
581 self._calculatedZFW.set_width_chars(6)
582 self._calculatedZFW.set_alignment(1.0, 0.5)
583 table.attach(self._calculatedZFW, 1, 2, 5, 6)
584
585 table.attach(gtk.Label("kg"), 2, 3, 5, 6)
586
587 button = gtk.Button("_ZFW from FS:")
588 button.set_use_underline(True)
589 button.connect("clicked", self._zfwRequested)
590 table.attach(button, 0, 1, 6, 7)
591
592 self._simulatorZFW = gtk.Label("-")
593 self._simulatorZFW.set_width_chars(6)
594 self._simulatorZFW.set_alignment(1.0, 0.5)
595 table.attach(self._simulatorZFW, 1, 2, 6, 7)
596 self._simulatorZFWValue = None
597
598 table.attach(gtk.Label("kg"), 2, 3, 6, 7)
599
600 self._button = self.addButton(gtk.STOCK_GO_FORWARD, default = True)
601 self._button.set_use_stock(True)
602 self._button.connect("clicked", self._forwardClicked)
603
604 def activate(self):
605 """Setup the information."""
606 bookedFlight = self._wizard._bookedFlight
607 self._numCrew.set_text(str(bookedFlight.numCrew))
608 self._numPassengers.set_text(str(bookedFlight.numPassengers))
609 self._bagWeight.set_text(str(bookedFlight.bagWeight))
610 self._cargoWeightValue = bookedFlight.cargoWeight
611 self._cargoWeight.set_text(str(bookedFlight.cargoWeight))
612 self._mailWeight.set_text(str(bookedFlight.mailWeight))
613 self._updateCalculatedZFW()
614
615 def _calculateZFW(self):
616 """Calculate the ZFW value."""
617 zfw = self._wizard.gui._flight.aircraft.dow
618 bookedFlight = self._wizard._bookedFlight
619 zfw += (bookedFlight.numCrew + bookedFlight.numPassengers) * 82
620 zfw += bookedFlight.bagWeight
621 zfw += self._cargoWeightValue
622 zfw += bookedFlight.mailWeight
623 return zfw
624
625 def _updateCalculatedZFW(self):
626 """Update the calculated ZFW"""
627 zfw = self._calculateZFW()
628
629 markupBegin = "<b>"
630 markupEnd = "</b>"
631 if self._simulatorZFWValue is not None and \
632 PayloadChecker.isZFWFaulty(self._simulatorZFWValue, zfw):
633 markupBegin += '<span foreground="red">'
634 markupEnd = "</span>" + markupEnd
635 self._calculatedZFW.set_markup(markupBegin + str(zfw) + markupEnd)
636
637 def _cargoWeightChanged(self, entry):
638 """Called when the cargo weight has changed."""
639 text = self._cargoWeight.get_text()
640 if text=="":
641 self._cargoWeightValue = 0
642 else:
643 try:
644 self._cargoWeightValue = int(text)
645 except:
646 self._cargoWeight.set_text(str(self._cargoWeightValue))
647 self._updateCalculatedZFW()
648
649 def _zfwRequested(self, button):
650 """Called when the ZFW is requested from the simulator."""
651 self._wizard.gui.beginBusy("Querying ZFW...")
652 self._wizard.gui.simulator.requestZFW(self._handleZFW)
653
654 def _handleZFW(self, zfw):
655 """Called when the ZFW value is retrieved."""
656 gobject.idle_add(self._processZFW, zfw)
657
658 def _processZFW(self, zfw):
659 """Process the given ZFW value received from the simulator."""
660 self._wizard.gui.endBusy()
661 self._simulatorZFWValue = zfw
662 self._simulatorZFW.set_text("%.0f" % (zfw,))
663 self._updateCalculatedZFW()
664
665 def _forwardClicked(self, button):
666 """Called when the forward button is clicked."""
667 self._wizard._zfw = self._calculateZFW()
668 self._wizard.nextPage()
669
670#-----------------------------------------------------------------------------
671
672class TimePage(Page):
673 """Page displaying the departure and arrival times and allows querying the
674 current time from the flight simulator."""
675 def __init__(self, wizard):
676 help = "The departure and arrival times are displayed below in UTC.\n\n" \
677 "You can also query the current UTC time from the simulator.\n" \
678 "Ensure that you have enough time to properly prepare for the flight."
679
680 super(TimePage, self).__init__(wizard, "Time", help)
681
682 alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
683 xscale = 0.0, yscale = 0.0)
684
685 table = gtk.Table(3, 2)
686 table.set_row_spacings(4)
687 table.set_col_spacings(16)
688 table.set_homogeneous(False)
689 alignment.add(table)
690 self.setMainWidget(alignment)
691
692 label = gtk.Label("Departure:")
693 label.set_alignment(0.0, 0.5)
694 table.attach(label, 0, 1, 0, 1)
695
696 self._departure = gtk.Label()
697 self._departure.set_alignment(0.0, 0.5)
698 table.attach(self._departure, 1, 2, 0, 1)
699
700 label = gtk.Label("Arrival:")
701 label.set_alignment(0.0, 0.5)
702 table.attach(label, 0, 1, 1, 2)
703
704 self._arrival = gtk.Label()
705 self._arrival.set_alignment(0.0, 0.5)
706 table.attach(self._arrival, 1, 2, 1, 2)
707
708 button = gtk.Button("_Time from FS:")
709 button.set_use_underline(True)
710 button.connect("clicked", self._timeRequested)
711 table.attach(button, 0, 1, 2, 3)
712
713 self._simulatorTime = gtk.Label("-")
714 self._simulatorTime.set_alignment(0.0, 0.5)
715 table.attach(self._simulatorTime, 1, 2, 2, 3)
716
717 self._button = self.addButton(gtk.STOCK_GO_FORWARD, default = True)
718 self._button.set_use_stock(True)
719 self._button.connect("clicked", self._forwardClicked)
720
721 def activate(self):
722 """Activate the page."""
723 bookedFlight = self._wizard._bookedFlight
724 self._departure.set_text(str(bookedFlight.departureTime.time()))
725 self._arrival.set_text(str(bookedFlight.arrivalTime.time()))
726
727 def _timeRequested(self, button):
728 """Request the time from the simulator."""
729 self._wizard.gui.beginBusy("Querying time...")
730 self._wizard.gui.simulator.requestTime(self._handleTime)
731
732 def _handleTime(self, timestamp):
733 """Handle the result of a time retrieval."""
734 gobject.idle_add(self._processTime, timestamp)
735
736 def _processTime(self, timestamp):
737 """Process the given time."""
738 self._wizard.gui.endBusy()
739 tm = time.gmtime(timestamp)
740 t = datetime.time(tm.tm_hour, tm.tm_min, tm.tm_sec)
741 self._simulatorTime.set_text(str(t))
742
743 ts = tm.tm_hour * 3600 + tm.tm_min * 60 + tm.tm_sec
744 dt = self._wizard._bookedFlight.departureTime.time()
745 dts = dt.hour * 3600 + dt.minute * 60 + dt.second
746 diff = dts-ts
747
748 markupBegin = ""
749 markupEnd = ""
750 if diff < 0:
751 markupBegin = '<b><span foreground="red">'
752 markupEnd = '</span></b>'
753 elif diff < 3*60 or diff > 30*60:
754 markupBegin = '<b><span foreground="orange">'
755 markupEnd = '</span></b>'
756
757 self._departure.set_markup(markupBegin + str(dt) + markupEnd)
758
759 def _forwardClicked(self, button):
760 """Called when the forward button is clicked."""
761 self._wizard.nextPage()
762
763#-----------------------------------------------------------------------------
764
765class RoutePage(Page):
766 """The page containing the route and the flight level."""
767 def __init__(self, wizard):
768 help = "Set your cruise flight level below, and\n" \
769 "if necessary, edit the flight plan."
770
771 super(RoutePage, self).__init__(wizard, "Route", help)
772
773 alignment = gtk.Alignment(xalign = 0.5, yalign = 0.5,
774 xscale = 0.0, yscale = 0.0)
775
776 mainBox = gtk.VBox()
777 alignment.add(mainBox)
778 self.setMainWidget(alignment)
779
780 levelBox = gtk.HBox()
781
782 label = gtk.Label("_Cruise level")
783 label.set_use_underline(True)
784 levelBox.pack_start(label, True, True, 0)
785
786 self._cruiseLevel = gtk.SpinButton()
787 self._cruiseLevel.set_increments(step = 10, page = 100)
788 self._cruiseLevel.set_range(min = 50, max = 500)
789 self._cruiseLevel.set_value(240)
790 self._cruiseLevel.set_tooltip_text("The cruise flight level.")
791 self._cruiseLevel.set_numeric(True)
792 self._cruiseLevel.connect("value-changed", self._cruiseLevelChanged)
793 label.set_mnemonic_widget(self._cruiseLevel)
794
795 levelBox.pack_start(self._cruiseLevel, False, False, 8)
796
797 alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
798 xscale = 0.0, yscale = 0.0)
799 alignment.add(levelBox)
800
801 mainBox.pack_start(alignment, False, False, 0)
802
803
804 routeBox = gtk.VBox()
805
806 alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
807 xscale = 0.0, yscale = 0.0)
808 label = gtk.Label("_Route")
809 label.set_use_underline(True)
810 alignment.add(label)
811 routeBox.pack_start(alignment, True, True, 0)
812
813 routeWindow = gtk.ScrolledWindow()
814 routeWindow.set_size_request(400, 80)
815 routeWindow.set_shadow_type(gtk.ShadowType.IN if pygobject
816 else gtk.SHADOW_IN)
817
818 self._route = gtk.TextView()
819 self._route.set_tooltip_text("The planned flight route.")
820 self._route.get_buffer().connect("changed", self._routeChanged)
821 routeWindow.add(self._route)
822
823 label.set_mnemonic_widget(self._route)
824 routeBox.pack_start(routeWindow, True, True, 0)
825
826 mainBox.pack_start(routeBox, True, True, 8)
827
828 self._button = self.addButton(gtk.STOCK_GO_FORWARD, default = True)
829 self._button.set_use_stock(True)
830 self._button.connect("clicked", self._forwardClicked)
831
832 def activate(self):
833 """Setup the route from the booked flight."""
834 self._route.get_buffer().set_text(self._wizard._bookedFlight.route)
835 self._updateForwardButton()
836
837 def _getRoute(self):
838 """Get the text of the route."""
839 buffer = self._route.get_buffer()
840 return buffer.get_text(buffer.get_start_iter(),
841 buffer.get_end_iter(), True)
842
843 def _updateForwardButton(self):
844 """Update the sensitivity of the forward button."""
845 self._button.set_sensitive(self._cruiseLevel.get_value_as_int()>=50 and \
846 self._getRoute())
847
848 def _cruiseLevelChanged(self, spinButton):
849 """Called when the cruise level has changed."""
850 self._updateForwardButton()
851
852 def _routeChanged(self, textBuffer):
853 """Called when the route has changed."""
854 self._updateForwardButton()
855
856 def _forwardClicked(self, button):
857 """Called when the Forward button is clicked."""
858 self._wizard._cruiseAltitude = self._cruiseLevel.get_value_as_int() * 100
859 self._wizard._route = self._getRoute()
860 self._wizard.nextPage()
861
862#-----------------------------------------------------------------------------
863
864class Wizard(gtk.VBox):
865 """The flight wizard."""
866 def __init__(self, gui):
867 """Construct the wizard."""
868 super(Wizard, self).__init__()
869
870 self.gui = gui
871
872 self._pages = []
873 self._currentPage = None
874
875 self._pages.append(LoginPage(self))
876 self._pages.append(FlightSelectionPage(self))
877 self._pages.append(GateSelectionPage(self))
878 self._pages.append(ConnectPage(self))
879 self._pages.append(PayloadPage(self))
880 self._pages.append(TimePage(self))
881 self._pages.append(RoutePage(self))
882
883 maxWidth = 0
884 maxHeight = 0
885 for page in self._pages:
886 page.show_all()
887 pageSizeRequest = page.size_request()
888 width = pageSizeRequest.width if pygobject else pageSizeRequest[0]
889 height = pageSizeRequest.height if pygobject else pageSizeRequest[1]
890 maxWidth = max(maxWidth, width)
891 maxHeight = max(maxHeight, height)
892 maxWidth += 16
893 maxHeight += 32
894 self.set_size_request(maxWidth, maxHeight)
895
896 self._initialize()
897
898 @property
899 def loginResult(self):
900 """Get the login result."""
901 return self._loginResult
902
903 def setCurrentPage(self, index):
904 """Set the current page to the one with the given index."""
905 assert index < len(self._pages)
906
907 if self._currentPage is not None:
908 self.remove(self._pages[self._currentPage])
909
910 self._currentPage = index
911 self.add(self._pages[index])
912 self._pages[index].activate()
913 self.show_all()
914
915 def nextPage(self):
916 """Go to the next page."""
917 self.jumpPage(1)
918
919 def jumpPage(self, count):
920 """Go to the page which is 'count' pages after the current one."""
921 self.setCurrentPage(self._currentPage + count)
922 self.grabDefault()
923
924 def grabDefault(self):
925 """Make the default button of the current page the default."""
926 self._pages[self._currentPage].grabDefault()
927
928 def connected(self, fsType, descriptor):
929 """Called when the connection could be made to the simulator."""
930 self.nextPage()
931
932 def connectionFailed(self):
933 """Called when the connection could not be made to the simulator."""
934 self._initialize()
935
936 def disconnected(self):
937 """Called when we have disconnected from the simulator."""
938 self._initialize()
939
940 def _initialize(self):
941 """Initialize the wizard."""
942 self._fleet = None
943 self._fleetCallback = None
944 self._updatePlaneCallback = None
945
946 self._loginResult = None
947 self._bookedFlight = None
948 self._departureGate = "-"
949 self._zfw = None
950 self._cruiseAltitude = None
951 self._route = None
952
953 self.setCurrentPage(0)
954
955 def _getFleet(self, callback, force = False):
956 """Get the fleet, if needed.
957
958 callback is function that will be called, when the feet is retrieved,
959 or the retrieval fails. It should have a single argument that will
960 receive the fleet object on success, None otherwise.
961 """
962 if self._fleet is not None and not force:
963 callback(self._fleet)
964
965 self.gui.beginBusy("Retrieving fleet...")
966 self._fleetCallback = callback
967 self.gui.webHandler.getFleet(self._fleetResultCallback)
968
969 def _fleetResultCallback(self, returned, result):
970 """Called when the fleet has been queried."""
971 gobject.idle_add(self._handleFleetResult, returned, result)
972
973 def _handleFleetResult(self, returned, result):
974 """Handle the fleet result."""
975 self.gui.endBusy()
976 if returned:
977 self._fleet = result.fleet
978 else:
979 self._fleet = None
980
981 dialog = gtk.MessageDialog(type = MESSAGETYPE_ERROR,
982 buttons = BUTTONSTYPE_OK,
983 message_format =
984 "Failed to retrieve the information on "
985 "the fleet.")
986 dialog.run()
987 dialog.hide()
988
989 self._fleetCallback(self._fleet)
990
991 def _updatePlane(self, callback, tailNumber, status, gateNumber = None):
992 """Update the given plane's gate information."""
993 self.gui.beginBusy("Updating plane status...")
994 self._updatePlaneCallback = callback
995 self.gui.webHandler.updatePlane(self._updatePlaneResultCallback,
996 tailNumber, status, gateNumber)
997
998 def _updatePlaneResultCallback(self, returned, result):
999 """Callback for the plane updating operation."""
1000 gobject.idle_add(self._handleUpdatePlaneResult, returned, result)
1001
1002 def _handleUpdatePlaneResult(self, returned, result):
1003 """Handle the result of a plane update operation."""
1004 self.gui.endBusy()
1005 if returned:
1006 success = result.success
1007 else:
1008 success = None
1009
1010 dialog = gtk.MessageDialog(type = MESSAGETYPE_ERROR,
1011 buttons = BUTTONSTYPE_OK,
1012 message_format =
1013 "Failed to update the statuis of "
1014 "the airplane.")
1015 dialog.run()
1016 dialog.hide()
1017
1018 self._updatePlaneCallback(success)
1019
1020 def _connectSimulator(self):
1021 """Connect to the simulator."""
1022 self.gui.connectSimulator(self._bookedFlight.aircraftType)
1023
1024#-----------------------------------------------------------------------------
1025
Note: See TracBrowser for help on using the repository browser.