Changeset 166:e4ba22b7a13b for src

Timestamp:

05/10/12 18:17:18 (13 years ago)

Author:

István Váradi <ivaradi@…>

Branch:

default

Phase:

public

Message:

The configuration loading/saving and the basic GUI for the sound preferences work

Location:

src/mlx

Files:

• config.py (modified) (5 diffs)
• gui/prefs.py (modified) (9 diffs)
• i18n.py (modified) (3 diffs)

src/mlx/config.py

@@ -20 +20 @@
     _languageMap = { "en_GB" : "eng",
                      "hu_HU" : "hun" }
+
+#-------------------------------------------------------------------------------
+
+class Hotkey(object):
+    """A hotkey."""
+    def __init__(self, ctrl = False, shift = False, key = "0"):
+        """Construct the hotkey."""
+        self.ctrl = ctrl
+        self.shift = shift
+        self.key = key
+
+    def set(self, s):
+        """Set the hotkey from the given string."""
+        self.ctrl = "C" in s[:-1]
+        self.shift = "S" in s[:-1]
+        self.key = s[-1]
+
+    def __eq__(self, other):
+        """Check if the given hotkey is equal to the other one."""
+        return self.ctrl == other.ctrl and self.shift == other.shift and \
+               self.key == other.key
+
+    def __str__(self):
+        """Construct the hotkey to a string."""
+        s = ""
+        if self.ctrl: s += "C"
+        if self.shift: s += "S"
+        s += self.key
+        return s
 
 #-------------------------------------------------------------------------------
@@ -44 +73 @@
 
         self._pirepDirectory = None
-        
+
+        self._enableSounds = True
+
+        self._pilotControlsSounds = True
+        self._pilotHotkey = Hotkey(ctrl = True, shift = False, key = "0")
+
+        #self._approachCallOuts = False
+        self._speedbrakeAtTD = True
+
+        self._enableChecklists = False
+        self._checklistHotkey = Hotkey(ctrl = True, shift = True, key = "0")
+                
         self._autoUpdate = True        
         self._updateURL = Config.DEFAULT_UPDATE_URL
@@ -196 +236 @@
            self._messageTypeLevels[messageType]!=level:
             self._messageTypeLevels[messageType] = level
+            self._modified = True
+
+    @property
+    def enableSounds(self):
+        """Get whether background sounds are enabled."""
+        return self._enableSounds
+
+    @enableSounds.setter
+    def enableSounds(self, enableSounds):
+        """Set whether background sounds are enabled."""
+        if enableSounds!=self._enableSounds:
+            self._enableSounds = enableSounds
+            self._modified = True
+
+    @property 
+    def pilotControlsSounds(self):
+        """Get whether the pilot controls the background sounds."""
+        return self._pilotControlsSounds
+
+    @pilotControlsSounds.setter
+    def pilotControlsSounds(self, pilotControlsSounds):
+        """Set whether the pilot controls the background sounds."""
+        if pilotControlsSounds!=self._pilotControlsSounds:
+            self._pilotControlsSounds = pilotControlsSounds
+            self._modified = True
+
+    @property
+    def pilotHotkey(self):
+        """Get the pilot's hotkey."""
+        return self._pilotHotkey
+
+    @pilotHotkey.setter
+    def pilotHotkey(self, pilotHotkey):
+        """Set the pilot's hotkey."""
+        if pilotHotkey!=self._pilotHotkey:
+            self._pilotHotkey = pilotHotkey
+            self._modified = True
+
+    # @property
+    # def approachCallOuts(self):
+    #     """Get whether the approach callouts should be played."""
+    #     return self._approachCallOuts
+
+    # @approachCallOuts.setter
+    # def approachCallOuts(self, approachCallOuts):
+    #     """Set whether the approach callouts should be played."""
+    #     if approachCallOuts!=self._approachCallOuts:
+    #         self._approachCallOuts = approachCallOuts
+    #         self._modified = True
+
+    @property
+    def speedbrakeAtTD(self):
+        """Get whether the speedbrake sounds should be played at touchdown."""
+        return self._speedbrakeAtTD
+
+    @speedbrakeAtTD.setter
+    def speedbrakeAtTD(self, speedbrakeAtTD):
+        """Set whether the speedbrake sounds should be played at touchdown."""
+        if speedbrakeAtTD!=self._speedbrakeAtTD:
+            self._speedbrakeAtTD = speedbrakeAtTD
+            self._modified = True
+        
+    @property
+    def enableChecklists(self):
+        """Get whether aircraft-specific checklists should be played."""
+        return self._enableChecklists
+
+    @enableChecklists.setter
+    def enableChecklists(self, enableChecklists):
+        """Get whether aircraft-specific checklists should be played."""
+        if enableChecklists!=self._enableChecklists:
+            self._enableChecklists = enableChecklists
+            self._modified = True
+
+    @property
+    def checklistHotkey(self):
+        """Get the checklist hotkey."""
+        return self._checklistHotkey
+
+    @checklistHotkey.setter
+    def checklistHotkey(self, checklistHotkey):
+        """Set the checklist hotkey."""
+        if checklistHotkey!=self._checklistHotkey:
+            self._checklistHotkey = checklistHotkey
             self._modified = True
 
@@ -254 +378 @@
             self._messageTypeLevels[messageType] = \
                 self._getMessageTypeLevel(config, messageType)
+
+        self._enableSounds = self._getBoolean(config, "sounds",
+                                              "enable", True)
+        self._pilotControlsSounds = self._getBoolean(config, "sounds",
+                                                     "pilotControls", True)
+        self._pilotHotkey.set(self._get(config, "sounds",
+                                        "pilotHotkey", "C0"))
+        #self._approachCallOuts = self._getBoolean(config, "sounds",
+        #                                          "approachCallOuts", False)
+        self._speedbrakeAtTD = self._getBoolean(config, "sounds",
+                                                "speedbrakeAtTD", True)
+
+        self._enableChecklists = self._getBoolean(config, "sounds",
+                                                  "enableChecklists", False)
+        self._checklistHotkey.set(self._get(config, "sounds",
+                                            "checklistHotkey", "CS0"))
             
         self._autoUpdate = self._getBoolean(config, "update", "auto", True)
@@ -298 +438 @@
                 config.set(Config._messageTypesSection, option,
                            const.messageLevel2string(level))
+
+        config.add_section("sounds")
+        config.set("sounds", "enable",
+                   "yes" if self._enableSounds else "no")
+        config.set("sounds", "pilotControls",
+                   "yes" if self._pilotControlsSounds else "no")
+        config.set("sounds", "pilotHotkey", str(self._pilotHotkey))
+        #config.set("sounds", "approachCallOuts",
+        #           "yes" if self._approachCallOuts else "no")
+        config.set("sounds", "speedbrakeAtTD",
+                   "yes" if self._speedbrakeAtTD else "no")
+
+        config.set("sounds", "enableChecklists",
+                   "yes" if self._enableChecklists else "no")
+        config.set("sounds", "checklistHotkey",
+                   str(self._checklistHotkey))
         
         config.add_section("update")

src/mlx/gui/prefs.py

@@ -7 +7 @@
 from mlx.i18n import xstr
 import mlx.const as const
+import mlx.config as config
 
 import urlparse
+
+#------------------------------------------------------------------------------
+
+class Hotkey(gtk.HBox):
+    """A widget to handle a hotkey."""
+    def __init__(self, labelText, tooltips):
+        """Construct the hotkey widget.
+
+        labelText is the text for the label before the hotkey.
+
+        The tooltips parameter is an array of the tooltips for:
+        - the hotkey combo box,
+        - the control check box, and
+        - the shift check box."""
+        super(Hotkey, self).__init__()
+        
+        label = gtk.Label(labelText)
+        label.set_use_underline(True)
+        labelAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
+                                       xscale = 0.0, yscale = 0.0)
+        labelAlignment.add(label)
+        self.pack_start(labelAlignment, False, False, 8)
+
+        self._ctrl = gtk.CheckButton("Ctrl")
+        self._ctrl.set_tooltip_text(tooltips[1])
+        self.pack_start(self._ctrl, False, False, 4)
+            
+        self._shift = gtk.CheckButton("Shift")
+        self._shift.set_tooltip_text(tooltips[2])
+        self.pack_start(self._shift, False, False, 4)
+
+        self._hotkeyModel = gtk.ListStore(str)
+        for keyCode in range(ord("0"), ord("9")) + range(ord("A"), ord("Z")):
+            self._hotkeyModel.append([chr(keyCode)])
+
+        self._hotkey = gtk.ComboBox(model = self._hotkeyModel)
+        cell = gtk.CellRendererText()
+        self._hotkey.pack_start(cell, True)
+        self._hotkey.add_attribute(cell, 'text', 0)
+        self._hotkey.set_tooltip_text(tooltips[0])
+        self.pack_start(self._hotkey, False, False, 4)
+
+        self._setting = False
+
+    def set(self, hotkey):
+        """Set the hotkey widget from the given hotkey."""
+        self._setting = True
+
+        self._ctrl.set_active(hotkey.ctrl)
+        self._shift.set_active(hotkey.shift)
+
+        hotkeyModel = self._hotkeyModel
+        iter = hotkeyModel.get_iter_first()
+        while iter is not None and \
+              hotkeyModel.get_value(iter, 0)!=hotkey.key:
+            iter = hotkeyModel.iter_next(iter)
+
+        if iter is None:
+            iter = hotkeyModel.get_iter_first()
+
+        self._hotkey.set_active_iter(iter)            
+        
+        self._setting = False
+
+    def get(self):
+        """Get a hotkey corresponding to the settings in the widghet."""
+
+        key = self._hotkeyModel.get_value(self._hotkey.get_active_iter(), 0)
+
+        return config.Hotkey(ctrl = self._ctrl.get_active(),
+                             shift = self._shift.get_active(),
+                             key = key)
 
 #------------------------------------------------------------------------------
@@ -25 +98 @@
         
         self._gui = gui
+        self._settingFromConfig = False
 
         contentArea = self.get_content_area()
@@ -42 +116 @@
         label.set_tooltip_text(xstr("prefs_tab_message_tooltip"))
         notebook.append_page(messages, label)
+
+        sounds = self._buildSounds()
+        label = gtk.Label(xstr("prefs_tab_sounds"))
+        label.set_use_underline(True)
+        label.set_tooltip_text(xstr("prefs_tab_sounds_tooltip"))
+        notebook.append_page(sounds, label)
 
         advanced = self._buildAdvanced()
@@ -66 +146 @@
     def _fromConfig(self, config):
         """Setup the dialog from the given configuration."""
+        self._settingFromConfig = True
+
         self._setLanguage(config.language)
         self._hideMinimizedWindow.set_active(config.hideMinimizedWindow)
@@ -86 +168 @@
                               level == const.MESSAGELEVEL_BOTH)
 
-        self._togglingAutoUpdate = True
+        self._enableSounds.set_active(config.enableSounds)
+        self._pilotControlsSounds.set_active(config.pilotControlsSounds)
+        self._pilotHotkey.set(config.pilotHotkey)
+        #self._approachCallOuts.set_active(config.approachCallOuts)
+        self._speedbrakeAtTD.set_active(config.speedbrakeAtTD)
+
+        self._enableChecklists.set_active(config.enableChecklists)        
+        self._checklistHotkey.set(config.checklistHotkey)
+
         self._autoUpdate.set_active(config.autoUpdate)
-        self._togglingAutoUpdate = False
         if not config.autoUpdate:
             self._warnedAutoUpdate = True
 
         self._updateURL.set_text(config.updateURL)
+
+        self._settingFromConfig = False
 
     def _toConfig(self, config):
@@ -115 +206 @@
                 level = const.MESSAGELEVEL_NONE
             config.setMessageTypeLevel(messageType, level)
+
+        config.enableSounds = self._enableSounds.get_active()
+        config.pilotControlsSounds = self._pilotControlsSounds.get_active()
+        config.pilotHotkey = self._pilotHotkey.get()
+        #config.approachCallOuts = self._approachCallOuts.get_active()
+        config.speedbrakeAtTD = self._speedbrakeAtTD.get_active()
+
+        config.enableChecklists = self._enableChecklists.get_active()
+        config.checklistHotkey = self._checklistHotkey.get()
 
         config.autoUpdate = self._autoUpdate.get_active()
@@ -330 +430 @@
 
         return True
-            
+
+    def _buildSounds(self):
+        """Build the page for the sounds."""
+        mainAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
+                                      xscale = 1.0, yscale = 1.0)
+        mainAlignment.set_padding(padding_top = 8, padding_bottom = 8,
+                                  padding_left = 4, padding_right = 4)
+
+        mainBox = gtk.VBox()
+        mainAlignment.add(mainBox)
+
+        backgroundFrame = gtk.Frame(label = xstr("prefs_sounds_frame_bg"))
+        mainBox.pack_start(backgroundFrame, False, False, 4)
+
+        backgroundAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
+                                            xscale = 1.0, yscale = 0.0)
+        backgroundAlignment.set_padding(padding_top = 4, padding_bottom = 4,
+                                        padding_left = 4, padding_right = 4)
+        backgroundFrame.add(backgroundAlignment)
+
+        backgroundBox = gtk.VBox()
+        backgroundAlignment.add(backgroundBox)
+
+        self._enableSounds = gtk.CheckButton(xstr("prefs_sounds_enable"))
+        self._enableSounds.set_use_underline(True)
+        self._enableSounds.set_tooltip_text(xstr("prefs_sounds_enable_tooltip"))
+        self._enableSounds.connect("toggled", self._enableSoundsToggled)
+        alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
+                                  xscale = 1.0, yscale = 0.0)
+        alignment.add(self._enableSounds)
+        backgroundBox.pack_start(alignment, False, False, 4)
+
+        self._pilotControlsSounds = gtk.CheckButton(xstr("prefs_sounds_pilotControls"))
+        self._pilotControlsSounds.set_use_underline(True)
+        self._pilotControlsSounds.set_tooltip_text(xstr("prefs_sounds_pilotControls_tooltip"))
+        backgroundBox.pack_start(self._pilotControlsSounds, False, False, 4)
+
+        self._pilotHotkey = Hotkey(xstr("prefs_sounds_pilotHotkey"),
+                                   [xstr("prefs_sounds_pilotHotkey_tooltip"),
+                                    xstr("prefs_sounds_pilotHotkeyCtrl_tooltip"),
+                                    xstr("prefs_sounds_pilotHotkeyShift_tooltip")])
+        
+        backgroundBox.pack_start(self._pilotHotkey, False, False, 4)
+
+        # self._approachCallOuts = gtk.CheckButton(xstr("prefs_sounds_approachCallOuts"))
+        # self._approachCallOuts.set_use_underline(True)
+        # self._approachCallOuts.set_tooltip_text(xstr("prefs_sounds_approachCallOuts_tooltip"))
+        # backgroundBox.pack_start(self._approachCallOuts, False, False, 4)
+        
+        self._speedbrakeAtTD = gtk.CheckButton(xstr("prefs_sounds_speedbrakeAtTD"))
+        self._speedbrakeAtTD.set_use_underline(True)
+        self._speedbrakeAtTD.set_tooltip_text(xstr("prefs_sounds_speedbrakeAtTD_tooltip"))
+        backgroundBox.pack_start(self._speedbrakeAtTD, False, False, 4)
+
+        checklistFrame = gtk.Frame(label = xstr("prefs_sounds_frame_checklists"))
+        mainBox.pack_start(checklistFrame, False, False, 4)
+
+        checklistAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
+                                           xscale = 1.0, yscale = 0.0)
+        checklistAlignment.set_padding(padding_top = 4, padding_bottom = 4,
+                                       padding_left = 4, padding_right = 4)
+        checklistFrame.add(checklistAlignment)
+
+        checklistBox = gtk.VBox()
+        checklistAlignment.add(checklistBox)
+        
+        self._enableChecklists = gtk.CheckButton(xstr("prefs_sounds_enableChecklists"))
+        self._enableChecklists.set_use_underline(True)
+        self._enableChecklists.set_tooltip_text(xstr("prefs_sounds_enableChecklists_tooltip"))
+        self._enableChecklists.connect("toggled", self._enableChecklistsToggled)
+        checklistBox.pack_start(self._enableChecklists, False, False, 4)
+
+        self._checklistHotkey = Hotkey(xstr("prefs_sounds_checklistHotkey"),
+                                       [xstr("prefs_sounds_checklistHotkey_tooltip"),
+                                        xstr("prefs_sounds_checklistHotkeyCtrl_tooltip"),
+                                        xstr("prefs_sounds_checklistHotkeyShift_tooltip")])
+
+        checklistBox.pack_start(self._checklistHotkey, False, False, 4)
+
+        self._enableSoundsToggled(self._enableSounds)
+        self._enableChecklistsToggled(self._enableChecklists)
+
+        return mainAlignment
+
+    def _enableSoundsToggled(self, button):
+        """Called when the enable sounds button is toggled."""
+        active = button.get_active()
+        self._pilotControlsSounds.set_sensitive(active)
+        self._pilotHotkey.set_sensitive(active)
+        #self._approachCallOuts.set_sensitive(active)
+        self._speedbrakeAtTD.set_sensitive(active)
+
+    def _enableChecklistsToggled(self, button):
+        """Called when the enable checklists button is toggled."""
+        active = button.get_active()
+        self._checklistHotkey.set_sensitive(active)
+
     def _buildAdvanced(self):
         """Build the page for the advanced settings."""
@@ -348 +544 @@
         self._autoUpdate.set_tooltip_text(xstr("prefs_update_auto_tooltip"))
         self._warnedAutoUpdate = False
-        self._togglingAutoUpdate = False
         
         updateURLBox = gtk.HBox()
@@ -379 +574 @@
     def _autoUpdateToggled(self, button):
         """Called when the auto update check button is toggled."""
-        if not self._togglingAutoUpdate and not self._warnedAutoUpdate and \
+        if not self._settingFromConfig and not self._warnedAutoUpdate and \
            not self._autoUpdate.get_active():
             dialog = gtk.MessageDialog(parent = self,

src/mlx/i18n.py

@@ -568 +568 @@
         self.add("prefs_tab_message_tooltip",
                  "Enable/disable message notifications in FS and/or by sound")
+        self.add("prefs_tab_sounds", "_Sounds")
+        self.add("prefs_tab_sounds_tooltip",
+                 "Preferences regarding what sounds should be played during the various flight stages")
         self.add("prefs_tab_advanced", "_Advanced")
         self.add("prefs_tab_advanced_tooltip",
@@ -604 +607 @@
                  "from timestamps returned by the simulator.")
         self.add("prefs_syncFSTime",
-                 "_Synchronize the time in FS with the computer's clock")
+                 "S_ynchronize the time in FS with the computer's clock")
         self.add("prefs_syncFSTime_tooltip",
                  "If this is checked the flight simulator's internal clock "
@@ -615 +618 @@
         self.add("prefs_pirepDirectory_browser_title",
                  "Select PIREP directory")
+
+        self.add("prefs_sounds_frame_bg", "Background")
+        self.add("prefs_sounds_enable",
+                 "_Enable background sounds")
+        self.add("prefs_sounds_enable_tooltip",
+                 "If the background sounds are enabled, the logger "
+                 "can play different pre-recorded sounds during the "
+                 "various stages of the flight.")
+        self.add("prefs_sounds_pilotControls",
+                 "_Pilot controls the sounds")
+        self.add("prefs_sounds_pilotControls_tooltip",
+                 "If checked, the background sounds can be started by the "
+                 "pilot by pressing the hotkey specified below. Otherwise "
+                 "the sounds will start automatically when certain "
+                 "conditions hold.")
+        self.add("prefs_sounds_pilotHotkey",
+                 "_Hotkey:")
+        self.add("prefs_sounds_pilotHotkey_tooltip",
+                 "The key to press possibly together with modifiers to play "
+                 "the sound relevant to the current flight status.")
+        self.add("prefs_sounds_pilotHotkeyCtrl_tooltip",
+                 "If checked, the Ctrl key should be pressed together with the "
+                 "main key.")
+        self.add("prefs_sounds_pilotHotkeyShift_tooltip",
+                 "If checked, the Shift key should be pressed together with the "
+                 "main key.")
+        self.add("prefs_sounds_approachCallOuts",
+                 "Enable approach callouts")
+        self.add("prefs_sounds_approachCallOuts_tooltip",
+                 "If checked, the approach callouts will be played at "
+                 "certain altitudes.")
+        self.add("prefs_sounds_speedbrakeAtTD",
+                 "Enable speed_brake sound at touchdown")
+        self.add("prefs_sounds_speedbrakeAtTD_tooltip",
+                 "If checked, a speedbrake sound will be played after "
+                 "touchdown, when the speedbrakes deploy.")
+        self.add("prefs_sounds_frame_checklists", "Checklists")
+        self.add("prefs_sounds_enableChecklists",
+                 "E_nable aircraft-specific checklists")
+        self.add("prefs_sounds_enableChecklists_tooltip",
+                 "If checked, the program will play back pre-recorded "
+                 "aircraft-specific checklists at the pilot's discretion.")
+        self.add("prefs_sounds_checklistHotkey",
+                 "Checklist hot_key:")
+        self.add("prefs_sounds_checklistHotkey_tooltip",
+                 "The key to press possibly together with modifiers to play the next "
+                 "checklist item.")
+        self.add("prefs_sounds_checklistHotkeyCtrl_tooltip",
+                 "If checked, the Ctrl key should be pressed together with the "
+                 "main key.")
+        self.add("prefs_sounds_checklistHotkeyShift_tooltip",
+                 "If checked, the Shift key should be pressed together with the "
+                 "main key.")
+        
         self.add("prefs_update_auto", "Update the program auto_matically")
         self.add("prefs_update_auto_tooltip",