source: src/mlx/gui/gui.py@ 99:b55ca557d5e9

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

The delay codes are handled
File size: 23.3 KB
RevLine 
[28]1# The main file for the GUI
2
[29]3from statusicon import StatusIcon
[32]4from statusbar import Statusbar
[90]5from info import FlightInfo
[36]6from update import Updater
[29]7from mlx.gui.common import *
[42]8from mlx.gui.flight import Wizard
[77]9from mlx.gui.monitor import MonitorWindow
[28]10
11import mlx.const as const
12import mlx.fs as fs
13import mlx.flight as flight
14import mlx.logger as logger
15import mlx.acft as acft
[41]16import mlx.web as web
[28]17
18import time
[38]19import threading
20import sys
[28]21
[77]22#------------------------------------------------------------------------------
23
[28]24class GUI(fs.ConnectionListener):
25 """The main GUI class."""
[96]26 @staticmethod
27 def _formatFlightLogLine(timeStr, line):
28 """Format the given line for flight logging."""
29 if timeStr is not None:
30 line = timeStr + ": " + line
31 return line + "\n"
32
[36]33 def __init__(self, programDirectory, config):
[28]34 """Construct the GUI."""
35 gobject.threads_init()
36
[36]37 self._programDirectory = programDirectory
[42]38 self.config = config
[28]39 self._connecting = False
[59]40 self._reconnecting = False
[28]41 self._connected = False
[96]42 self._logger = logger.Logger(self)
[28]43 self._flight = None
44 self._simulator = None
[59]45 self._monitoring = False
[38]46
47 self._stdioLock = threading.Lock()
48 self._stdioText = ""
[28]49
[41]50 self.webHandler = web.Handler()
51 self.webHandler.start()
52
[38]53 self.toRestart = False
54
[29]55 def build(self, iconDirectory):
[28]56 """Build the GUI."""
[29]57
[36]58 window = gtk.Window()
59 window.set_title("MAVA Logger X " + const.VERSION)
60 window.set_icon_from_file(os.path.join(iconDirectory, "logo.ico"))
61 window.connect("delete-event",
62 lambda a, b: self.hideMainWindow())
63 window.connect("window-state-event", self._handleMainWindowState)
[93]64 accelGroup = gtk.AccelGroup()
65 window.add_accel_group(accelGroup)
[28]66
67 mainVBox = gtk.VBox()
[36]68 window.add(mainVBox)
[28]69
[93]70 menuBar = self._buildMenuBar(accelGroup)
71 mainVBox.pack_start(menuBar, False, False, 0)
72
[92]73 self._notebook = gtk.Notebook()
[93]74 mainVBox.pack_start(self._notebook, True, True, 4)
[42]75
[46]76 self._wizard = Wizard(self)
[90]77 label = gtk.Label("Fligh_t")
[46]78 label.set_use_underline(True)
79 label.set_tooltip_text("Flight wizard")
[92]80 self._notebook.append_page(self._wizard, label)
[42]81
[90]82 self._flightInfo = FlightInfo(self)
83 label = gtk.Label("Flight _info")
84 label.set_use_underline(True)
85 label.set_tooltip_text("Flight information")
[92]86 self._notebook.append_page(self._flightInfo, label)
[93]87 self._flightInfo.disable()
[90]88
[93]89 (logWidget, self._logView) = self._buildLogWidget()
[46]90 label = gtk.Label("_Log")
91 label.set_use_underline(True)
[93]92 label.set_tooltip_text("The log of your flight that will be sent to the MAVA website")
93 self._notebook.append_page(logWidget, label)
94
95 (self._debugLogWidget, self._debugLogView) = self._buildLogWidget()
96 self._debugLogWidget.show_all()
[32]97
98 mainVBox.pack_start(gtk.HSeparator(), False, False, 0)
99
100 self._statusbar = Statusbar()
101 mainVBox.pack_start(self._statusbar, False, False, 0)
102
[92]103 self._notebook.connect("switch-page", self._notebookPageSwitch)
[46]104
[77]105 self._monitorWindow = MonitorWindow(self, iconDirectory)
[93]106 self._monitorWindow.add_accel_group(accelGroup)
[77]107 self._monitorWindowX = None
108 self._monitorWindowY = None
[93]109 self._selfToggling = False
[77]110
[46]111 window.show_all()
112 self._wizard.grabDefault()
[28]113
[36]114 self._mainWindow = window
[29]115
116 self._statusIcon = StatusIcon(iconDirectory, self)
[28]117
[49]118 self._busyCursor = gdk.Cursor(gdk.CursorType.WATCH if pygobject
119 else gdk.WATCH)
120
[59]121 @property
[97]122 def logger(self):
123 """Get the logger used by us."""
124 return self._logger
125
126 @property
[59]127 def simulator(self):
128 """Get the simulator used by us."""
129 return self._simulator
130
[71]131 @property
132 def flight(self):
133 """Get the flight being performed."""
134 return self._flight
[84]135
136 @property
[97]137 def bookedFlight(self):
138 """Get the booked flight selected, if any."""
139 return self._wizard.bookedFlight
140
141 @property
142 def cargoWeight(self):
143 """Get the cargo weight."""
144 return self._wizard.cargoWeight
145
146 @property
[84]147 def zfw(self):
148 """Get Zero-Fuel Weight calculated for the current flight."""
149 return self._wizard.zfw
150
151 @property
[97]152 def filedCruiseAltitude(self):
153 """Get cruise altitude filed for the current flight."""
154 return self._wizard.filedCruiseAltitude
155
156 @property
[84]157 def cruiseAltitude(self):
[97]158 """Get cruise altitude set for the current flight."""
[84]159 return self._wizard.cruiseAltitude
[97]160
161 @property
162 def route(self):
163 """Get the flight route."""
164 return self._wizard.route
165
166 @property
167 def departureMETAR(self):
168 """Get the METAR of the deprature airport."""
169 return self._wizard.departureMETAR
[84]170
171 @property
[97]172 def arrivalMETAR(self):
173 """Get the METAR of the deprature airport."""
174 return self._wizard.arrivalMETAR
175
176 @property
177 def departureRunway(self):
178 """Get the name of the departure runway."""
179 return self._wizard.departureRunway
180
181 @property
182 def sid(self):
183 """Get the SID."""
184 return self._wizard.sid
185
186 @property
[84]187 def v1(self):
188 """Get the V1 speed calculated for the flight."""
189 return self._wizard.v1
190
191 @property
192 def vr(self):
193 """Get the Vr speed calculated for the flight."""
194 return self._wizard.vr
195
196 @property
197 def v2(self):
198 """Get the V2 speed calculated for the flight."""
199 return self._wizard.v2
[71]200
[86]201 @property
[97]202 def arrivalRunway(self):
203 """Get the arrival runway."""
204 return self._wizard.arrivalRunway
205
206 @property
207 def star(self):
208 """Get the STAR."""
209 return self._wizard.star
210
211 @property
212 def transition(self):
213 """Get the transition."""
214 return self._wizard.transition
215
216 @property
217 def approachType(self):
218 """Get the approach type."""
219 return self._wizard.approachType
220
221 @property
[86]222 def vref(self):
223 """Get the Vref speed calculated for the flight."""
224 return self._wizard.vref
225
[97]226 @property
227 def flightType(self):
228 """Get the flight type."""
229 return self._wizard.flightType
230
231 @property
232 def online(self):
233 """Get whether the flight was online or not."""
234 return self._wizard.online
235
236 @property
237 def comments(self):
238 """Get the comments."""
239 return self._flightInfo.comments
240
241 @property
242 def flightDefects(self):
243 """Get the flight defects."""
244 return self._flightInfo.flightDefects
245
[99]246 @property
247 def delayCodes(self):
248 """Get the delay codes."""
249 return self._flightInfo.delayCodes
250
[28]251 def run(self):
252 """Run the GUI."""
[42]253 if self.config.autoUpdate:
[38]254 self._updater = Updater(self,
255 self._programDirectory,
[42]256 self.config.updateURL,
[36]257 self._mainWindow)
258 self._updater.start()
259
[28]260 gtk.main()
[36]261
[91]262 self._disconnect()
[28]263
264 def connected(self, fsType, descriptor):
265 """Called when we have connected to the simulator."""
266 self._connected = True
267 self._logger.untimedMessage("Connected to the simulator %s" % (descriptor,))
[59]268 gobject.idle_add(self._handleConnected, fsType, descriptor)
269
270 def _handleConnected(self, fsType, descriptor):
271 """Called when the connection to the simulator has succeeded."""
272 self._statusbar.updateConnection(self._connecting, self._connected)
273 self.endBusy()
274 if not self._reconnecting:
275 self._wizard.connected(fsType, descriptor)
276 self._reconnecting = False
277
278 def connectionFailed(self):
279 """Called when the connection failed."""
280 self._logger.untimedMessage("Connection to the simulator failed")
281 gobject.idle_add(self._connectionFailed)
282
283 def _connectionFailed(self):
284 """Called when the connection failed."""
285 self.endBusy()
286 self._statusbar.updateConnection(self._connecting, self._connected)
287
288 dialog = gtk.MessageDialog(type = MESSAGETYPE_ERROR,
289 message_format =
290 "Cannot connect to the simulator.",
291 parent = self._mainWindow)
292 dialog.format_secondary_markup("Rectify the situation, and press <b>Try again</b> "
293 "to try the connection again, "
294 "or <b>Cancel</b> to cancel the flight.")
295
296 dialog.add_button("_Cancel", 0)
297 dialog.add_button("_Try again", 1)
298 dialog.set_default_response(1)
299
300 result = dialog.run()
301 dialog.hide()
302 if result == 1:
303 self.beginBusy("Connecting to the simulator.")
304 self._simulator.reconnect()
305 else:
[91]306 self.reset()
[28]307
308 def disconnected(self):
309 """Called when we have disconnected from the simulator."""
310 self._connected = False
311 self._logger.untimedMessage("Disconnected from the simulator")
[59]312
313 gobject.idle_add(self._disconnected)
314
315 def _disconnected(self):
316 """Called when we have disconnected from the simulator unexpectedly."""
317 self._statusbar.updateConnection(self._connecting, self._connected)
318
319 dialog = gtk.MessageDialog(type = MESSAGETYPE_ERROR,
320 message_format =
321 "The connection to the simulator failed unexpectedly.",
322 parent = self._mainWindow)
323 dialog.format_secondary_markup("If the simulator has crashed, restart it "
324 "and restore your flight as much as possible "
325 "to the state it was in before the crash.\n"
326 "Then press <b>Reconnect</b> to reconnect.\n\n"
327 "If you want to cancel the flight, press <b>Cancel</b>.")
328
329 dialog.add_button("_Cancel", 0)
330 dialog.add_button("_Reconnect", 1)
331 dialog.set_default_response(1)
332
333 result = dialog.run()
334 dialog.hide()
335 if result == 1:
336 self.beginBusy("Connecting to the simulator.")
337 self._reconnecting = True
338 self._simulator.reconnect()
339 else:
[91]340 self.reset()
341
[93]342 def enableFlightInfo(self):
343 """Enable the flight info tab."""
344 self._flightInfo.enable()
345
[91]346 def reset(self):
347 """Reset the GUI."""
348 self._disconnect()
[92]349
[91]350 self._flightInfo.reset()
[93]351 self._flightInfo.disable()
[91]352 self.resetFlightStatus()
[28]353
[92]354 self._wizard.reset()
355 self._notebook.set_current_page(0)
356
357 self._logView.get_buffer().set_text("")
358
[91]359 def _disconnect(self):
360 """Disconnect from the simulator if connected."""
[92]361 self.stopMonitoring()
362
[91]363 if self._connected:
364 self._flight.simulator.disconnect()
365 self._connected = False
366
367 self._connecting = False
368 self._reconnecting = False
369 self._statusbar.updateConnection(False, False)
370
[96]371 def addFlightLogLine(self, timeStr, line):
372 """Write the given message line to the log."""
373 gobject.idle_add(self._writeLog,
374 GUI._formatFlightLogLine(timeStr, line),
375 self._logView)
376
377 def updateFlightLogLine(self, index, timeStr, line):
378 """Update the line with the given index."""
379 gobject.idle_add(self._updateFlightLogLine, index,
380 GUI._formatFlightLogLine(timeStr, line))
381
382 def _updateFlightLogLine(self, index, line):
383 """Replace the contents of the given line in the log."""
384 buffer = self._logView.get_buffer()
385 startIter = buffer.get_iter_at_line(index)
386 endIter = buffer.get_iter_at_line(index + 1)
387 buffer.delete(startIter, endIter)
388 buffer.insert(startIter, line)
389 self._logView.scroll_mark_onscreen(buffer.get_insert())
390
[28]391 def check(self, flight, aircraft, logger, oldState, state):
392 """Update the data."""
[77]393 gobject.idle_add(self._monitorWindow.setData, state)
[80]394 gobject.idle_add(self._statusbar.updateTime, state.timestamp)
[28]395
[31]396 def resetFlightStatus(self):
397 """Reset the status of the flight."""
[32]398 self._statusbar.resetFlightStatus()
[80]399 self._statusbar.updateTime()
[31]400 self._statusIcon.resetFlightStatus()
401
402 def setStage(self, stage):
403 """Set the stage of the flight."""
404 gobject.idle_add(self._setStage, stage)
405
406 def _setStage(self, stage):
407 """Set the stage of the flight."""
[32]408 self._statusbar.setStage(stage)
[31]409 self._statusIcon.setStage(stage)
[84]410 self._wizard.setStage(stage)
[88]411 if stage==const.STAGE_END:
[91]412 self._disconnect()
[31]413
414 def setRating(self, rating):
415 """Set the rating of the flight."""
416 gobject.idle_add(self._setRating, rating)
417
418 def _setRating(self, rating):
419 """Set the rating of the flight."""
[32]420 self._statusbar.setRating(rating)
[31]421 self._statusIcon.setRating(rating)
422
423 def setNoGo(self, reason):
424 """Set the rating of the flight to No-Go with the given reason."""
425 gobject.idle_add(self._setNoGo, reason)
426
427 def _setNoGo(self, reason):
428 """Set the rating of the flight."""
[32]429 self._statusbar.setNoGo(reason)
[31]430 self._statusIcon.setNoGo(reason)
431
[29]432 def _handleMainWindowState(self, window, event):
433 """Hande a change in the state of the window"""
434 iconified = gdk.WindowState.ICONIFIED if pygobject \
435 else gdk.WINDOW_STATE_ICONIFIED
436 if (event.changed_mask&iconified)!=0 and (event.new_window_state&iconified)!=0:
[35]437 self.hideMainWindow(savePosition = False)
[29]438
[35]439 def hideMainWindow(self, savePosition = True):
[29]440 """Hide the main window and save its position."""
[35]441 if savePosition:
442 (self._mainWindowX, self._mainWindowY) = \
443 self._mainWindow.get_window().get_root_origin()
444 else:
445 self._mainWindowX = self._mainWindowY = None
[29]446 self._mainWindow.hide()
447 self._statusIcon.mainWindowHidden()
448 return True
449
450 def showMainWindow(self):
451 """Show the main window at its former position."""
[35]452 if self._mainWindowX is not None and self._mainWindowY is not None:
453 self._mainWindow.move(self._mainWindowX, self._mainWindowY)
454
455 self._mainWindow.show()
[29]456 self._mainWindow.deiconify()
[35]457
[29]458 self._statusIcon.mainWindowShown()
459
460 def toggleMainWindow(self):
461 """Toggle the main window."""
462 if self._mainWindow.get_visible():
463 self.hideMainWindow()
464 else:
465 self.showMainWindow()
[36]466
[77]467 def hideMonitorWindow(self, savePosition = True):
468 """Hide the monitor window."""
469 if savePosition:
470 (self._monitorWindowX, self._monitorWindowY) = \
471 self._monitorWindow.get_window().get_root_origin()
472 else:
473 self._monitorWindowX = self._monitorWindowY = None
474 self._monitorWindow.hide()
475 self._statusIcon.monitorWindowHidden()
[93]476 if self._showMonitorMenuItem.get_active():
477 self._selfToggling = True
478 self._showMonitorMenuItem.set_active(False)
[77]479 return True
480
481 def showMonitorWindow(self):
482 """Show the monitor window."""
483 if self._monitorWindowX is not None and self._monitorWindowY is not None:
484 self._monitorWindow.move(self._monitorWindowX, self._monitorWindowY)
485 self._monitorWindow.show_all()
486 self._statusIcon.monitorWindowShown()
[93]487 if not self._showMonitorMenuItem.get_active():
488 self._selfToggling = True
489 self._showMonitorMenuItem.set_active(True)
490
491 def _toggleMonitorWindow(self, menuItem):
492 if self._selfToggling:
493 self._selfToggling = False
494 elif self._monitorWindow.get_visible():
495 self.hideMonitorWindow()
496 else:
497 self.showMonitorWindow()
[77]498
[38]499 def restart(self):
500 """Quit and restart the application."""
501 self.toRestart = True
[81]502 self._quit(force = True)
[38]503
504 def flushStdIO(self):
505 """Flush any text to the standard error that could not be logged."""
506 if self._stdioText:
507 sys.__stderr__.write(self._stdioText)
508
[36]509 def writeStdIO(self, text):
510 """Write the given text into standard I/O log."""
[38]511 with self._stdioLock:
512 self._stdioText += text
513
514 gobject.idle_add(self._writeStdIO)
[36]515
[49]516 def beginBusy(self, message):
517 """Begin a period of background processing."""
[93]518 self._wizard.set_sensitive(False)
[49]519 self._mainWindow.get_window().set_cursor(self._busyCursor)
520 self._statusbar.updateBusyState(message)
521
522 def endBusy(self):
523 """End a period of background processing."""
524 self._mainWindow.get_window().set_cursor(None)
[93]525 self._wizard.set_sensitive(True)
[49]526 self._statusbar.updateBusyState(None)
527
[38]528 def _writeStdIO(self):
[36]529 """Perform the real writing."""
[38]530 with self._stdioLock:
531 text = self._stdioText
532 self._stdioText = ""
533 if not text: return
534
[36]535 lines = text.splitlines()
536 if text[-1]=="\n":
537 text = ""
538 else:
539 text = lines[-1]
540 lines = lines[:-1]
541
542 for line in lines:
[96]543 #print >> sys.__stdout__, line
[93]544 self._writeLog(line + "\n", self._debugLogView)
[36]545
546 if text:
[96]547 #print >> sys.__stdout__, text,
[93]548 self._writeLog(text, self._debugLogView)
[51]549
[59]550 def connectSimulator(self, aircraftType):
551 """Connect to the simulator for the first time."""
552 self._logger.reset()
553
554 self._flight = flight.Flight(self._logger, self)
555 self._flight.aircraftType = aircraftType
556 self._flight.aircraft = acft.Aircraft.create(self._flight)
557 self._flight.aircraft._checkers.append(self)
558
559 if self._simulator is None:
560 self._simulator = fs.createSimulator(const.SIM_MSFS9, self)
561
562 self._flight.simulator = self._simulator
563
564 self.beginBusy("Connecting to the simulator...")
565 self._statusbar.updateConnection(self._connecting, self._connected)
566
567 self._connecting = True
568 self._simulator.connect(self._flight.aircraft)
569
[70]570 def startMonitoring(self):
571 """Start monitoring."""
[88]572 if not self._monitoring:
573 self.simulator.startMonitoring()
574 self._monitoring = True
[70]575
576 def stopMonitoring(self):
577 """Stop monitoring."""
[88]578 if self._monitoring:
579 self.simulator.stopMonitoring()
580 self._monitoring = False
[70]581
[93]582 def _buildMenuBar(self, accelGroup):
583 """Build the main menu bar."""
584 menuBar = gtk.MenuBar()
585
586 fileMenuItem = gtk.MenuItem("File")
587 fileMenu = gtk.Menu()
588 fileMenuItem.set_submenu(fileMenu)
589 menuBar.append(fileMenuItem)
590
591 quitMenuItem = gtk.ImageMenuItem(gtk.STOCK_QUIT)
592 quitMenuItem.set_use_stock(True)
593 quitMenuItem.add_accelerator("activate", accelGroup,
594 ord("q"), CONTROL_MASK,
595 ACCEL_VISIBLE)
596 quitMenuItem.connect("activate", self._quit)
597 fileMenu.append(quitMenuItem)
598
599
600 viewMenuItem = gtk.MenuItem("View")
601 viewMenu = gtk.Menu()
602 viewMenuItem.set_submenu(viewMenu)
603 menuBar.append(viewMenuItem)
[28]604
[93]605 self._showMonitorMenuItem = gtk.CheckMenuItem()
606 self._showMonitorMenuItem.set_label("Show _monitor window")
607 self._showMonitorMenuItem.set_use_underline(True)
608 self._showMonitorMenuItem.set_active(False)
609 self._showMonitorMenuItem.add_accelerator("activate", accelGroup,
610 ord("m"), CONTROL_MASK,
611 ACCEL_VISIBLE)
612 self._showMonitorMenuItem.connect("toggled", self._toggleMonitorWindow)
613 viewMenu.append(self._showMonitorMenuItem)
614
615 showDebugMenuItem = gtk.CheckMenuItem()
616 showDebugMenuItem.set_label("Show _debug log")
617 showDebugMenuItem.set_use_underline(True)
618 showDebugMenuItem.set_active(False)
619 showDebugMenuItem.add_accelerator("activate", accelGroup,
620 ord("d"), CONTROL_MASK,
621 ACCEL_VISIBLE)
622 showDebugMenuItem.connect("toggled", self._toggleDebugLog)
623 viewMenu.append(showDebugMenuItem)
[28]624
[93]625 return menuBar
[28]626
[93]627 def _toggleDebugLog(self, menuItem):
628 """Toggle the debug log."""
629 if menuItem.get_active():
630 label = gtk.Label("_Debug log")
631 label.set_use_underline(True)
632 label.set_tooltip_text("Log with debugging information.")
633 self._debugLogPage = self._notebook.append_page(self._debugLogWidget, label)
634 self._notebook.set_current_page(self._debugLogPage)
635 else:
636 self._notebook.remove_page(self._debugLogPage)
637
638 def _buildLogWidget(self):
639 """Build the widget for the log."""
640 alignment = gtk.Alignment(xscale = 1.0, yscale = 1.0)
641
642 alignment.set_padding(padding_top = 8, padding_bottom = 8,
643 padding_left = 16, padding_right = 16)
[28]644
645 logScroller = gtk.ScrolledWindow()
[93]646 # FIXME: these should be constants in common
647 logScroller.set_policy(gtk.PolicyType.AUTOMATIC if pygobject
648 else gtk.POLICY_AUTOMATIC,
649 gtk.PolicyType.AUTOMATIC if pygobject
650 else gtk.POLICY_AUTOMATIC)
651 logScroller.set_shadow_type(gtk.ShadowType.IN if pygobject
652 else gtk.SHADOW_IN)
653 logView = gtk.TextView()
654 logView.set_editable(False)
655 logScroller.add(logView)
[28]656
657 logBox = gtk.VBox()
658 logBox.pack_start(logScroller, True, True, 0)
659 logBox.set_size_request(-1, 200)
660
[93]661 alignment.add(logBox)
[28]662
[93]663 return (alignment, logView)
[28]664
[93]665 def _writeLog(self, msg, logView):
[28]666 """Write the given message to the log."""
[93]667 buffer = logView.get_buffer()
[28]668 buffer.insert(buffer.get_end_iter(), msg)
[93]669 logView.scroll_mark_onscreen(buffer.get_insert())
[28]670
[81]671 def _quit(self, what = None, force = False):
[38]672 """Quit from the application."""
[81]673 if force:
674 result=RESPONSETYPE_YES
675 else:
676 dialog = gtk.MessageDialog(type = MESSAGETYPE_QUESTION,
677 buttons = BUTTONSTYPE_YES_NO,
678 message_format =
679 "Are you sure to quit the logger?")
680 result = dialog.run()
681 dialog.hide()
[76]682
683 if result==RESPONSETYPE_YES:
684 self._statusIcon.destroy()
685 return gtk.main_quit()
[38]686
[46]687 def _notebookPageSwitch(self, notebook, page, page_num):
688 """Called when the current page of the notebook has changed."""
689 if page_num==0:
[48]690 gobject.idle_add(self._wizard.grabDefault)
[46]691 else:
692 self._mainWindow.set_default(None)
Note: See TracBrowser for help on using the repository browser.