1 files changed, 414 insertions, 232 deletions
diff --git a/libmatemixer/matemixer-stream-control.c b/libmatemixer/matemixer-stream-control.c
index 388308e..ace584a 100644
--- a/libmatemixer/matemixer-stream-control.c
+++ b/libmatemixer/matemixer-stream-control.c
@@ -21,425 +21,607 @@
 #include "matemixer-enums.h"
 #include "matemixer-enum-types.h"
 #include "matemixer-stream-control.h"
+#include "matemixer-stream-control-private.h"
 
 /**
 * SECTION:matemixer-stream-control
 * @include: libmatemixer/matemixer.h
 */
 
-G_DEFINE_INTERFACE (MateMixerStreamControl, mate_mixer_stream_control, G_TYPE_OBJECT)
+struct _MateMixerStreamControlPrivate
+{
+ gchar *name;
+ gchar *label;
+ gboolean mute;
+ gfloat balance;
+ gfloat fade;
+ MateMixerStreamControlFlags flags;
+ MateMixerStreamControlRole role;
+};
+
+enum {
+ PROP_0,
+ PROP_NAME,
+ PROP_LABEL,
+ PROP_FLAGS,
+ PROP_ROLE,
+ PROP_MUTE,
+ PROP_VOLUME,
+ PROP_BALANCE,
+ PROP_FADE,
+ N_PROPERTIES
+};
+
+static GParamSpec *properties[N_PROPERTIES] = { NULL, };
+
+static void mate_mixer_stream_control_class_init (MateMixerStreamControlClass *klass);
+
+static void mate_mixer_stream_control_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void mate_mixer_stream_control_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec);
+
+static void mate_mixer_stream_control_init (MateMixerStreamControl *control);
+static void mate_mixer_stream_control_finalize (GObject *object);
+
+G_DEFINE_ABSTRACT_TYPE (MateMixerStreamControl, mate_mixer_stream_control, G_TYPE_OBJECT)
+
+static void
+mate_mixer_stream_control_class_init (MateMixerStreamControlClass *klass)
+{
+ GObjectClass *object_class;
+
+ object_class = G_OBJECT_CLASS (klass);
+ object_class->finalize = mate_mixer_stream_control_finalize;
+ object_class->get_property = mate_mixer_stream_control_get_property;
+ object_class->set_property = mate_mixer_stream_control_set_property;
+
+ properties[PROP_NAME] =
+ g_param_spec_string ("name",
+ "Name",
+ "Name of the stream control",
+ NULL,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_LABEL] =
+ g_param_spec_string ("label",
+ "Label",
+ "Label of the stream control",
+ NULL,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_FLAGS] =
+ g_param_spec_flags ("flags",
+ "Flags",
+ "Capability flags of the stream control",
+ MATE_MIXER_TYPE_STREAM_CONTROL_FLAGS,
+ MATE_MIXER_STREAM_CONTROL_NO_FLAGS,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_ROLE] =
+ g_param_spec_enum ("role",
+ "Role",
+ "Role of the stream control",
+ MATE_MIXER_TYPE_STREAM_CONTROL_ROLE,
+ MATE_MIXER_STREAM_CONTROL_ROLE_UNKNOWN,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_MUTE] =
+ g_param_spec_boolean ("mute",
+ "Mute",
+ "Mute state of the stream control",
+ FALSE,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_VOLUME] =
+ g_param_spec_uint ("volume",
+ "Volume",
+ "Volume of the stream control",
+ 0,
+ G_MAXUINT,
+ 0,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_BALANCE] =
+ g_param_spec_float ("balance",
+ "Balance",
+ "Balance value of the stream control",
+ -1.0f,
+ 1.0f,
+ 0.0f,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_FADE] =
+ g_param_spec_float ("fade",
+ "Fade",
+ "Fade value of the stream control",
+ -1.0f,
+ 1.0f,
+ 0.0f,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_STRINGS);
+
+ g_object_class_install_properties (object_class, N_PROPERTIES, properties);
+
+ g_type_class_add_private (object_class, sizeof (MateMixerStreamControlPrivate));
+}
+
+static void
+mate_mixer_stream_control_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ MateMixerStreamControl *control;
+
+ control = MATE_MIXER_STREAM_CONTROL (object);
+
+ switch (param_id) {
+ case PROP_NAME:
+ g_value_set_string (value, control->priv->name);
+ break;
+ case PROP_LABEL:
+ g_value_set_string (value, control->priv->label);
+ break;
+ case PROP_FLAGS:
+ g_value_set_flags (value, control->priv->flags);
+ break;
+ case PROP_ROLE:
+ g_value_set_enum (value, control->priv->role);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+ break;
+ }
+}
+
+static void
+mate_mixer_stream_control_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ MateMixerStreamControl *control;
+
+ control = MATE_MIXER_STREAM_CONTROL (object);
+
+ switch (param_id) {
+ case PROP_NAME:
+ /* Construct-only string */
+ control->priv->name = g_value_dup_string (value);
+ break;
+ case PROP_LABEL:
+ /* Construct-only string */
+ control->priv->label = g_value_dup_string (value);
+ break;
+ case PROP_FLAGS:
+ control->priv->flags = g_value_get_flags (value);
+ break;
+ case PROP_ROLE:
+ control->priv->role = g_value_get_enum (value);
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+ break;
+ }
+}
+
+static void
+mate_mixer_stream_control_init (MateMixerStreamControl *control)
+{
+ control->priv = G_TYPE_INSTANCE_GET_PRIVATE (control,
+ MATE_MIXER_TYPE_STREAM_CONTROL,
+ MateMixerStreamControlPrivate);
+}
 
 static void
-mate_mixer_stream_control_default_init (MateMixerStreamControlInterface *iface)
-{
- g_object_interface_install_property (iface,
- g_param_spec_string ("name",
- "Name",
- "Name of the stream control",
- NULL,
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
- g_param_spec_string ("description",
- "Description",
- "Description of the stream control",
- NULL,
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
- g_param_spec_flags ("flags",
- "Flags",
- "Capability flags of the stream control",
- MATE_MIXER_TYPE_STREAM_CONTROL_FLAGS,
- MATE_MIXER_STREAM_CONTROL_NO_FLAGS,
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
- g_param_spec_boolean ("mute",
- "Mute",
- "Mute state of the stream control",
- FALSE,
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
- g_param_spec_uint ("volume",
- "Volume",
- "Volume of the stream control",
- 0,
- G_MAXUINT,
- 0,
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
- g_param_spec_float ("balance",
- "Balance",
- "Balance value of the stream control",
- -1.0f,
- 1.0f,
- 0.0f,
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
- g_param_spec_float ("fade",
- "Fade",
- "Fade value of the stream control",
- -1.0f,
- 1.0f,
- 0.0f,
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
+mate_mixer_stream_control_finalize (GObject *object)
+{
+ MateMixerStreamControl *control;
+
+ control = MATE_MIXER_STREAM_CONTROL (object);
+
+ g_free (control->priv->name);
+ g_free (control->priv->label);
+
+ G_OBJECT_CLASS (mate_mixer_stream_control_parent_class)->finalize (object);
 }
 
 const gchar *
-mate_mixer_stream_control_get_name (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_name (MateMixerStreamControl *control)
 {
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), NULL);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), NULL);
 
- /* Implementation required */
- return MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl)->get_name (ctl);
+ return control->priv->name;
 }
 
 const gchar *
-mate_mixer_stream_control_get_description (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_label (MateMixerStreamControl *control)
 {
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), NULL);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), NULL);
 
- /* Implementation required */
- return MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl)->get_description (ctl);
+ return control->priv->label;
 }
 
 MateMixerStreamControlFlags
-mate_mixer_stream_control_get_flags (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_flags (MateMixerStreamControl *control)
 {
- MateMixerStreamControlFlags flags = MATE_MIXER_STREAM_CONTROL_NO_FLAGS;
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), MATE_MIXER_STREAM_CONTROL_NO_FLAGS);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), MATE_MIXER_STREAM_CONTROL_NO_FLAGS);
+ return control->priv->flags;
+}
 
- g_object_get (G_OBJECT (ctl),
- "flags", &flags,
- NULL);
+MateMixerStreamControlRole
+mate_mixer_stream_control_get_role (MateMixerStreamControl *control)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), MATE_MIXER_STREAM_CONTROL_ROLE_UNKNOWN);
 
- return flags;
+ return control->priv->role;
 }
 
 gboolean
-mate_mixer_stream_control_get_mute (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_mute (MateMixerStreamControl *control)
 {
- gboolean mute = FALSE;
-
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);
 
- g_object_get (G_OBJECT (ctl),
- "mute", &mute,
- NULL);
-
- return mute;
+ return control->priv->mute;
 }
 
 gboolean
-mate_mixer_stream_control_set_mute (MateMixerStreamControl *ctl, gboolean mute)
+mate_mixer_stream_control_set_mute (MateMixerStreamControl *control, gboolean mute)
 {
- MateMixerStreamControlInterface *iface;
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE);
+ if (control->priv->mute == mute)
+ return TRUE;
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_MUTE) {
+ MateMixerStreamControlClass *klass;
 
- if (iface->set_mute != NULL)
- return iface->set_mute (ctl, mute);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
+ if (G_LIKELY (klass->set_mute != NULL))
+ return klass->set_mute (control, mute);
+ }
 return FALSE;
 }
 
 guint
-mate_mixer_stream_control_get_volume (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_num_channels (MateMixerStreamControl *control)
 {
- guint volume = 0;
+ MateMixerStreamControlClass *klass;
+
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- g_object_get (G_OBJECT (ctl),
- "volume", &volume,
- NULL);
+ if (klass->get_num_channels != NULL)
+ return klass->get_num_channels (control);
 
- return volume;
+ return 0;
 }
 
-gboolean
-mate_mixer_stream_control_set_volume (MateMixerStreamControl *ctl, guint volume)
+guint
+mate_mixer_stream_control_get_volume (MateMixerStreamControl *control)
 {
- MateMixerStreamControlInterface *iface;
-
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_VOLUME) {
+ MateMixerStreamControlClass *klass;
 
- if (iface->set_volume != NULL)
- return iface->set_volume (ctl, volume);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- return FALSE;
+ if G_LIKELY (klass->get_volume != NULL)
+ return klass->get_volume (control);
+ }
+ return 0;
 }
 
-gdouble
-mate_mixer_stream_control_get_decibel (MateMixerStreamControl *ctl)
+gboolean
+mate_mixer_stream_control_set_volume (MateMixerStreamControl *control, guint volume)
 {
- MateMixerStreamControlInterface *iface;
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), -MATE_MIXER_INFINITY);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_VOLUME) {
+ MateMixerStreamControlClass *klass;
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- if (iface->get_decibel != NULL)
- return iface->get_decibel (ctl);
-
- return -MATE_MIXER_INFINITY;
+ if (G_LIKELY (klass->set_volume != NULL))
+ return klass->set_volume (control, volume);
+ }
+ return FALSE;
 }
 
-gboolean
-mate_mixer_stream_control_set_decibel (MateMixerStreamControl *ctl, gdouble decibel)
+gdouble
+mate_mixer_stream_control_get_decibel (MateMixerStreamControl *control)
 {
- MateMixerStreamControlInterface *iface;
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), -MATE_MIXER_INFINITY);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL) {
+ MateMixerStreamControlClass *klass;
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- if (iface->set_decibel != NULL)
- return iface->set_decibel (ctl, decibel);
-
- return FALSE;
+ if (G_LIKELY (klass->get_decibel != NULL))
+ return klass->get_decibel (control);
+ }
+ return -MATE_MIXER_INFINITY;
 }
 
-guint
-mate_mixer_stream_control_get_num_channels (MateMixerStreamControl *ctl)
+gboolean
+mate_mixer_stream_control_set_decibel (MateMixerStreamControl *control, gdouble decibel)
 {
- MateMixerStreamControlInterface *iface;
-
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL) {
+ MateMixerStreamControlClass *klass;
 
- if (iface->get_num_channels != NULL)
- return iface->get_num_channels (ctl);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- return 0;
+ if (G_LIKELY (klass->set_decibel != NULL))
+ return klass->set_decibel (control, decibel);
+ }
+ return FALSE;
 }
 
 MateMixerChannelPosition
-mate_mixer_stream_control_get_channel_position (MateMixerStreamControl *ctl, guint channel)
+mate_mixer_stream_control_get_channel_position (MateMixerStreamControl *control, guint channel)
 {
- MateMixerStreamControlInterface *iface;
+ MateMixerStreamControlClass *klass;
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), MATE_MIXER_CHANNEL_UNKNOWN);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), MATE_MIXER_CHANNEL_UNKNOWN);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- if (iface->get_channel_position != NULL)
- return iface->get_channel_position (ctl, channel);
+ if (klass->get_channel_position != NULL)
+ return klass->get_channel_position (control, channel);
 
 return MATE_MIXER_CHANNEL_UNKNOWN;
 }
 
 guint
-mate_mixer_stream_control_get_channel_volume (MateMixerStreamControl *ctl, guint channel)
+mate_mixer_stream_control_get_channel_volume (MateMixerStreamControl *control, guint channel)
 {
- MateMixerStreamControlInterface *iface;
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_VOLUME) {
+ MateMixerStreamControlClass *klass;
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
-
- if (iface->get_channel_volume != NULL)
- return iface->get_channel_volume (ctl, channel);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
+ if (G_LIKELY (klass->get_channel_volume != NULL))
+ return klass->get_channel_volume (control, channel);
+ }
 return 0;
 }
 
 gboolean
-mate_mixer_stream_control_set_channel_volume (MateMixerStreamControl *ctl,
+mate_mixer_stream_control_set_channel_volume (MateMixerStreamControl *control,
 guint channel,
 guint volume)
 {
- MateMixerStreamControlInterface *iface;
-
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_VOLUME) {
+ MateMixerStreamControlClass *klass;
 
- if (iface->set_channel_volume != NULL)
- return iface->set_channel_volume (ctl, channel, volume);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
+ if (G_LIKELY (klass->set_channel_volume != NULL))
+ return klass->set_channel_volume (control, channel, volume);
+ }
 return FALSE;
 }
 
 gdouble
-mate_mixer_stream_control_get_channel_decibel (MateMixerStreamControl *ctl, guint channel)
+mate_mixer_stream_control_get_channel_decibel (MateMixerStreamControl *control, guint channel)
 {
- MateMixerStreamControlInterface *iface;
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), -MATE_MIXER_INFINITY);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), -MATE_MIXER_INFINITY);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL) {
+ MateMixerStreamControlClass *klass;
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
-
- if (iface->get_channel_decibel != NULL)
- return iface->get_channel_decibel (ctl, channel);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
+ if (G_LIKELY (klass->get_channel_decibel != NULL))
+ return klass->get_channel_decibel (control, channel);
+ }
 return -MATE_MIXER_INFINITY;
 }
 
 gboolean
-mate_mixer_stream_control_set_channel_decibel (MateMixerStreamControl *ctl,
+mate_mixer_stream_control_set_channel_decibel (MateMixerStreamControl *control,
 guint channel,
 gdouble decibel)
 {
- MateMixerStreamControlInterface *iface;
-
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_HAS_DECIBEL) {
+ MateMixerStreamControlClass *klass;
 
- if (iface->set_channel_decibel != NULL)
- return iface->set_channel_decibel (ctl, channel, decibel);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
+ if (G_LIKELY (klass->set_channel_decibel != NULL))
+ return klass->set_channel_decibel (control, channel, decibel);
+ }
 return FALSE;
 }
 
 gboolean
-mate_mixer_stream_control_has_channel_position (MateMixerStreamControl *ctl,
+mate_mixer_stream_control_has_channel_position (MateMixerStreamControl *control,
 MateMixerChannelPosition position)
 {
- MateMixerStreamControlInterface *iface;
+ MateMixerStreamControlClass *klass;
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- if (iface->has_channel_position != NULL)
- return iface->has_channel_position (ctl, position);
+ if (klass->has_channel_position != NULL)
+ return klass->has_channel_position (control, position);
 
 return FALSE;
 }
 
 gfloat
-mate_mixer_stream_control_get_balance (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_balance (MateMixerStreamControl *control)
 {
- gfloat balance = 0.0f;
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0.0f);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0.0f);
-
- g_object_get (G_OBJECT (ctl),
- "balance", &balance,
- NULL);
-
- return balance;
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_CAN_BALANCE)
+ return control->priv->balance;
+ else
+ return 0.0f;
 }
 
 gboolean
-mate_mixer_stream_control_set_balance (MateMixerStreamControl *ctl, gfloat balance)
+mate_mixer_stream_control_set_balance (MateMixerStreamControl *control, gfloat balance)
 {
- MateMixerStreamControlInterface *iface;
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_CAN_BALANCE) {
+ MateMixerStreamControlClass *klass;
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ if (balance < -1.0f || balance > 1.0f)
+ return FALSE;
 
- if (iface->set_balance != NULL)
- return iface->set_balance (ctl, balance);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
+ if (G_LIKELY (klass->set_balance != NULL))
+ return klass->set_balance (control, balance);
+ }
 return FALSE;
 }
 
 gfloat
-mate_mixer_stream_control_get_fade (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_fade (MateMixerStreamControl *control)
 {
- gfloat fade = 0.0f;
-
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0.0f);
-
- g_object_get (G_OBJECT (ctl),
- "fade", &fade,
- NULL);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0.0f);
 
- return fade;
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_CAN_FADE)
+ return control->priv->fade;
+ else
+ return 0.0f;
 }
 
 gboolean
-mate_mixer_stream_control_set_fade (MateMixerStreamControl *ctl, gfloat fade)
+mate_mixer_stream_control_set_fade (MateMixerStreamControl *control, gfloat fade)
 {
- MateMixerStreamControlInterface *iface;
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), FALSE);
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), FALSE);
+ if (control->priv->flags & MATE_MIXER_STREAM_CONTROL_CAN_FADE) {
+ MateMixerStreamControlClass *klass;
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ if (fade < -1.0f || fade > 1.0f)
+ return FALSE;
 
- if (iface->set_fade != NULL)
- return iface->set_fade (ctl, fade);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
+ if (G_LIKELY (klass->set_fade != NULL))
+ return klass->set_fade (control, fade);
+ }
 return FALSE;
 }
 
 guint
-mate_mixer_stream_control_get_min_volume (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_min_volume (MateMixerStreamControl *control)
 {
- MateMixerStreamControlInterface *iface;
+ MateMixerStreamControlClass *klass;
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- if (iface->get_min_volume != NULL)
- return iface->get_min_volume (ctl);
+ if (klass->get_min_volume != NULL)
+ return klass->get_min_volume (control);
 
 return 0;
 }
 
 guint
-mate_mixer_stream_control_get_max_volume (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_max_volume (MateMixerStreamControl *control)
 {
- MateMixerStreamControlInterface *iface;
+ MateMixerStreamControlClass *klass;
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- if (iface->get_max_volume != NULL)
- return iface->get_max_volume (ctl);
+ if (klass->get_max_volume != NULL)
+ return klass->get_max_volume (control);
 
 return 0;
 }
 
 guint
-mate_mixer_stream_control_get_normal_volume (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_normal_volume (MateMixerStreamControl *control)
 {
- MateMixerStreamControlInterface *iface;
+ MateMixerStreamControlClass *klass;
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- if (iface->get_normal_volume != NULL)
- return iface->get_normal_volume (ctl);
+ if (klass->get_normal_volume != NULL)
+ return klass->get_normal_volume (control);
 
 return 0;
 }
 
 guint
-mate_mixer_stream_control_get_base_volume (MateMixerStreamControl *ctl)
+mate_mixer_stream_control_get_base_volume (MateMixerStreamControl *control)
 {
- MateMixerStreamControlInterface *iface;
+ MateMixerStreamControlClass *klass;
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (ctl), 0);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM_CONTROL (control), 0);
 
- iface = MATE_MIXER_STREAM_CONTROL_GET_INTERFACE (ctl);
+ klass = MATE_MIXER_STREAM_CONTROL_GET_CLASS (control);
 
- if (iface->get_base_volume != NULL)
- return iface->get_base_volume (ctl);
+ if (klass->get_base_volume != NULL)
+ return klass->get_base_volume (control);
 
 return 0;
 }
+
+void
+_mate_mixer_stream_control_set_flags (MateMixerStreamControl *control,
+ MateMixerStreamControlFlags flags)
+{
+ control->priv->flags = flags;
+}
+
+void
+_mate_mixer_stream_control_set_mute (MateMixerStreamControl *control, gboolean mute)
+{
+ control->priv->mute = mute;
+}
+
+void
+_mate_mixer_stream_control_set_balance (MateMixerStreamControl *control, gfloat balance)
+{
+ control->priv->balance = balance;
+}
+
+void
+_mate_mixer_stream_control_set_fade (MateMixerStreamControl *control, gfloat fade)
+{
+ control->priv->fade = fade;
+}