Merge lp:~cjcurran/indicator-sound/unify-device-handling-patterns into lp:~indicator-applet-developers/indicator-sound/trunk_3

[Conor Curran]

This is essentially a renaming refactor that was needed on the service side. Every since the voip item was introduced the existing pattern within the pulsemanager of assuming its userdata object was some sort of sink representative became untrue. The userdata mgr is simply just now a wrapper for which the pulsemanager uses to communicate with to menu. It is now called simply 'Device'
Furthermore all state should be stored in the respective widgets. Therefore there is no need for Device to calculate volumes etc.

[Ted Gould (ted)]

review: Approve

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2011-02-17 16:07:28 +0000
+++ src/Makefile.am	2011-03-14 20:12:00 +0000
@@ -92,8 +92,8 @@
   sound-service.c \
   pulseaudio-mgr.h \
   pulseaudio-mgr.c \
-  active-sink.c \
-  active-sink.h \
+  device.c \
+  device.h \
   sound-service-dbus.h \
   sound-service-dbus.c \
   slider-menu-item.h \

=== renamed file 'src/active-sink.c' => 'src/device.c'
--- src/active-sink.c	2011-02-18 17:11:08 +0000
+++ src/device.c	2011-03-14 20:12:00 +0000
@@ -18,64 +18,55 @@
 */
 #include <libdbusmenu-glib/menuitem.h>
 
-#include "active-sink.h"
+#include "device.h"
 #include "slider-menu-item.h"
 #include "mute-menu-item.h"
 #include "voip-input-menu-item.h"
 #include "pulseaudio-mgr.h"
 
-typedef struct _ActiveSinkPrivate ActiveSinkPrivate;
+typedef struct _DevicePrivate DevicePrivate;
 
-struct _ActiveSinkPrivate
+struct _DevicePrivate
 {
   SliderMenuItem*     volume_slider_menuitem;
   MuteMenuItem*       mute_menuitem;
   VoipInputMenuItem*  voip_input_menu_item;
   SoundState          current_sound_state;
   SoundServiceDbus*   service;
-  gint                index;
-  gchar*              name;
-  pa_cvolume          volume;
-  pa_channel_map      channel_map;
-  pa_volume_t         base_volume;
 };
 
-#define ACTIVE_SINK_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), ACTIVE_SINK_TYPE, ActiveSinkPrivate))
+#define DEVICE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DEVICE_TYPE, DevicePrivate))
 
 /* Prototypes */
-static void active_sink_class_init (ActiveSinkClass *klass);
-static void active_sink_init       (ActiveSink *self);
-static void active_sink_dispose    (GObject *object);
-static void active_sink_finalize   (GObject *object);
-
-static SoundState active_sink_get_state_from_volume (ActiveSink* self);
-static pa_cvolume active_sink_construct_mono_volume (const pa_cvolume* vol);
-static void active_sink_volume_update (ActiveSink* self, gdouble percent);
-static void active_sink_mute_update (ActiveSink* self, gboolean muted);
-
-G_DEFINE_TYPE (ActiveSink, active_sink, G_TYPE_OBJECT);
+static void device_class_init (DeviceClass *klass);
+static void device_init       (Device *self);
+static void device_dispose    (GObject *object);
+static void device_finalize   (GObject *object);
+
+static SoundState device_get_state_from_volume (Device* self);
+static void device_mute_update (Device* self, gboolean muted);
+
+G_DEFINE_TYPE (Device, device, G_TYPE_OBJECT);
 
 static void
-active_sink_class_init (ActiveSinkClass *klass)
+device_class_init (DeviceClass *klass)
 {
   GObjectClass      *gobject_class = G_OBJECT_CLASS (klass);
 
-  g_type_class_add_private (klass, sizeof (ActiveSinkPrivate));
+  g_type_class_add_private (klass, sizeof (DevicePrivate));
 
-  gobject_class->dispose = active_sink_dispose;
-  gobject_class->finalize = active_sink_finalize;  
+  gobject_class->dispose = device_dispose;
+  gobject_class->finalize = device_finalize;
 }
 
 static void
-active_sink_init (ActiveSink *self)
+device_init (Device *self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   priv->mute_menuitem = NULL;
   priv->volume_slider_menuitem = NULL;
   priv->voip_input_menu_item = NULL;
   priv->current_sound_state = UNAVAILABLE;
-  priv->index = -1;
-  priv->name = NULL;
   priv->service = NULL;
 
   // Init our menu items.
@@ -87,45 +78,38 @@
 }
 
 static void
-active_sink_dispose (GObject *object)
+device_dispose (GObject *object)
 {  
-  G_OBJECT_CLASS (active_sink_parent_class)->dispose (object);
+  G_OBJECT_CLASS (device_parent_class)->dispose (object);
 }
 
 static void
-active_sink_finalize (GObject *object)
+device_finalize (GObject *object)
 {
-  G_OBJECT_CLASS (active_sink_parent_class)->finalize (object);  
+  G_OBJECT_CLASS (device_parent_class)->finalize (object);
 }
 
 void
-active_sink_populate (ActiveSink* sink,
+device_populate (Device* self,
                       const pa_sink_info* update)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE(sink);
-
-  priv->name = g_strdup (update->name);
-  priv->index = update->index;
-  active_sink_mute_update (sink, update->mute);
-  priv->volume = active_sink_construct_mono_volume (&update->volume);
-  priv->base_volume = update->base_volume;
-  priv->channel_map = update->channel_map;
-
-  pa_volume_t vol = pa_cvolume_max (&update->volume);
-  gdouble volume_percent = ((gdouble) vol * 100) / PA_VOLUME_NORM;
-
-  active_sink_volume_update (sink, volume_percent);  
-  active_sink_mute_update (sink, update->mute);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE(self);
+  device_mute_update (self, update->mute);
   mute_menu_item_enable (priv->mute_menuitem, TRUE);
-  slider_menu_item_enable (priv->volume_slider_menuitem, TRUE);
+  slider_menu_item_populate (priv->volume_slider_menuitem, update);
+  SoundState state = device_get_state_from_volume (self);
+  if (priv->current_sound_state != state){
+    priv->current_sound_state  = state;
+    sound_service_dbus_update_sound_state (priv->service,
+                                           priv->current_sound_state);
+  }
 
-  g_debug ("Active sink has been populated - volume %f", volume_percent);
 }
 
 void
-active_sink_activate_voip_item (ActiveSink* self, gint sink_input_index, gint client_index)
+device_activate_voip_item (Device* self, gint sink_input_index, gint client_index)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   if (voip_input_menu_item_is_interested (priv->voip_input_menu_item,
                                           sink_input_index,
                                           client_index)){
@@ -134,85 +118,55 @@
 }
 
 void
-active_sink_deactivate_voip_source (ActiveSink* self, gboolean visible)
+device_deactivate_voip_source (Device* self, gboolean visible)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   visible &= voip_input_menu_item_is_active (priv->voip_input_menu_item);
   voip_input_menu_item_deactivate_source (priv->voip_input_menu_item, visible);
 }
 
 void
-active_sink_deactivate_voip_client (ActiveSink* self)
+device_deactivate_voip_client (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   voip_input_menu_item_deactivate_voip_client (priv->voip_input_menu_item);
 }
 
 void
-active_sink_update (ActiveSink* sink,
+device_update (Device* self,
                     const pa_sink_info* update)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (sink);
-  active_sink_mute_update (sink, update->mute);
-  priv->volume = active_sink_construct_mono_volume (&update->volume);
-  priv->base_volume = update->base_volume;
-  priv->channel_map = update->channel_map;
-
-  pa_volume_t vol = pa_cvolume_max (&update->volume);
-  gdouble volume_percent = ((gdouble) vol * 100) / PA_VOLUME_NORM;
-
-  active_sink_volume_update (sink, volume_percent);  
-  active_sink_mute_update (sink, update->mute);  
-}
-
-// To the UI
-static void
-active_sink_volume_update (ActiveSink* self, gdouble percent)
-{
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
-  slider_menu_item_update (priv->volume_slider_menuitem, percent);  
-  SoundState state = active_sink_get_state_from_volume (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
+  slider_menu_item_update (priv->volume_slider_menuitem, update);
+
+  SoundState state = device_get_state_from_volume (self);
   if (priv->current_sound_state != state){
     priv->current_sound_state  = state;
     sound_service_dbus_update_sound_state (priv->service,
                                            priv->current_sound_state);
   }
-}
-
-// From the UI
-void 
-active_sink_update_volume (ActiveSink* self, gdouble percent)
-{
-  pa_cvolume new_volume;
-  pa_cvolume_init(&new_volume);
-  new_volume.channels = 1;
-  pa_volume_t new_volume_value = (pa_volume_t) ((percent * PA_VOLUME_NORM) / 100);
-  pa_cvolume_set(&new_volume, 1, new_volume_value);
-
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
-
-  pa_cvolume_set(&priv->volume, priv->channel_map.channels, new_volume_value);
-  pm_update_volume (priv->index, new_volume);
-}
-
+
+  device_mute_update (self, update->mute);
+}
 
 gint
-active_sink_get_current_sink_input_index (ActiveSink* sink)
+device_get_current_sink_input_index (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (sink);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   return voip_input_menu_item_get_sink_input_index (priv->voip_input_menu_item);
 }
 
 static void 
-active_sink_mute_update (ActiveSink* self, gboolean muted)
+device_mute_update (Device* self, gboolean muted)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   mute_menu_item_update (priv->mute_menuitem, muted);
-  SoundState state = active_sink_get_state_from_volume (self);
+  SoundState state = device_get_state_from_volume (self);
   
   if (muted == TRUE){
     state = MUTED;
   }
+  // Only send signals if something has changed
   if (priv->current_sound_state != state){
     priv->current_sound_state = state;
     sound_service_dbus_update_sound_state (priv->service, state);
@@ -220,9 +174,9 @@
 }
 
 void
-active_sink_ensure_sink_is_unmuted (ActiveSink* self)
+device_ensure_sink_is_unmuted (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   if (mute_menu_item_is_muted (priv->mute_menuitem)){
     pm_update_mute (FALSE);    
   }
@@ -230,9 +184,9 @@
 
 
 static SoundState
-active_sink_get_state_from_volume (ActiveSink* self)
+device_get_state_from_volume (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   GVariant* v = dbusmenu_menuitem_property_get_variant (DBUSMENU_MENUITEM(priv->volume_slider_menuitem),
                                                         DBUSMENU_VOLUME_MENUITEM_LEVEL);
   gdouble volume_percent = g_variant_get_double (v);
@@ -254,21 +208,10 @@
   return state;
 }
 
-pa_cvolume
-active_sink_construct_mono_volume (const pa_cvolume* vol)
-{
-  pa_cvolume new_volume;
-  pa_cvolume_init(&new_volume);
-  new_volume.channels = 1;
-  pa_volume_t max_vol = pa_cvolume_max(vol);
-  pa_cvolume_set(&new_volume, 1, max_vol);
-  return new_volume;
-}
-
 void
-active_sink_determine_blocking_state (ActiveSink* self)
+device_determine_blocking_state (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   if (mute_menu_item_is_muted (priv->mute_menuitem)){
     /**
     We don't want to set the current state to blocking
@@ -280,65 +223,63 @@
 }
 
 gint
-active_sink_get_index (ActiveSink* self)
+device_get_index (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
-  return priv->index;
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
+  return slider_menu_item_get_sink_index (priv->volume_slider_menuitem);
 }
 
 gboolean
-active_sink_is_populated (ActiveSink* sink)
+device_is_populated (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (sink);
-  return (priv->index != -1);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
+  return dbusmenu_menuitem_property_get_bool (DBUSMENU_MENUITEM (priv->volume_slider_menuitem),
+                                                                 DBUSMENU_MENUITEM_PROP_ENABLED);
 }
 
 void 
-active_sink_deactivate (ActiveSink* self)
+device_deactivate (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   priv->current_sound_state = UNAVAILABLE;
   sound_service_dbus_update_sound_state (priv->service,
                                          priv->current_sound_state);  
   mute_menu_item_enable (priv->mute_menuitem, FALSE);
   slider_menu_item_enable (priv->volume_slider_menuitem, FALSE);
-  priv->index = -1;
-  g_free(priv->name);
-  priv->name = NULL;
 }
 
 SoundState
-active_sink_get_state (ActiveSink* self)
+device_get_state (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   return priv->current_sound_state;
 }
 
 void
-active_sink_update_voip_input_source (ActiveSink* self, const pa_source_info* update)
+device_update_voip_input_source (Device* self, const pa_source_info* update)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   voip_input_menu_item_update (priv->voip_input_menu_item, update);
 }
 
 gboolean
-active_sink_is_voip_source_populated (ActiveSink* self)
+device_is_voip_source_populated (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   return voip_input_menu_item_is_populated (priv->voip_input_menu_item);
 }
 
-gint active_sink_get_source_index (ActiveSink* self)
+gint device_get_source_index (Device* self)
 {
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (self);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (self);
   return voip_input_menu_item_get_index (priv->voip_input_menu_item);
 }
 
-ActiveSink*
-active_sink_new (SoundServiceDbus* service)
+Device*
+device_new (SoundServiceDbus* service)
 {
-  ActiveSink* sink = g_object_new (ACTIVE_SINK_TYPE, NULL);
-  ActiveSinkPrivate* priv = ACTIVE_SINK_GET_PRIVATE (sink);
+  Device* sink = g_object_new (DEVICE_TYPE, NULL);
+  DevicePrivate* priv = DEVICE_GET_PRIVATE (sink);
   priv->service = service;
   sound_service_dbus_build_sound_menu (service,
                                        mute_menu_item_get_button (priv->mute_menuitem),

=== renamed file 'src/active-sink.h' => 'src/device.h'
--- src/active-sink.h	2011-02-18 16:56:17 +0000
+++ src/device.h	2011-03-14 20:12:00 +0000
@@ -17,8 +17,8 @@
  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef __ACTIVE_SINK_H__
-#define __ACTIVE_SINK_H__
+#ifndef __DEVICE_H__
+#define __DEVICE_H__
 
 #include <glib.h>
 #include <glib-object.h>
@@ -30,25 +30,25 @@
 
 G_BEGIN_DECLS
 
-#define ACTIVE_SINK_TYPE         (active_sink_get_type ())
-#define ACTIVE_SINK(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), ACTIVE_SINK_TYPE, ActiveSink))
-#define ACTIVE_SINK_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), ACTIVE_SINK_TYPE, ActiveSinkClass))
-#define IS_ACTIVE_SINK(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), ACTIVE_SINK_TYPE))
-#define IS_ACTIVE_SINK_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), ACTIVE_SINK_TYPE))
-#define ACTIVE_SINK_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), ACTIVE_SINK_TYPE, ActiveSinkClass))
-
-typedef struct _ActiveSink      ActiveSink;
-typedef struct _ActiveSinkClass ActiveSinkClass;
-
-struct _ActiveSink {
+#define DEVICE_TYPE         (device_get_type ())
+#define DEVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), DEVICE_TYPE, Device))
+#define DEVICE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), DEVICE_TYPE, DeviceClass))
+#define IS_DEVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), DEVICE_TYPE))
+#define IS_DEVICE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), DEVICE_TYPE))
+#define DEVICE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), DEVICE_TYPE, DeviceClass))
+
+typedef struct _Device      Device;
+typedef struct _DeviceClass DeviceClass;
+
+struct _Device {
   GObject parent;
 };
 
-struct _ActiveSinkClass {
+struct _DeviceClass {
   GObjectClass parent_class;
 };
 
-GType active_sink_get_type  (void) G_GNUC_CONST;
+GType device_get_type  (void) G_GNUC_CONST;
 
 /**
  * TODO
@@ -58,27 +58,26 @@
  */
 
 // Sink related
-void active_sink_populate (ActiveSink* sink, const pa_sink_info* update);  
-void active_sink_update (ActiveSink* sink, const pa_sink_info* update);  
-gboolean active_sink_is_populated (ActiveSink* sink);
-gint active_sink_get_index (ActiveSink* self);
-void active_sink_deactivate (ActiveSink* self);
-void active_sink_update_mute (ActiveSink* self, gboolean mute_update);
-void active_sink_update_volume (ActiveSink* self, gdouble percent);
-void active_sink_ensure_sink_is_unmuted (ActiveSink* self);
+void device_populate (Device* sink, const pa_sink_info* update);
+void device_update (Device* sink, const pa_sink_info* update);
+gboolean device_is_populated (Device* sink);
+gint device_get_index (Device* self);
+void device_deactivate (Device* self);
+void device_update_mute (Device* self, gboolean mute_update);
+void device_ensure_sink_is_unmuted (Device* self);
 
 // source and sinkinput/client related for VOIP functionality
-void active_sink_update_voip_input_source (ActiveSink* sink, const pa_source_info* update);
-void active_sink_activate_voip_item (ActiveSink* sink, gint sink_input_index, gint client_index);
-gint active_sink_get_current_sink_input_index (ActiveSink* sink);
-gboolean active_sink_is_voip_source_populated (ActiveSink* sink);
-gint active_sink_get_source_index (ActiveSink* self);
-void active_sink_determine_blocking_state (ActiveSink* self);
-void active_sink_deactivate_voip_source (ActiveSink* self, gboolean visible);
-void active_sink_deactivate_voip_client (ActiveSink* self);
-SoundState active_sink_get_state (ActiveSink* self);
+void device_update_voip_input_source (Device* sink, const pa_source_info* update);
+void device_activate_voip_item (Device* sink, gint sink_input_index, gint client_index);
+gint device_get_current_sink_input_index (Device* sink);
+gboolean device_is_voip_source_populated (Device* sink);
+gint device_get_source_index (Device* self);
+void device_determine_blocking_state (Device* self);
+void device_deactivate_voip_source (Device* self, gboolean visible);
+void device_deactivate_voip_client (Device* self);
+SoundState device_get_state (Device* self);
 
-ActiveSink* active_sink_new (SoundServiceDbus* service);
+Device* device_new (SoundServiceDbus* service);
 
 G_END_DECLS
 

=== modified file 'src/pulseaudio-mgr.c'
--- src/pulseaudio-mgr.c	2011-03-01 20:36:26 +0000
+++ src/pulseaudio-mgr.c	2011-03-14 20:12:00 +0000
@@ -68,7 +68,7 @@
                                          const pa_sink_input_info *info,
                                          int eol,
                                          void *userdata);
-static void pm_update_active_sink (pa_context *c,
+static void pm_update_device (pa_context *c,
                                    const pa_sink_info *info,
                                    int eol,
                                    void *userdata);
@@ -89,11 +89,11 @@
  Entry Point
  **/
 void 
-pm_establish_pulse_connection (ActiveSink* active_sink)
+pm_establish_pulse_connection (Device* device)
 {
   pa_main_loop = pa_glib_mainloop_new (g_main_context_default ());
   g_assert (pa_main_loop);
-  reconnect_to_pulse ((gpointer)active_sink);  
+  reconnect_to_pulse ((gpointer)device);
 }
 
 /**
@@ -119,7 +119,7 @@
 {
   g_debug("Attempt a pulse connection");
   // reset
-  g_return_val_if_fail (IS_ACTIVE_SINK (user_data), FALSE);
+  g_return_val_if_fail (IS_DEVICE (user_data), FALSE);
 
   connection_attempts += 1;
   if (pulse_context != NULL) {
@@ -216,38 +216,38 @@
                                uint32_t index,
                                void* userdata)
 {
-  if (IS_ACTIVE_SINK (userdata) == FALSE){
+  if (IS_DEVICE (userdata) == FALSE){
     g_critical ("subscribed events callback - our userdata is not what we think it should be");
     return;
   }
-  ActiveSink* sink = ACTIVE_SINK (userdata);
+  Device* sink = DEVICE (userdata);
 
   switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
   case PA_SUBSCRIPTION_EVENT_SINK:
     
     // We don't care about any other sink other than the active one.
-    if (index != active_sink_get_index (sink))
+    if (index != device_get_index (sink))
       return;
       
     if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
-      active_sink_deactivate (sink);
+      device_deactivate (sink);
       
     }
     else{
       pa_operation_unref (pa_context_get_sink_info_by_index (c,
                                                              index,
-                                                             pm_update_active_sink,
+                                                             pm_update_device,
                                                              userdata) );
     }
     break;
   case PA_SUBSCRIPTION_EVENT_SOURCE:
     g_debug ("Looks like source event of some description - index = %i", index);
     // We don't care about any other sink other than the active one.
-    if (index != active_sink_get_source_index (sink))
+    if (index != device_get_source_index (sink))
         return;
     if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
       g_debug ("Source removal event - index = %i", index);
-      active_sink_deactivate_voip_source (sink, FALSE);
+      device_deactivate_voip_source (sink, FALSE);
     }
     else{
       pa_operation_unref (pa_context_get_source_info_by_index (c,
@@ -260,12 +260,12 @@
     // We don't care about sink input removals.
     g_debug ("sink input event");
     if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
-      gint cached_index = active_sink_get_current_sink_input_index (sink);
+      gint cached_index = device_get_current_sink_input_index (sink);
 
       g_debug ("Just saw a sink input removal event - index = %i and cached index = %i", index, cached_index);
 
       if (index == cached_index){
-        active_sink_deactivate_voip_client (sink);
+        device_deactivate_voip_client (sink);
       }
     }
     else if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
@@ -308,7 +308,7 @@
     break;
   case PA_CONTEXT_FAILED:
     g_warning("PA_CONTEXT_FAILED - Is PulseAudio Daemon running ?");
-    active_sink_deactivate (ACTIVE_SINK (userdata));
+    device_deactivate (DEVICE (userdata));
     if (reconnect_idle_id == 0){
       reconnect_idle_id = g_timeout_add_seconds (RECONNECT_DELAY,
                                                  reconnect_to_pulse,
@@ -362,7 +362,7 @@
 
   if (info == NULL) {
     g_warning("No PA server - get the hell out of here");
-    active_sink_deactivate (ACTIVE_SINK (userdata));
+    device_deactivate (DEVICE (userdata));
     return;
   }
   // Go for the default sink
@@ -373,7 +373,7 @@
                                                        pm_default_sink_info_callback,
                                                        userdata) )) {
       g_warning("pa_context_get_sink_info_by_namet() failed");
-      active_sink_deactivate (ACTIVE_SINK (userdata));
+      device_deactivate (DEVICE (userdata));
       pa_operation_unref(operation);
       return;
     }
@@ -382,7 +382,7 @@
                                                        pm_sink_info_callback,
                                                        userdata))) {
     g_warning("pa_context_get_sink_info_list() failed");
-    active_sink_deactivate (ACTIVE_SINK (userdata));
+    device_deactivate (DEVICE (userdata));
     pa_operation_unref(operation);
     return;
   }
@@ -421,14 +421,14 @@
     return;
   }
   else {
-    if (IS_ACTIVE_SINK (userdata) == FALSE || sink == NULL){
+    if (IS_DEVICE (userdata) == FALSE || sink == NULL){
       g_warning ("sink info callback - our user data is not what we think it should be or the sink parameter is null");
       return;
     }
-    ActiveSink* a_sink = ACTIVE_SINK (userdata);
-    if (active_sink_is_populated (a_sink) == FALSE &&
+    Device* a_sink = DEVICE (userdata);
+    if (device_is_populated (a_sink) == FALSE &&
         g_ascii_strncasecmp("auto_null", sink->name, 9) != 0){
-      active_sink_populate (a_sink, sink);
+      device_populate (a_sink, sink);
     }
   }
 }
@@ -443,16 +443,16 @@
     return;
   } 
   else {
-    if (IS_ACTIVE_SINK (userdata) == FALSE || info == NULL){
+    if (IS_DEVICE (userdata) == FALSE || info == NULL){
       g_warning ("Default sink info callback - our user data is not what we think it should be or the info parameter is null");
       return;
     }
     // Only repopulate if there is a change with regards the index
-    if (active_sink_get_index (ACTIVE_SINK (userdata)) == info->index)
+    if (device_get_index (DEVICE (userdata)) == info->index)
       return;
     
     g_debug ("Pulse Server has handed us a new default sink");
-    active_sink_populate (ACTIVE_SINK (userdata), info);
+    device_populate (DEVICE (userdata), info);
   }
 }
 
@@ -466,18 +466,18 @@
     return;
   }
   else {
-    if (info == NULL || IS_ACTIVE_SINK (userdata) == FALSE) {
+    if (info == NULL || IS_DEVICE (userdata) == FALSE) {
       g_warning("Sink input info callback : SINK INPUT INFO IS NULL or our user_data is not what we think it should be");
       return;
     }
 
-    if (IS_ACTIVE_SINK (userdata) == FALSE){
+    if (IS_DEVICE (userdata) == FALSE){
       g_warning ("sink input info callback - our user data is not what we think it should be");
       return;
     }
     // Check if this is Voip sink input
     gint result  = pa_proplist_contains (info->proplist, PA_PROP_MEDIA_ROLE);
-    ActiveSink* a_sink = ACTIVE_SINK (userdata);
+    Device* a_sink = DEVICE (userdata);
 
     if (result == 1){
       g_debug ("Sink input info has media role property");
@@ -485,7 +485,7 @@
       g_debug ("prop role = %s", value);
       if (g_strcmp0 (value, "phone") == 0) {
         g_debug ("And yes its a VOIP app ... sink input index = %i", info->index);
-        active_sink_activate_voip_item (a_sink, (gint)info->index, (gint)info->client);
+        device_activate_voip_item (a_sink, (gint)info->index, (gint)info->client);
         // TODO to start with we will assume our source is the same as what this 'client'
         // is pointing at. This should probably be more intelligent :
         // query for the list of source output info's and going on the name of the client
@@ -494,14 +494,14 @@
     }
 
     // And finally check for the mute blocking state
-    if (active_sink_get_index (a_sink) == info->sink){
-      active_sink_determine_blocking_state (a_sink);
+    if (device_get_index (a_sink) == info->sink){
+      device_determine_blocking_state (a_sink);
     }
   }
 }
 
 static void 
-pm_update_active_sink (pa_context *c,
+pm_update_device (pa_context *c,
                        const pa_sink_info *info,
                        int eol,
                        void *userdata)
@@ -510,11 +510,11 @@
     return;
   }
   else{
-    if (IS_ACTIVE_SINK (userdata) == FALSE || info == NULL){
-      g_warning ("update_active_sink - our user data is not what we think it should be or the info parameter is null");
+    if (IS_DEVICE (userdata) == FALSE || info == NULL){
+      g_warning ("update_device - our user data is not what we think it should be or the info parameter is null");
       return;
     }
-    active_sink_update (ACTIVE_SINK(userdata), info);
+    device_update (DEVICE(userdata), info);
   }
 }
 
@@ -551,16 +551,16 @@
     return;
   }
   else {
-    if (IS_ACTIVE_SINK (userdata) == FALSE || info == NULL){
+    if (IS_DEVICE (userdata) == FALSE || info == NULL){
       g_warning ("Default source info callback - our user data is not what we think it should be or the source info parameter is null");
       return;
     }
     // If there is an index change we need to change our cached source
-    if (active_sink_get_source_index (ACTIVE_SINK (userdata)) == info->index)
+    if (device_get_source_index (DEVICE (userdata)) == info->index)
       return;
     g_debug ("Pulse Server has handed us a new default source");
-    active_sink_deactivate_voip_source (ACTIVE_SINK (userdata), TRUE);
-    active_sink_update_voip_input_source (ACTIVE_SINK (userdata), info);
+    device_deactivate_voip_source (DEVICE (userdata), TRUE);
+    device_update_voip_input_source (DEVICE (userdata), info);
   }
 }
 
@@ -574,13 +574,13 @@
     return;
   }
   else {
-    if (IS_ACTIVE_SINK (userdata) == FALSE || info == NULL){
+    if (IS_DEVICE (userdata) == FALSE || info == NULL){
       g_warning ("source info callback - our user data is not what we think it should be or the source info parameter is null");
       return;
     }
     // For now we will take the first available
-    if (active_sink_is_voip_source_populated (ACTIVE_SINK (userdata)) == FALSE){
-      active_sink_update_voip_input_source (ACTIVE_SINK (userdata), info);
+    if (device_is_voip_source_populated (DEVICE (userdata)) == FALSE){
+      device_update_voip_input_source (DEVICE (userdata), info);
     }
   }
 }
@@ -595,11 +595,11 @@
     return;
   }
   else {
-    if (IS_ACTIVE_SINK (userdata) == FALSE || info == NULL ){
+    if (IS_DEVICE (userdata) == FALSE || info == NULL ){
       g_warning ("source info update callback - our user data is not what we think it should be or the source info paramter is null");
       return;
     }
     g_debug ("Got a source update for %s , index %i", info->name, info->index);
-    active_sink_update_voip_input_source (ACTIVE_SINK (userdata), info);
+    device_update_voip_input_source (DEVICE (userdata), info);
   }
 }

=== modified file 'src/pulseaudio-mgr.h'
--- src/pulseaudio-mgr.h	2011-02-18 16:22:58 +0000
+++ src/pulseaudio-mgr.h	2011-03-14 20:12:00 +0000
@@ -17,9 +17,9 @@
 with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "active-sink.h"
+#include "device.h"
 
-void pm_establish_pulse_connection (ActiveSink* active_sink);
+void pm_establish_pulse_connection (Device* device);
 void close_pulse_activites();
 void pm_update_volume (gint sink_index, pa_cvolume new_volume);
 void pm_update_mic_gain (gint source_index, pa_cvolume new_gain);

=== modified file 'src/slider-menu-item.c'
--- src/slider-menu-item.c	2011-03-10 19:48:26 +0000
+++ src/slider-menu-item.c	2011-03-14 20:12:00 +0000
@@ -23,11 +23,17 @@
 #include <glib/gi18n.h>
 #include "slider-menu-item.h"
 #include "common-defs.h"
+#include "pulseaudio-mgr.h"
 
 typedef struct _SliderMenuItemPrivate SliderMenuItemPrivate;
 
 struct _SliderMenuItemPrivate {
-  ActiveSink* a_sink;
+  Device*         a_sink;
+  gint                index;
+  gchar*              name;
+  pa_cvolume          volume;
+  pa_channel_map      channel_map;
+  pa_volume_t         base_volume;
 };
 
 #define SLIDER_MENU_ITEM_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SLIDER_MENU_ITEM_TYPE, SliderMenuItemPrivate))
@@ -39,6 +45,8 @@
 static void slider_menu_item_finalize   (GObject *object);
 static void handle_event (DbusmenuMenuitem * mi, const gchar * name, 
                           GVariant * value, guint timestamp);
+static pa_cvolume slider_menu_item_construct_mono_volume (const pa_cvolume* vol);
+static void slider_menu_item_update_volume (SliderMenuItem* self, gdouble percent);
 
 G_DEFINE_TYPE (SliderMenuItem, slider_menu_item, DBUSMENU_TYPE_MENUITEM);
 
@@ -63,7 +71,13 @@
   g_debug("Building new Slider Menu Item");
   dbusmenu_menuitem_property_set( DBUSMENU_MENUITEM(self),
                                   DBUSMENU_MENUITEM_PROP_TYPE,
-                                  DBUSMENU_VOLUME_MENUITEM_TYPE );  
+                                  DBUSMENU_VOLUME_MENUITEM_TYPE );
+
+  SliderMenuItemPrivate* priv = SLIDER_MENU_ITEM_GET_PRIVATE (self);
+
+  priv->index = -1;
+  priv->name = NULL;
+
   return;
 }
 
@@ -97,33 +111,108 @@
       SliderMenuItemPrivate* priv = SLIDER_MENU_ITEM_GET_PRIVATE (SLIDER_MENU_ITEM (mi));
       gdouble volume_input = g_variant_get_double(input);
       //g_debug ("slider menu item about to update volume %f", volume_input);
-      active_sink_update_volume (priv->a_sink, volume_input);
-      active_sink_ensure_sink_is_unmuted (priv->a_sink);      
+      slider_menu_item_update_volume (SLIDER_MENU_ITEM (mi), volume_input);
+      device_ensure_sink_is_unmuted (priv->a_sink);
     }    
   }
 }
 
-void
-slider_menu_item_update (SliderMenuItem* item,
-                              gdouble update)
-{
-  GVariant* new_volume = g_variant_new_double(update);
-  dbusmenu_menuitem_property_set_variant(DBUSMENU_MENUITEM(item),
-                                         DBUSMENU_VOLUME_MENUITEM_LEVEL,
-                                         new_volume);
-}
-
-void
-slider_menu_item_enable (SliderMenuItem* item,
-                              gboolean active)
-{
-  dbusmenu_menuitem_property_set_bool( DBUSMENU_MENUITEM(item),
+
+void
+slider_menu_item_populate (SliderMenuItem* self, const pa_sink_info* update)
+{
+  SliderMenuItemPrivate* priv = SLIDER_MENU_ITEM_GET_PRIVATE (self);
+  priv->name = g_strdup (update->name);
+  priv->index = update->index;
+  priv->volume = slider_menu_item_construct_mono_volume (&update->volume);
+  priv->base_volume = update->base_volume;
+  priv->channel_map = update->channel_map;
+
+  pa_volume_t vol = pa_cvolume_max (&update->volume);
+  gdouble volume_percent = ((gdouble) vol * 100) / PA_VOLUME_NORM;
+  GVariant* new_volume = g_variant_new_double (volume_percent);
+  dbusmenu_menuitem_property_set_variant (DBUSMENU_MENUITEM(self),
+                                          DBUSMENU_VOLUME_MENUITEM_LEVEL,
+                                          new_volume);
+  slider_menu_item_enable (self, TRUE);
+}
+
+// From the UI
+static void
+slider_menu_item_update_volume (SliderMenuItem* self, gdouble percent)
+{
+  pa_cvolume new_volume;
+  pa_cvolume_init(&new_volume);
+  new_volume.channels = 1;
+  pa_volume_t new_volume_value = (pa_volume_t) ((percent * PA_VOLUME_NORM) / 100);
+  pa_cvolume_set(&new_volume, 1, new_volume_value);
+
+  SliderMenuItemPrivate* priv = SLIDER_MENU_ITEM_GET_PRIVATE (self);
+
+  pa_cvolume_set(&priv->volume, priv->channel_map.channels, new_volume_value);
+  pm_update_volume (priv->index, new_volume);
+}
+
+// To the UI
+void
+slider_menu_item_update (SliderMenuItem* self, const pa_sink_info* update)
+{
+  SliderMenuItemPrivate* priv = SLIDER_MENU_ITEM_GET_PRIVATE (self);
+
+  priv->volume = slider_menu_item_construct_mono_volume (&update->volume);
+  priv->base_volume = update->base_volume;
+  priv->channel_map = update->channel_map;
+
+  pa_volume_t vol = pa_cvolume_max (&update->volume);
+  gdouble volume_percent = ((gdouble) vol * 100) / PA_VOLUME_NORM;
+
+  GVariant* new_volume = g_variant_new_double (volume_percent);
+  dbusmenu_menuitem_property_set_variant (DBUSMENU_MENUITEM(self),
+                                          DBUSMENU_VOLUME_MENUITEM_LEVEL,
+                                          new_volume);
+}
+
+/*
+ * Enable/Disabled can be considered the equivalent of whether we have an active
+ * sink or not, let the widget have inherent state.
+ */
+void
+slider_menu_item_enable (SliderMenuItem* self, gboolean active)
+{
+  SliderMenuItemPrivate* priv = SLIDER_MENU_ITEM_GET_PRIVATE (self);
+
+  dbusmenu_menuitem_property_set_bool (DBUSMENU_MENUITEM(self),
                                        DBUSMENU_MENUITEM_PROP_ENABLED,
-                                       active );
+                                       active);
+  if(active == FALSE){
+    priv->index = -1;
+    if(priv->name != NULL){
+      g_free(priv->name);
+      priv->name = NULL;
+    }
+  }
+}
+
+gint
+slider_menu_item_get_sink_index (SliderMenuItem* self)
+{
+  SliderMenuItemPrivate* priv = SLIDER_MENU_ITEM_GET_PRIVATE (self);
+  return priv->index;
+}
+
+static pa_cvolume
+slider_menu_item_construct_mono_volume (const pa_cvolume* vol)
+{
+  pa_cvolume new_volume;
+  pa_cvolume_init(&new_volume);
+  new_volume.channels = 1;
+  pa_volume_t max_vol = pa_cvolume_max(vol);
+  pa_cvolume_set(&new_volume, 1, max_vol);
+  return new_volume;
 }
 
 SliderMenuItem*
-slider_menu_item_new (ActiveSink* sink)
+slider_menu_item_new (Device* sink)
 { 
   SliderMenuItem *self = g_object_new(SLIDER_MENU_ITEM_TYPE, NULL);
   SliderMenuItemPrivate* priv = SLIDER_MENU_ITEM_GET_PRIVATE (self);

=== modified file 'src/slider-menu-item.h'
--- src/slider-menu-item.h	2011-02-04 19:55:20 +0000
+++ src/slider-menu-item.h	2011-03-14 20:12:00 +0000
@@ -23,7 +23,7 @@
 #include <glib-object.h>
 
 #include <libdbusmenu-glib/menuitem.h>
-#include "active-sink.h"
+#include "device.h"
 
 G_BEGIN_DECLS
 
@@ -47,10 +47,16 @@
 
 GType slider_menu_item_get_type (void);
 
-void slider_menu_item_update(SliderMenuItem* item, gdouble update);
+void slider_menu_item_update(SliderMenuItem* item, const pa_sink_info* update);
 void slider_menu_item_enable(SliderMenuItem* item, gboolean active);
-
-SliderMenuItem* slider_menu_item_new (ActiveSink* sink);
+void slider_menu_item_populate (SliderMenuItem* self, const pa_sink_info* update);
+//void
+//active_sink_update (ActiveSink* sink,
+//                    const pa_sink_info* update)
+
+gint slider_menu_item_get_sink_index (SliderMenuItem* self);
+
+SliderMenuItem* slider_menu_item_new (Device* sink);
 
 G_END_DECLS
 

=== modified file 'src/sound-service-dbus.c'
--- src/sound-service-dbus.c	2011-03-11 15:24:11 +0000
+++ src/sound-service-dbus.c	2011-03-14 20:12:00 +0000
@@ -29,7 +29,7 @@
 #include <libdbusmenu-glib/client.h>
 
 #include "sound-service-dbus.h"
-#include "active-sink.h"
+#include "device.h"
 #include "gen-sound-service.xml.h"
 #include "dbus-shared-names.h"
 
@@ -55,7 +55,7 @@
 struct _SoundServiceDbusPrivate {
   GDBusConnection*    connection;
   DbusmenuMenuitem*   root_menuitem;
-  ActiveSink*         active_sink;
+  Device*             device;
 };
 
 static GDBusNodeInfo *            node_info = NULL;
@@ -155,7 +155,7 @@
                                   paths);
   dbusmenu_server_set_root (server, priv->root_menuitem);
   g_object_unref (priv->root_menuitem);
-  priv->active_sink = active_sink_new (self);
+  priv->device = device_new (self);
   return priv->root_menuitem;
 }
 
@@ -272,8 +272,8 @@
   SoundServiceDbusPrivate *priv = SOUND_SERVICE_DBUS_GET_PRIVATE (service);
 
   if (g_strcmp0(method, "GetSoundState") == 0) {
-    g_debug("Get state -  %i", active_sink_get_state (priv->active_sink));
-    retval =  g_variant_new ( "(i)", active_sink_get_state (priv->active_sink));    
+    g_debug("Get state -  %i", device_get_state (priv->device));
+    retval =  g_variant_new ( "(i)", device_get_state (priv->device));
   }   
   else if (g_strcmp0(method, "BlacklistMediaPlayer") == 0) {    
     gboolean blacklist;

=== modified file 'src/voip-input-menu-item.c'
--- src/voip-input-menu-item.c	2011-02-18 17:11:08 +0000
+++ src/voip-input-menu-item.c	2011-03-14 20:12:00 +0000
@@ -28,7 +28,7 @@
 typedef struct _VoipInputMenuItemPrivate VoipInputMenuItemPrivate;
 
 struct _VoipInputMenuItemPrivate {
-  ActiveSink*         a_sink;
+  Device*             a_sink;
   pa_cvolume          volume;
   gint                mute;
   guint32             volume_steps;
@@ -129,8 +129,6 @@
       if (priv->mute == 1) {
         pm_update_mic_mute (priv->source_index, 0);
       }
-      //active_sink_update_volume (priv->a_sink, volume_input);
-      //active_sink_ensure_sink_is_unmuted (priv->a_sink);
     }
   }
 }
@@ -268,7 +266,7 @@
 }
 
 VoipInputMenuItem*
-voip_input_menu_item_new (ActiveSink* sink)
+voip_input_menu_item_new (Device* sink)
 {
   VoipInputMenuItem *self = g_object_new(VOIP_INPUT_MENU_ITEM_TYPE, NULL);
   VoipInputMenuItemPrivate* priv = VOIP_INPUT_MENU_ITEM_GET_PRIVATE (self);

=== modified file 'src/voip-input-menu-item.h'
--- src/voip-input-menu-item.h	2011-02-18 17:11:08 +0000
+++ src/voip-input-menu-item.h	2011-03-14 20:12:00 +0000
@@ -22,7 +22,7 @@
 #include <glib.h>
 #include <pulse/pulseaudio.h>
 #include <libdbusmenu-glib/menuitem.h>
-#include "active-sink.h"
+#include "device.h"
 
 G_BEGIN_DECLS
 
@@ -62,7 +62,7 @@
 void voip_input_menu_item_deactivate_source (VoipInputMenuItem* item, gboolean visible);
 void voip_input_menu_item_deactivate_voip_client (VoipInputMenuItem* item);
 
-VoipInputMenuItem* voip_input_menu_item_new (ActiveSink* sink);
+VoipInputMenuItem* voip_input_menu_item_new (Device* sink);
 
 G_END_DECLS