#7248 speaker icon consistency fixes

4 files changed, 90 insertions, 26 deletions

diff --git a/src/hardware/hardwaremanager.py b/src/hardware/hardwaremanager.py
index 2f92537..02b2e26 100644
--- a/src/hardware/hardwaremanager.py
+++ b/src/hardware/hardwaremanager.py
@@ -17,6 +17,7 @@
 import logging
 
 import dbus
+import gobject
 import gst
 import gst.interfaces
 
@@ -31,8 +32,21 @@ _HARDWARE_MANAGER_OBJECT_PATH = '/org/laptop/HardwareManager'
 COLOR_MODE = 0
 B_AND_W_MODE = 1
 
-class HardwareManager(object):
+VOL_CHANGE_INCREMENT_RECOMMENDATION = 10
+
+class HardwareManager(gobject.GObject):
+    __gsignals__ = {
+        'muted-changed' : (gobject.SIGNAL_RUN_FIRST,
+                           gobject.TYPE_NONE,
+                           ([gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN])),
+        'volume-changed': (gobject.SIGNAL_RUN_FIRST,
+                           gobject.TYPE_NONE,
+                           ([gobject.TYPE_INT, gobject.TYPE_INT])),
+    }
+
     def __init__(self):
+        gobject.GObject.__init__(self)
+
         try:
             bus = dbus.SystemBus()
             proxy = bus.get_object(_HARDWARE_MANAGER_SERVICE,
@@ -50,6 +64,14 @@ class HardwareManager(object):
             if track.flags & gst.interfaces.MIXER_TRACK_MASTER:
                 self._master = track
 
+    def __muted_changed_cb(self, old_state, new_state):
+        if old_state != new_state:
+            self.emit('muted-changed', old_state, new_state)
+
+    def __volume_changed_cb(self, old_volume, new_volume):
+        if old_volume != new_volume:
+            self.emit('volume-changed', old_volume, new_volume)
+
     def get_muted(self):
         if not self._mixer or not self._master:
             logging.error('Cannot get the mute status')
@@ -70,7 +92,7 @@ class HardwareManager(object):
         #sometimes we get a spurious zero from one/more channel(s)
         #TODO: consider removing this when trac #6933 is resolved
         nonzero_volumes = [v for v in volumes if v > 0]
-        
+
         if len(nonzero_volumes) > 0:
             #we could just pick the first nonzero volume, but this converges
             volume = sum(nonzero_volumes) / len(nonzero_volumes)
@@ -78,20 +100,22 @@ class HardwareManager(object):
         else:
             return 0
 
-    def set_volume(self, volume):
+    def set_volume(self, new_volume):
         if not self._mixer or not self._master:
             logging.error('Cannot set the volume')
             return
 
-        if volume < 0 or volume > 100:
+        if new_volume < 0 or new_volume > 100:
             logging.error('Trying to set an invalid volume value.')
             return
 
+        old_volume = self.get_volume()
         max_volume = self._master.max_volume
         min_volume = self._master.min_volume
 
-        volume = volume * (max_volume - min_volume) / 100.0 + min_volume
-        volume_list = [ volume ] * self._master.num_channels
+        new_volume_mixer_range = min_volume + \
+            (new_volume * ((max_volume - min_volume) / 100.0))
+        volume_list = [ new_volume_mixer_range ] * self._master.num_channels
 
         #sometimes alsa sets one/more channels' volume to zero instead
         # of what we asked for, so try a few times
@@ -103,11 +127,15 @@ class HardwareManager(object):
             last_volumes_read = self._mixer.get_volume(self._master)
             read_count += 1
 
-    def set_muted(self, mute):
+        self.emit('volume-changed', old_volume, new_volume)
+
+    def set_muted(self, new_state):
         if not self._mixer or not self._master:
             logging.error('Cannot mute the audio channel')
-        else:
-            self._mixer.set_mute(self._master, mute)
+            return
+        old_state = self.get_muted()
+        self._mixer.set_mute(self._master, new_state)
+        self.emit('muted-changed', old_state, new_state)
 
     def startup(self):
         if env.is_emulator() is False:
@@ -119,7 +147,7 @@ class HardwareManager(object):
             profile = get_profile()
             profile.sound_volume = self.get_volume()
             profile.save()
-    
+
     def set_dcon_freeze(self, frozen):
         if not self._service:
             return
@@ -153,7 +181,7 @@ class HardwareManager(object):
         if self._service.get_keyboard_brightness():
             self._service.set_keyboard_brightness(False)
         else:
-            self._service.set_keyboard_brightness(True)            
+            self._service.set_keyboard_brightness(True)
 
 def get_manager():
     return _manager
diff --git a/src/model/devices/speaker.py b/src/model/devices/speaker.py
index 683849d..c2a3a18 100644
--- a/src/model/devices/speaker.py
+++ b/src/model/devices/speaker.py
@@ -28,20 +28,26 @@ class Device(device.Device):
     def __init__(self):
         device.Device.__init__(self)
         self._manager = hardwaremanager.get_manager()
+        self._manager.connect('muted-changed', self.__muted_changed_cb)
+        self._manager.connect('volume-changed', self.__volume_changed_cb)
+
+    def __muted_changed_cb(self, sender_, old_state_, new_state_):
+        self.notify('muted')
+
+    def __volume_changed_cb(self, sender_, old_volume_, new_volume_):
+        self.notify('level')
 
     def _get_level(self):
         return self._manager.get_volume()
 
     def _set_level(self, new_volume):
         self._manager.set_volume(new_volume)
-        self.notify('level')
 
     def _get_muted(self):
         return self._manager.get_muted()
 
     def _set_muted(self, mute):
         self._manager.set_muted(mute)
-        self.notify('muted')
 
     def get_type(self):
         return 'speaker'
diff --git a/src/view/devices/speaker.py b/src/view/devices/speaker.py
index a7efb26..e01a179 100644
--- a/src/view/devices/speaker.py
+++ b/src/view/devices/speaker.py
@@ -18,6 +18,7 @@ from gettext import gettext as _
 
 import gtk
 
+from hardware import hardwaremanager
 from sugar import profile
 from sugar.graphics import style
 from sugar.graphics.icon import get_icon_state, Icon
@@ -60,10 +61,10 @@ class DeviceView(TrayIcon):
         self.icon.props.icon_name = get_icon_state(name, current_level, step=1)
         self.icon.props.xo_color = xo_color
 
-    def __speaker_status_changed_cb(self, pspec, param):
+    def __expose_event_cb(self, *args):
         self._update_info()
 
-    def __expose_event_cb(self, *args):
+    def __speaker_status_changed_cb(self, pspec_, param_):
         self._update_info()
 
 class SpeakerPalette(Palette):
@@ -79,10 +80,13 @@ class SpeakerPalette(Palette):
         self.set_content(vbox)
         vbox.show()
 
+        vol_step = hardwaremanager.VOL_CHANGE_INCREMENT_RECOMMENDATION
         self._adjustment = gtk.Adjustment(value=self._model.props.level,
-                                          lower=0.0, upper=101.0,
-                                          step_incr=1,
-                                          page_incr=1, page_size=1)
+                                          lower=0,
+                                          upper=100 + vol_step,
+                                          step_incr=vol_step,
+                                          page_incr=vol_step,
+                                          page_size=vol_step)
         self._hscale = gtk.HScale(self._adjustment)
         self._hscale.set_digits(0)
         self._hscale.set_draw_value(False)
@@ -95,11 +99,19 @@ class SpeakerPalette(Palette):
         self.menu.append(self._mute_item)
         self._mute_item.show()
 
-        self._adjustment.connect('value_changed', self.__adjustment_changed_cb)
+        self._adjustment_handler_id = \
+            self._adjustment.connect('value_changed',
+                                     self.__adjustment_changed_cb)
+
+        self._model_notify_level_handler_id = \
+            self._model.connect('notify::level', self.__level_changed_cb)
+        self._model.connect('notify::muted', self.__muted_changed_cb)
+
         self._mute_item.connect('activate', self.__mute_activate_cb)
+
         self.connect('popup', self.__popup_cb)
 
-    def _update_info(self):
+    def _update_muted(self):
         if self._model.props.muted:
             mute_item_text = _('Unmute')
             mute_item_icon_name = 'dialog-ok'
@@ -109,13 +121,31 @@ class SpeakerPalette(Palette):
         self._mute_item.get_child().set_text(mute_item_text)
         self._mute_icon.props.icon_name = mute_item_icon_name
 
+    def _update_level(self):
+        if self._adjustment.value != self._model.props.level:
+            self._adjustment.handler_block(self._adjustment_handler_id)
+            try:
+                self._adjustment.value = self._model.props.level
+            finally:
+                self._adjustment.handler_unblock(self._adjustment_handler_id)
+
     def __adjustment_changed_cb(self, adj_):
-        self._model.props.level = self._adjustment.value
+        self._model.handler_block(self._model_notify_level_handler_id)
+        try:
+            self._model.props.level = self._adjustment.value
+        finally:
+            self._model.handler_unblock(self._model_notify_level_handler_id)
+        self._model.props.muted = self._adjustment.value == 0
 
-    def __popup_cb(self, palette_):
-        if self._adjustment.value != self._model.props.level:
-            self._adjustment.value = self._model.props.level
-        self._update_info()
+    def __level_changed_cb(self, pspec_, param_):
+        self._update_level()
 
     def __mute_activate_cb(self, menuitem_):
         self._model.props.muted = not self._model.props.muted
+
+    def __muted_changed_cb(self, pspec_, param_):
+        self._update_muted()
+
+    def __popup_cb(self, palette_):
+        self._update_level()
+        self._update_muted()
diff --git a/src/view/keyhandler.py b/src/view/keyhandler.py
index c7d3001..44ea759 100644
--- a/src/view/keyhandler.py
+++ b/src/view/keyhandler.py
@@ -31,7 +31,7 @@ from view.tabbinghandler import TabbingHandler
 from model.shellmodel import ShellModel
 
 _BRIGHTNESS_STEP = 2
-_VOLUME_STEP = 10
+_VOLUME_STEP = hardwaremanager.VOL_CHANGE_INCREMENT_RECOMMENDATION
 _BRIGHTNESS_MAX = 15
 _VOLUME_MAX = 100
 _TABBING_MODIFIER = gtk.gdk.MOD1_MASK