source: src/mlx/gui/gui.py@ 123:3b181cd0ab99

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

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