/*
 * Copyright (C) 2008 William Jon McCann
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#include <pulse/pulseaudio.h>

#include <glib.h>
#include <glib/gi18n-lib.h>
#include <gtk/gtk.h>
#include <canberra-gtk.h>

#include "gvc-channel-bar.h"
#include "gvc-mixer-control.h"

#define SCALE_SIZE 128

struct GvcChannelBarPrivate
{
        GvcMixerControl *mixer_control;

        GtkOrientation   orientation;
        GtkWidget       *scale_box;
        GtkWidget       *start_box;
        GtkWidget       *end_box;
        GtkWidget       *image;
        GtkWidget       *low_image;
        GtkWidget       *scale;
        GtkWidget       *high_image;
        GtkAdjustment   *adjustment;
        GtkAdjustment   *zero_adjustment;
        gboolean         is_muted;
        char            *icon_name;
        char            *low_icon_name;
        char            *high_icon_name;
        gboolean         click_lock;
        gboolean         is_amplified;
        guint32          base_volume;
};

enum
{
        PROP_0,
        PROP_MIXER_CONTROL,
        PROP_ORIENTATION,
        PROP_IS_MUTED,
};

static void     gvc_channel_bar_finalize      (GObject            *object);

static gboolean on_scale_button_press_event   (GtkWidget      *widget,
                                               GdkEventButton *event,
                                               GvcChannelBar  *bar);
static gboolean on_scale_button_release_event (GtkWidget      *widget,
                                               GdkEventButton *event,
                                               GvcChannelBar  *bar);
static gboolean on_scale_scroll_event         (GtkWidget      *widget,
                                               GdkEventScroll *event,
                                               GvcChannelBar  *bar);

G_DEFINE_TYPE_WITH_PRIVATE (GvcChannelBar, gvc_channel_bar, GTK_TYPE_BOX)

static GtkWidget *
_scale_box_new (GvcChannelBar *bar)
{
        GvcChannelBarPrivate *priv = bar->priv;
        GtkWidget            *box;
        GtkWidget            *sbox;
        GtkWidget            *ebox;

        if (priv->orientation == GTK_ORIENTATION_VERTICAL) {
                bar->priv->scale_box = box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);

                priv->scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, priv->adjustment);

                gtk_widget_set_size_request (priv->scale, -1, SCALE_SIZE);
                gtk_range_set_inverted (GTK_RANGE (priv->scale), TRUE);

                bar->priv->start_box = sbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
                gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);

                gtk_box_pack_start (GTK_BOX (sbox), priv->image, FALSE, FALSE, 0);

                gtk_box_pack_start (GTK_BOX (sbox), priv->high_image, FALSE, FALSE, 0);
                gtk_widget_hide (priv->high_image);

                gtk_box_pack_start (GTK_BOX (box), priv->scale, TRUE, TRUE, 0);

                bar->priv->end_box = ebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
                gtk_box_pack_start (GTK_BOX (box), ebox, FALSE, FALSE, 0);

                gtk_box_pack_start (GTK_BOX (ebox), priv->low_image, FALSE, FALSE, 0);
                gtk_widget_hide (priv->low_image);
        } else {
                bar->priv->scale_box = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);

                priv->scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, priv->adjustment);

                gtk_widget_set_size_request (priv->scale, SCALE_SIZE, -1);

                bar->priv->start_box = sbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
                gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);

                gtk_box_pack_start (GTK_BOX (sbox), priv->image, FALSE, FALSE, 0);

                gtk_box_pack_end (GTK_BOX (sbox), priv->low_image, FALSE, FALSE, 0);
                gtk_widget_show (priv->low_image);

                gtk_box_pack_start (GTK_BOX (box), priv->scale, TRUE, TRUE, 0);

                bar->priv->end_box = ebox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
                gtk_box_pack_start (GTK_BOX (box), ebox, FALSE, FALSE, 0);

                gtk_box_pack_start (GTK_BOX (ebox), priv->high_image, FALSE, FALSE, 0);
                gtk_widget_show (priv->high_image);
        }

        ca_gtk_widget_disable_sounds (bar->priv->scale, FALSE);
        gtk_widget_add_events (bar->priv->scale, GDK_SCROLL_MASK);

        g_signal_connect (G_OBJECT (bar->priv->scale), "button-press-event",
                          G_CALLBACK (on_scale_button_press_event), bar);
        g_signal_connect (G_OBJECT (bar->priv->scale), "button-release-event",
                          G_CALLBACK (on_scale_button_release_event), bar);
        g_signal_connect (G_OBJECT (bar->priv->scale), "scroll-event",
                          G_CALLBACK (on_scale_scroll_event), bar);

        gtk_scale_set_draw_value (GTK_SCALE (priv->scale), FALSE);

        return box;
}

static void
update_image (GvcChannelBar *bar)
{
        gtk_image_set_from_icon_name (GTK_IMAGE (bar->priv->image),
                                      bar->priv->icon_name,
                                      GTK_ICON_SIZE_DIALOG);

        if (bar->priv->icon_name != NULL) {
                gtk_widget_show (bar->priv->image);
        } else {
                gtk_widget_hide (bar->priv->image);
        }
}

static void
update_layout (GvcChannelBar *bar)
{
        GtkWidget *box;
        GtkWidget *frame;

        if (bar->priv->scale == NULL) {
                return;
        }

        box = bar->priv->scale_box;
        frame = gtk_widget_get_parent (box);

        g_object_ref (bar->priv->image);
        g_object_ref (bar->priv->low_image);
        g_object_ref (bar->priv->high_image);

        gtk_container_remove (GTK_CONTAINER (bar->priv->start_box), bar->priv->image);

        if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
                gtk_container_remove (GTK_CONTAINER (bar->priv->start_box), bar->priv->low_image);
                gtk_container_remove (GTK_CONTAINER (bar->priv->end_box), bar->priv->high_image);
        } else {
                gtk_container_remove (GTK_CONTAINER (bar->priv->end_box), bar->priv->low_image);
                gtk_container_remove (GTK_CONTAINER (bar->priv->start_box), bar->priv->high_image);
        }

        gtk_container_remove (GTK_CONTAINER (box), bar->priv->start_box);
        gtk_container_remove (GTK_CONTAINER (box), bar->priv->scale);
        gtk_container_remove (GTK_CONTAINER (box), bar->priv->end_box);
        gtk_container_remove (GTK_CONTAINER (frame), box);

        bar->priv->scale_box = _scale_box_new (bar);
        gtk_container_add (GTK_CONTAINER (frame), bar->priv->scale_box);

        g_object_unref (bar->priv->image);
        g_object_unref (bar->priv->low_image);
        g_object_unref (bar->priv->high_image);

        gtk_widget_show_all (frame);
}

void
gvc_channel_bar_set_icon_name (GvcChannelBar  *bar,
                               const char     *name)
{
        g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));

        g_free (bar->priv->icon_name);
        bar->priv->icon_name = g_strdup (name);
        update_image (bar);
}

void
gvc_channel_bar_set_low_icon_name   (GvcChannelBar *bar,
                                     const char    *name)
{
        g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));

        if (name != NULL && strcmp (bar->priv->low_icon_name, name) != 0) {
                g_free (bar->priv->low_icon_name);
                bar->priv->low_icon_name = g_strdup (name);
                gtk_image_set_from_icon_name (GTK_IMAGE (bar->priv->low_image),
                                              bar->priv->low_icon_name,
                                              GTK_ICON_SIZE_MENU);
        }
}

void
gvc_channel_bar_set_high_icon_name  (GvcChannelBar *bar,
                                     const char    *name)
{
        g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));

        if (name != NULL && strcmp (bar->priv->high_icon_name, name) != 0) {
                g_free (bar->priv->high_icon_name);
                bar->priv->high_icon_name = g_strdup (name);
                gtk_image_set_from_icon_name (GTK_IMAGE (bar->priv->high_image),
                                              bar->priv->high_icon_name,
                                              GTK_ICON_SIZE_MENU);
        }
}

void
gvc_channel_bar_set_orientation (GvcChannelBar  *bar,
                                 GtkOrientation  orientation)
{
        g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));

        if (orientation != bar->priv->orientation) {
                bar->priv->orientation = orientation;
                update_layout (bar);
                g_object_notify (G_OBJECT (bar), "orientation");
        }
}

GtkAdjustment *
gvc_channel_bar_get_adjustment (GvcChannelBar *bar)
{
        g_return_val_if_fail (GVC_IS_CHANNEL_BAR (bar), NULL);

        return bar->priv->adjustment;
}

static gboolean
on_scale_button_press_event (GtkWidget      *widget,
                             GdkEventButton *event,
                             GvcChannelBar  *bar)
{
        bar->priv->click_lock = TRUE;

        return FALSE;
}

static gboolean
on_scale_button_release_event (GtkWidget      *widget,
                               GdkEventButton *event,
                               GvcChannelBar  *bar)
{
        GtkAdjustment *adj;
        gdouble value;

        bar->priv->click_lock = FALSE;

        adj = gtk_range_get_adjustment (GTK_RANGE (widget));

        value = gtk_adjustment_get_value (adj);

        /* this means the adjustment moved away from zero and
         * therefore we should unmute and set the volume. */
        gvc_channel_bar_set_is_muted (bar, (value == 0.0));

        /* Play a sound! */
        ca_gtk_play_for_widget (GTK_WIDGET (bar), 0,
                                CA_PROP_EVENT_ID, "audio-volume-change",
                                CA_PROP_EVENT_DESCRIPTION, "foobar event happened",
                                CA_PROP_APPLICATION_ID, "org.gnome.VolumeControl",
                                NULL);

        return FALSE;
}

gboolean
gvc_channel_bar_scroll (GvcChannelBar *bar, GdkEventScroll *event)
{
        GtkAdjustment *adj;
        gdouble value;
        GdkScrollDirection direction;
        gdouble dx, dy;
        gdouble adjustment_max;
        gdouble scrollstep;

        g_return_val_if_fail (bar != NULL, FALSE);
        g_return_val_if_fail (GVC_IS_CHANNEL_BAR (bar), FALSE);

        if (!gdk_event_get_scroll_direction ((GdkEvent*) event, &direction))
                return FALSE;

        if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
                if (direction == GDK_SCROLL_LEFT || direction == GDK_SCROLL_RIGHT)
                        return FALSE;
        } else {
                /* Switch direction for RTL */
                if (gtk_widget_get_direction (GTK_WIDGET (bar)) == GTK_TEXT_DIR_RTL) {
                        if (direction == GDK_SCROLL_RIGHT)
                                direction = GDK_SCROLL_LEFT;
                        else if (direction == GDK_SCROLL_LEFT)
                                direction = GDK_SCROLL_RIGHT;
                }
                /* Switch side scroll to vertical */
                if (direction == GDK_SCROLL_RIGHT)
                        direction = GDK_SCROLL_UP;
                else if (direction == GDK_SCROLL_LEFT)
                        direction = GDK_SCROLL_DOWN;
        }

	if (!gdk_event_get_scroll_deltas ((GdkEvent*)event, &dx, &dy)) {
		dx = 0.0;
		dy = 0.0;

		switch (direction) {
		case GDK_SCROLL_UP:
		case GDK_SCROLL_LEFT:
			dy = 1.0;
			break;
		case GDK_SCROLL_DOWN:
		case GDK_SCROLL_RIGHT:
			dy = -1.0;
			break;
		case GDK_SCROLL_SMOOTH:
		default:
			break;
		}
	}

        adj = gtk_range_get_adjustment (GTK_RANGE (bar->priv->scale));
        if (adj == bar->priv->zero_adjustment) {
                if (dy > 0)
                        gvc_channel_bar_set_is_muted (bar, FALSE);
                return TRUE;
        }

        value = gtk_adjustment_get_value (adj);

        if (bar->priv->is_amplified)
                adjustment_max = gvc_mixer_control_get_vol_max_amplified (bar->priv->mixer_control);
        else
                adjustment_max = gvc_mixer_control_get_vol_max_norm (bar->priv->mixer_control);

        scrollstep = (adjustment_max / 100.0 * 5.0);

        if (dy > 0) {
                if (value + dy * scrollstep > adjustment_max)
                        value = adjustment_max;
                else
                        value = value + dy * scrollstep;
        } else if (dy < 0) {
                if (value + dy * scrollstep < 0)
                        value = 0.0;
                else
                        value = value + dy * scrollstep;
        }

        gvc_channel_bar_set_is_muted (bar, (value == 0.0));
        adj = gtk_range_get_adjustment (GTK_RANGE (bar->priv->scale));
        gtk_adjustment_set_value (adj, value);

        return TRUE;
}

static gboolean
on_scale_scroll_event (GtkWidget      *widget,
                       GdkEventScroll *event,
                       GvcChannelBar  *bar)
{
        return gvc_channel_bar_scroll (bar, event);
}

static void
on_zero_adjustment_value_changed (GtkAdjustment *adjustment,
                                  GvcChannelBar *bar)
{
        gdouble value;

        if (bar->priv->click_lock != FALSE) {
                return;
        }

        value = gtk_adjustment_get_value (bar->priv->zero_adjustment);
        gtk_adjustment_set_value (bar->priv->adjustment, value);

        /* this means the adjustment moved away from zero and
         * therefore we should unmute and set the volume. */
        gvc_channel_bar_set_is_muted (bar, value > 0.0);
}

static void
update_mute_switch (GvcChannelBar *bar)
{


        if (bar->priv->is_muted) {
                /* If we aren't showing the mute button then
                 * move slider to the zero.  But we don't want to
                 * change the adjustment.  */
                g_signal_handlers_block_by_func (bar->priv->zero_adjustment,
                                                 on_zero_adjustment_value_changed,
                                                 bar);
                gtk_adjustment_set_value (bar->priv->zero_adjustment, 0);
                g_signal_handlers_unblock_by_func (bar->priv->zero_adjustment,
                                                   on_zero_adjustment_value_changed,
                                                   bar);
                gtk_range_set_adjustment (GTK_RANGE (bar->priv->scale),
                                          bar->priv->zero_adjustment);
        } else {
                /* no longer muted so restore the original adjustment
                 * and tell the front-end that the value changed */
                gtk_range_set_adjustment (GTK_RANGE (bar->priv->scale),
                                          bar->priv->adjustment);
        }
}

void
gvc_channel_bar_set_is_muted (GvcChannelBar *bar,
                              gboolean       is_muted)
{
        g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));

        if (is_muted != bar->priv->is_muted) {
                /* Update our internal state before telling the
                 * front-end about our changes */
                bar->priv->is_muted = is_muted;
                update_mute_switch (bar);
                g_object_notify (G_OBJECT (bar), "is-muted");
        }
}

gboolean
gvc_channel_bar_get_is_muted  (GvcChannelBar *bar)
{
        g_return_val_if_fail (GVC_IS_CHANNEL_BAR (bar), FALSE);
        return bar->priv->is_muted;
}

void
gvc_channel_bar_set_is_amplified (GvcChannelBar *bar, gboolean amplified)
{
        gdouble vol_max_normal;
        gdouble adjustment_max;

        g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));

        vol_max_normal = gvc_mixer_control_get_vol_max_norm (bar->priv->mixer_control);

        if (amplified)
                adjustment_max = gvc_mixer_control_get_vol_max_amplified (bar->priv->mixer_control);
        else
                adjustment_max = gvc_mixer_control_get_vol_max_norm (bar->priv->mixer_control);

        bar->priv->is_amplified = amplified;
        gtk_adjustment_set_upper (bar->priv->adjustment, adjustment_max);
        gtk_adjustment_set_upper (bar->priv->zero_adjustment, adjustment_max);
        gtk_scale_clear_marks (GTK_SCALE (bar->priv->scale));

        if (amplified) {
                char *str;

                if (bar->priv->base_volume == vol_max_normal) {
                        str = g_strdup_printf ("<small>%s</small>", C_("volume", "100%"));
                        gtk_scale_add_mark (GTK_SCALE (bar->priv->scale), vol_max_normal,
                                            GTK_POS_BOTTOM, str);
                } else {
                        str = g_strdup_printf ("<small>%s</small>", C_("volume", "Unamplified"));
                        gtk_scale_add_mark (GTK_SCALE (bar->priv->scale), bar->priv->base_volume,
                                            GTK_POS_BOTTOM, str);
                        /* Only show 100% if it's higher than the base volume */
                        if (bar->priv->base_volume < vol_max_normal) {
                                str = g_strdup_printf ("<small>%s</small>", C_("volume", "100%"));
                                gtk_scale_add_mark (GTK_SCALE (bar->priv->scale), vol_max_normal,
                                                    GTK_POS_BOTTOM, str);
                        }
                }

                g_free (str);
        }
}

void
gvc_channel_bar_set_base_volume (GvcChannelBar *bar,
                                 pa_volume_t    base_volume)
{
        g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));

        if (base_volume == 0) {
                bar->priv->base_volume = gvc_mixer_control_get_vol_max_norm (bar->priv->mixer_control);
                return;
        }

        /* Note that you need to call _is_amplified() afterwards to update the marks */
        bar->priv->base_volume = base_volume;
}

static void
gvc_channel_bar_set_property (GObject       *object,
                              guint          prop_id,
                              const GValue  *value,
                              GParamSpec    *pspec)
{
        GvcChannelBar *self = GVC_CHANNEL_BAR (object);

        switch (prop_id) {
        case PROP_MIXER_CONTROL:
                self->priv->mixer_control = g_value_dup_object (value);
                break;
        case PROP_ORIENTATION:
                gvc_channel_bar_set_orientation (self, g_value_get_enum (value));
                break;
        case PROP_IS_MUTED:
                gvc_channel_bar_set_is_muted (self, g_value_get_boolean (value));
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
                break;
        }
}

static void
gvc_channel_bar_get_property (GObject     *object,
                              guint        prop_id,
                              GValue      *value,
                              GParamSpec  *pspec)
{
        GvcChannelBar *self = GVC_CHANNEL_BAR (object);
        GvcChannelBarPrivate *priv = self->priv;

        switch (prop_id) {
        case PROP_MIXER_CONTROL:
                g_value_set_object (value, priv->mixer_control);
                break;
        case PROP_ORIENTATION:
                g_value_set_enum (value, priv->orientation);
                break;
        case PROP_IS_MUTED:
                g_value_set_boolean (value, priv->is_muted);
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
                break;
        }
}

static void
gvc_channel_bar_constructed (GObject *object)
{
        GvcChannelBar *bar;
        gdouble vol_max_normal;
        GtkWidget *frame;

        bar = GVC_CHANNEL_BAR (object);
        G_OBJECT_CLASS (gvc_channel_bar_parent_class)->constructed (object);

        vol_max_normal = gvc_mixer_control_get_vol_max_norm (bar->priv->mixer_control);

        bar->priv->base_volume = vol_max_normal;
        bar->priv->low_icon_name = g_strdup ("audio-volume-low");
        bar->priv->high_icon_name = g_strdup ("audio-volume-high");

        bar->priv->orientation = GTK_ORIENTATION_VERTICAL;
        bar->priv->adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
                                                                    0.0,
                                                                    vol_max_normal,
                                                                    vol_max_normal / 100.0,
                                                                    vol_max_normal / 10.0,
                                                                    0.0));
        g_object_ref_sink (bar->priv->adjustment);

        bar->priv->zero_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
                                                                         0.0,
                                                                         vol_max_normal,
                                                                         vol_max_normal / 100.0,
                                                                         vol_max_normal / 10.0,
                                                                         0.0));
        g_object_ref_sink (bar->priv->zero_adjustment);

        g_signal_connect (bar->priv->zero_adjustment,
                          "value-changed",
                          G_CALLBACK (on_zero_adjustment_value_changed),
                          bar);

        bar->priv->low_image = gtk_image_new_from_icon_name ("audio-volume-low",
                                                             GTK_ICON_SIZE_MENU);
        gtk_style_context_add_class (gtk_widget_get_style_context (bar->priv->low_image), "dim-label");
        gtk_widget_set_no_show_all (bar->priv->low_image, TRUE);
        bar->priv->high_image = gtk_image_new_from_icon_name ("audio-volume-high",
                                                              GTK_ICON_SIZE_MENU);
        gtk_style_context_add_class (gtk_widget_get_style_context (bar->priv->high_image), "dim-label");
        gtk_widget_set_no_show_all (bar->priv->high_image, TRUE);

        bar->priv->image = gtk_image_new ();
        gtk_widget_set_no_show_all (bar->priv->image, TRUE);

        /* frame */
        frame = gtk_frame_new (NULL);
        gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
        gtk_box_pack_start (GTK_BOX (bar), frame, TRUE, TRUE, 0);
        gtk_widget_show_all (frame);

        /* box with scale */
        bar->priv->scale_box = _scale_box_new (bar);

        gtk_container_add (GTK_CONTAINER (frame), bar->priv->scale_box);
        gtk_widget_show_all (frame);

        update_mute_switch (bar);
}

static void
gvc_channel_bar_dispose (GObject *object)
{
        GvcChannelBar *channel_bar;

        channel_bar = GVC_CHANNEL_BAR (object);

        g_clear_object (&channel_bar->priv->mixer_control);

        G_OBJECT_CLASS (gvc_channel_bar_parent_class)->dispose (object);
}

static void
gvc_channel_bar_class_init (GvcChannelBarClass *klass)
{
        GObjectClass   *object_class = G_OBJECT_CLASS (klass);

        object_class->constructed = gvc_channel_bar_constructed;
        object_class->dispose = gvc_channel_bar_dispose;
        object_class->finalize = gvc_channel_bar_finalize;
        object_class->set_property = gvc_channel_bar_set_property;
        object_class->get_property = gvc_channel_bar_get_property;

        g_object_class_install_property (object_class,
                                         PROP_MIXER_CONTROL,
                                         g_param_spec_object ("mixer-control",
                                                              "mixer control",
                                                              "mixer control",
                                                              GVC_TYPE_MIXER_CONTROL,
                                                              G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));

        g_object_class_install_property (object_class,
                                         PROP_ORIENTATION,
                                         g_param_spec_enum ("orientation",
                                                            "Orientation",
                                                            "The orientation of the scale",
                                                            GTK_TYPE_ORIENTATION,
                                                            GTK_ORIENTATION_VERTICAL,
                                                            G_PARAM_READWRITE));
        g_object_class_install_property (object_class,
                                         PROP_IS_MUTED,
                                         g_param_spec_boolean ("is-muted",
                                                               "is muted",
                                                               "Whether stream is muted",
                                                               FALSE,
                                                               G_PARAM_READWRITE|G_PARAM_CONSTRUCT));
}

static void
gvc_channel_bar_init (GvcChannelBar *bar)
{
        bar->priv = gvc_channel_bar_get_instance_private (bar);
}

static void
gvc_channel_bar_finalize (GObject *object)
{
        GvcChannelBar *channel_bar;

        g_return_if_fail (object != NULL);
        g_return_if_fail (GVC_IS_CHANNEL_BAR (object));

        channel_bar = GVC_CHANNEL_BAR (object);

        g_return_if_fail (channel_bar->priv != NULL);

        g_free (channel_bar->priv->icon_name);
        g_free (channel_bar->priv->low_icon_name);
        g_free (channel_bar->priv->high_icon_name);

        G_OBJECT_CLASS (gvc_channel_bar_parent_class)->finalize (object);
}

GtkWidget *
gvc_channel_bar_new (GvcMixerControl *mixer_control)
{
        GObject *bar;
        bar = g_object_new (GVC_TYPE_CHANNEL_BAR,
                            "mixer-control", mixer_control,
                            "orientation", GTK_ORIENTATION_HORIZONTAL,
                            NULL);
        return GTK_WIDGET (bar);
}
