1 files changed, 595 insertions, 0 deletions
diff --git a/gst-mixer/src/element.c b/gst-mixer/src/element.c
new file mode 100644
index 0000000..a190582
--- /dev/null
+++ b/gst-mixer/src/element.c
@@ -0,0 +1,595 @@
+/* MATE Volume Control
+ * Copyright (C) 2003-2004 Ronald Bultje <[email protected]>
+ *
+ * element.c: widget representation of a single mixer element
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <string.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "element.h"
+#include "keys.h"
+#include "preferences.h"
+#include "track.h"
+#include "misc.h"
+#ifdef HAVE_SOUND_THEME
+#include "gvc-sound-theme-chooser.h"
+#endif
+
+G_DEFINE_TYPE (MateVolumeControlElement, mate_volume_control_element, GTK_TYPE_NOTEBOOK)
+
+static void mate_volume_control_element_class_init (MateVolumeControlElementClass *klass);
+static void mate_volume_control_element_init (MateVolumeControlElement *el);
+static void mate_volume_control_element_dispose (GObject *object);
+
+static void cb_mateconf (MateConfClient *client,
+ guint connection_id,
+ MateConfEntry *entry,
+ gpointer data);
+
+
+static void
+mate_volume_control_element_class_init (MateVolumeControlElementClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->dispose = mate_volume_control_element_dispose;
+}
+
+static void
+mate_volume_control_element_init (MateVolumeControlElement *el)
+{
+ el->client = NULL;
+ el->mixer = NULL;
+}
+
+GtkWidget *
+mate_volume_control_element_new (MateConfClient *client)
+{
+ MateVolumeControlElement *el;
+
+ /* element */
+ el = g_object_new (MATE_VOLUME_CONTROL_TYPE_ELEMENT, NULL);
+ el->client = g_object_ref (G_OBJECT (client));
+
+ mateconf_client_add_dir (el->client, MATE_VOLUME_CONTROL_KEY_DIR,
+ MATECONF_CLIENT_PRELOAD_RECURSIVE, NULL);
+ mateconf_client_notify_add (el->client, MATE_VOLUME_CONTROL_KEY_DIR,
+ cb_mateconf, el, NULL, NULL);
+
+ return GTK_WIDGET (el);
+}
+
+static void
+mate_volume_control_element_dispose (GObject *object)
+{
+ MateVolumeControlElement *el = MATE_VOLUME_CONTROL_ELEMENT (object);
+
+ if (el->client) {
+ g_object_unref (G_OBJECT (el->client));
+ el->client = NULL;
+ }
+
+ if (el->mixer) {
+ /* remove g_timeout_add() mainloop handlers */
+ mate_volume_control_element_change (el, NULL);
+ gst_element_set_state (GST_ELEMENT (el->mixer), GST_STATE_NULL);
+ gst_object_unref (GST_OBJECT (el->mixer));
+ el->mixer = NULL;
+ }
+
+ G_OBJECT_CLASS (mate_volume_control_element_parent_class)->dispose (object);
+}
+
+/*
+ * Checks if we want to show the track by default ("whitelist").
+ */
+
+gboolean
+mate_volume_control_element_whitelist (GstMixer *mixer,
+ GstMixerTrack *track)
+{
+ gint i, pos;
+ gboolean found = FALSE;
+
+ /* Yes this is a hack. */
+ static struct {
+ gchar *label;
+ gboolean done;
+ } list[] = {
+
+/* Translator comment: the names below are a whitelist for which volume
+ * controls to show by default. Make sure that those match the translations
+ * of GStreamer-plugins' ALSA/OSS plugins. */
+ { "cd", FALSE },
+ { "line", FALSE },
+ { "mic", FALSE },
+ { "pcm", FALSE },
+ { "headphone", FALSE },
+ { "speaker", FALSE },
+ { "volume", FALSE },
+ { "master", FALSE },
+ { "digital output", FALSE },
+ { "recording", FALSE },
+ { "front", FALSE },
+ { NULL, FALSE }
+ };
+ 
+ /*
+ * When the user changes devices, it is necessary to reset the whitelist
+ * to a good default state. This fixes bugs LP:345645, 576022
+ */
+ if (track == NULL)
+ {
+ for (i = 0; list[i].label != NULL; i++)
+ list[i].done = FALSE;
+ return TRUE;
+ }
+
+ /* honor the mixer supplied hints about whitelisting if available */
+ if (gst_mixer_get_mixer_flags (GST_MIXER (mixer)) & GST_MIXER_FLAG_HAS_WHITELIST) {
+ if (GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_WHITELIST)) {
+ return (TRUE);
+ } else {
+ return (FALSE);
+ }
+ }
+
+ for (i = 0; !found && list[i].label != NULL; i++) {
+ gchar *label_l = NULL;
+
+ if (list[i].done)
+ continue;
+
+ /* make case insensitive */
+ if (g_object_class_find_property (G_OBJECT_GET_CLASS (track), "untranslated-label"))
+ g_object_get (track, "untranslated-label", &label_l, NULL);
+ if (label_l == NULL)
+ g_object_get (track, "label", &label_l, NULL);
+ for (pos = 0; label_l[pos] != '\0'; pos++)
+ label_l[pos] = g_ascii_tolower (label_l[pos]);
+
+ if (g_strrstr (label_l, list[i].label) != NULL) {
+ found = TRUE;
+ list[i].done = TRUE;
+ }
+ g_free (label_l);
+ }
+
+ return found;
+}
+
+/*
+ * Hide/show notebook page.
+ */
+
+static void
+update_tab_visibility (MateVolumeControlElement *el, gint page, gint tabnum)
+{
+ const GList *item;
+ gboolean visible = FALSE;
+ GtkWidget *t;
+
+ for (item = gst_mixer_list_tracks (el->mixer);
+ item != NULL; item = item->next) {
+ GstMixerTrack *track = item->data;
+ MateVolumeControlTrack *trkw =
+ g_object_get_data (G_OBJECT (track), "mate-volume-control-trkw");
+
+ if (get_page_num (el->mixer, track) == page && trkw->visible) {
+ visible = TRUE;
+ break;
+ }
+ }
+
+ t = gtk_notebook_get_nth_page (GTK_NOTEBOOK (el), tabnum);
+ if (visible)
+ gtk_widget_show (t);
+ else
+ gtk_widget_hide (t);
+}
+
+static void
+cb_notify_message (GstBus *bus, GstMessage *message, gpointer data)
+{
+ MateVolumeControlElement *el = data;
+ GstMixerMessageType type;
+ MateVolumeControlTrack *trkw;
+ GstMixerTrack *track = NULL;
+ GstMixerOptions *options = NULL;
+
+ if (GST_MESSAGE_SRC (message) != GST_OBJECT (el->mixer)) {
+ /* not from our mixer - can't update anything anyway */
+ return;
+ }
+
+ /* This code only calls refresh if the first_track changes, because the
+ * refresh code only retrieves the current value from that track anyway */
+ type = gst_mixer_message_get_type (message);
+ if (type == GST_MIXER_MESSAGE_MUTE_TOGGLED) {
+ gst_mixer_message_parse_mute_toggled (message, &track, NULL);
+ } else if (type == GST_MIXER_MESSAGE_VOLUME_CHANGED) {
+ gst_mixer_message_parse_volume_changed (message, &track, NULL, NULL);
+ } else if (type == GST_MIXER_MESSAGE_OPTION_CHANGED) {
+ gst_mixer_message_parse_option_changed (message, &options, NULL);
+ track = GST_MIXER_TRACK (options);
+ } else {
+ return;
+ }
+
+ trkw = g_object_get_data (G_OBJECT (track),
+ "mate-volume-control-trkw");
+
+ mate_volume_control_track_update (trkw);
+}
+
+/*
+ * Change the element. Basically recreates this object internally.
+ */
+
+void
+mate_volume_control_element_change (MateVolumeControlElement *el,
+ GstElement *element)
+{
+ struct {
+ GtkWidget *page, *old_sep, *new_sep, *flagbuttonbox;
+ gboolean use;
+ gint pos, height, width;
+ MateVolumeControlTrack * (* get_track_widget) (GtkTable *table,
+ gint tab_pos,
+ GstMixer *mixer,
+ GstMixerTrack *track,
+ GtkWidget *left_sep,
+ GtkWidget *right_sep,
+ GtkWidget *flagbox);
+
+ } content[4] = {
+ { NULL, NULL, NULL, NULL, FALSE, 0, 5, 1,
+ mate_volume_control_track_add_playback },
+ { NULL, NULL, NULL, NULL, FALSE, 0, 5, 1,
+ mate_volume_control_track_add_recording },
+ { NULL, NULL, NULL, NULL, FALSE, 0, 1, 3,
+ mate_volume_control_track_add_playback },
+ { NULL, NULL, NULL, NULL, FALSE, 0, 1, 3,
+ mate_volume_control_track_add_option }
+ };
+ static gboolean theme_page = FALSE;
+ const GList *item;
+ GstMixer *mixer;
+ GstBus *bus;
+ gint i;
+
+ /* remove old pages, but not the "Sound Theme" page */
+ i = 0;
+ if (theme_page)
+ i = 1;
+
+ while (gtk_notebook_get_n_pages (GTK_NOTEBOOK (el)) > i) {
+ gtk_notebook_remove_page (GTK_NOTEBOOK (el), 0);
+ }
+
+ /* take/put reference */
+ if (el->mixer) {
+ for (item = gst_mixer_list_tracks (el->mixer);
+ item != NULL; item = item->next) {
+ GstMixerTrack *track = item->data;
+ MateVolumeControlTrack *trkw;
+
+ trkw = g_object_get_data (G_OBJECT (track),
+ "mate-volume-control-trkw");
+ g_object_set_data (G_OBJECT (track), "mate-volume-control-trkw", NULL);
+ mate_volume_control_track_free (trkw);
+ }
+ }
+ if (!element)
+ return;
+
+ g_return_if_fail (GST_IS_MIXER (element));
+ mixer = GST_MIXER (element);
+ gst_object_replace ((GstObject **) &el->mixer, GST_OBJECT (element));
+
+ /* Bus for notifications */
+ if (GST_ELEMENT_BUS (mixer) == NULL) {
+ bus = gst_bus_new ();
+ gst_bus_add_signal_watch (bus);
+ g_signal_connect (G_OBJECT (bus), "message::element",
+ (GCallback) cb_notify_message, el);
+ gst_element_set_bus (GST_ELEMENT (mixer), bus);
+ }
+
+ /* content pages */
+ for (i = 0; i < 4; i++) {
+ content[i].page = gtk_table_new (content[i].width, content[i].height, FALSE);
+ gtk_container_set_border_width (GTK_CONTAINER (content[i].page), 6);
+ if (i >= 2)
+ gtk_table_set_row_spacings (GTK_TABLE (content[i].page), 6);
+ gtk_table_set_col_spacings (GTK_TABLE (content[i].page), 6);
+ content[i].flagbuttonbox = NULL;
+ }
+
+ /* show */
+ mate_volume_control_element_whitelist (el->mixer, NULL);
+ for (item = gst_mixer_list_tracks (el->mixer);
+ item != NULL; item = item->next) {
+ GstMixerTrack *track = item->data;
+ MateVolumeControlTrack *trkw;
+ gchar *key;
+ const MateConfValue *value;
+ gboolean active;
+
+ i = get_page_num (el->mixer, track);
+
+ /* FIXME:
+ * - do not create separator if there is no more track
+ * _of this type_. We currently destroy it at the
+ * end, so it's not critical, but not nice either.
+ */
+ if (i == 3) {
+ content[i].new_sep = gtk_hseparator_new ();
+ } else if (i < 2) {
+ content[i].new_sep = gtk_vseparator_new ();
+ } else {
+ content[i].new_sep = NULL;
+ }
+
+ /* visible? */
+ active = mate_volume_control_element_whitelist (mixer, track);
+ key = get_mateconf_key (el->mixer, track);
+ if ((value = mateconf_client_get (el->client, key, NULL)) != NULL &&
+ value->type == MATECONF_VALUE_BOOL) {
+ active = mateconf_value_get_bool (value);
+ }
+ g_free (key);
+
+ /* Show left separator if we're not the first track */
+ if (active && content[i].use && content[i].old_sep) {
+
+ /* Do not show separator for switches/options on Playback/Recording tab */
+ if (i < 2 && track->num_channels != 0) {
+ gtk_widget_show (content[i].old_sep);
+ }
+ }
+
+ /* widget */
+ trkw = content[i].get_track_widget (GTK_TABLE (content[i].page),
+ content[i].pos++, el->mixer, track,
+ content[i].old_sep, content[i].new_sep,
+ content[i].flagbuttonbox);
+ mate_volume_control_track_show (trkw, active);
+
+ /* Only the first trkw on the page will return flagbuttonbox */
+ if (trkw->flagbuttonbox != NULL)
+ content[i].flagbuttonbox = trkw->flagbuttonbox;
+ g_object_set_data (G_OBJECT (track),
+ "mate-volume-control-trkw", trkw);
+
+ /* separator */
+ if (item->next != NULL && content[i].new_sep) {
+ if (i >= 2) {
+ gtk_table_attach (GTK_TABLE (content[i].page), content[i].new_sep,
+ 0, 3, content[i].pos, content[i].pos + 1,
+ GTK_SHRINK | GTK_FILL, 0, 0, 0);
+ } else {
+ gtk_table_attach (GTK_TABLE (content[i].page), content[i].new_sep,
+ content[i].pos, content[i].pos + 1, 0, 6,
+ 0, GTK_SHRINK | GTK_FILL, 0, 0);
+ }
+ content[i].pos++;
+ }
+
+ content[i].old_sep = content[i].new_sep;
+
+ if (active) {
+ content[i].use = TRUE;
+ }
+ }
+
+ /* show - need to build the tabs backwards so that deleting the "Sound Theme"
+ * page can be avoided.
+ */
+ for (i = 3; i >= 0; i--) {
+ GtkWidget *label, *view, *viewport;
+ GtkAdjustment *hadjustment, *vadjustment;
+
+ /* don't show last separator */
+ if (content[i].new_sep)
+ gtk_widget_destroy (content[i].new_sep);
+
+ /* viewport for lots of tracks */
+ view = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view),
+ i >= 2 ? GTK_POLICY_NEVER :
+ GTK_POLICY_AUTOMATIC,
+ i >= 2 ? GTK_POLICY_AUTOMATIC :
+ GTK_POLICY_NEVER);
+
+ hadjustment = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (view));
+ vadjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (view));
+ viewport = gtk_viewport_new (hadjustment, vadjustment);
+ gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);
+
+ if (content[i].flagbuttonbox != NULL) {
+ GtkWidget *vbox = NULL;
+ GtkWidget *hbox = NULL;
+ GtkWidget *hbox2 = NULL;
+ GtkWidget *separator = NULL;
+
+ if (i < 2) {
+ vbox = gtk_vbox_new (FALSE, 0);
+ hbox = gtk_hbox_new (FALSE, 6);
+ hbox2 = gtk_hbox_new (FALSE, 6);
+ separator = gtk_hseparator_new ();
+ gtk_box_pack_start (GTK_BOX (vbox), content[i].page, TRUE, TRUE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (hbox2), separator, TRUE, TRUE, 6);
+ gtk_box_pack_start (GTK_BOX (hbox), content[i].flagbuttonbox, TRUE,
+ FALSE, 6);
+ } else {
+ /* orientation is rotated for these ... */
+ vbox = gtk_hbox_new (FALSE, 0);
+ hbox = gtk_vbox_new (FALSE, 0);
+ hbox2 = gtk_vbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), content[i].page, FALSE, FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (hbox), content[i].flagbuttonbox, TRUE,
+ FALSE, 6);
+ }
+ gtk_widget_show_all (hbox2);
+ gtk_widget_show (content[i].flagbuttonbox);
+ gtk_widget_show (hbox);
+ gtk_widget_show (content[i].page);
+ gtk_widget_show (vbox);
+
+ gtk_container_add (GTK_CONTAINER (viewport), vbox);
+ gtk_container_add (GTK_CONTAINER (view), viewport);
+ } else {
+ gtk_container_add (GTK_CONTAINER (viewport), content[i].page);
+ gtk_container_add (GTK_CONTAINER (view), viewport);
+ }
+
+ label = gtk_label_new (get_page_description (i));
+ gtk_notebook_prepend_page (GTK_NOTEBOOK (el), view, label);
+ gtk_widget_show (content[i].page);
+ gtk_widget_show (viewport);
+ gtk_widget_show (view);
+ gtk_widget_show (label);
+
+ update_tab_visibility (el, i, 0);
+ }
+
+ /* refresh fix */
+ for (i = gtk_notebook_get_n_pages (GTK_NOTEBOOK (el)) - 1;
+ i >= 0; i--) {
+ gtk_notebook_set_current_page (GTK_NOTEBOOK (el), i);
+ }
+
+#ifdef HAVE_SOUND_THEME
+ /* Add tab for managing themes */
+ if (!theme_page) {
+ theme_page = TRUE;
+ GtkWidget *label, *view, *viewport, *sound_theme_chooser, *vbox;
+ GtkAdjustment *hadjustment, *vadjustment;
+
+ label = gtk_label_new (_("Sound Theme"));
+
+ view = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+
+ hadjustment = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (view));
+ vadjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (view));
+ viewport = gtk_viewport_new (hadjustment, vadjustment);
+ gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);
+ gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);
+
+ sound_theme_chooser = gvc_sound_theme_chooser_new ();
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), sound_theme_chooser, TRUE, TRUE, 6);
+ gtk_container_add (GTK_CONTAINER (viewport), vbox);
+ gtk_container_add (GTK_CONTAINER (view), viewport);
+
+ gtk_widget_show_all (vbox);
+ gtk_widget_show (sound_theme_chooser);
+ gtk_widget_show (viewport);
+ gtk_widget_show (view);
+ gtk_widget_show (label);
+
+ gtk_notebook_append_page (GTK_NOTEBOOK (el), view, label);
+ }
+#endif
+}
+
+/*
+ * MateConf callback.
+ */
+
+static void
+cb_mateconf (MateConfClient *client,
+ guint connection_id,
+ MateConfEntry *entry,
+ gpointer data)
+{
+ MateVolumeControlElement *el = MATE_VOLUME_CONTROL_ELEMENT (data);
+ gchar *keybase = get_mateconf_key (el->mixer, NULL);
+
+ if (!strncmp (mateconf_entry_get_key (entry),
+ keybase, strlen (keybase))) {
+ const GList *item;
+
+ for (item = gst_mixer_list_tracks (el->mixer);
+ item != NULL; item = item->next) {
+ GstMixerTrack *track = item->data;
+ MateVolumeControlTrack *trkw =
+ g_object_get_data (G_OBJECT (track), "mate-volume-control-trkw");
+ gchar *key = get_mateconf_key (el->mixer, track);
+
+ g_return_if_fail (mateconf_entry_get_key (entry) != NULL);
+ g_return_if_fail (key != NULL);
+
+ if (g_str_equal (mateconf_entry_get_key (entry), key)) {
+ MateConfValue *value = mateconf_entry_get_value (entry);
+
+ if (value->type == MATECONF_VALUE_BOOL) {
+ gboolean active = mateconf_value_get_bool (value),
+ first[4] = { TRUE, TRUE, TRUE, TRUE };
+ gint n, page = get_page_num (el->mixer, track);
+
+ mate_volume_control_track_show (trkw, active);
+
+ /* separators */
+ for (item = gst_mixer_list_tracks (el->mixer);
+ item != NULL; item = item->next) {
+ GstMixerTrack *track = item->data;
+ MateVolumeControlTrack *trkw =
+ g_object_get_data (G_OBJECT (track), "mate-volume-control-trkw");
+
+ n = get_page_num (el->mixer, track);
+ if (trkw->visible && !first[n]) {
+ if (trkw->left_separator) {
+ if (n < 2 && track->num_channels == 0) {
+ gtk_widget_hide (trkw->left_separator);
+ } else {
+ gtk_widget_show (trkw->left_separator);
+ }
+ }
+ } else {
+ if (trkw->left_separator)
+ gtk_widget_hide (trkw->left_separator);
+ }
+
+ if (trkw->visible && first[n])
+ first[n] = FALSE;
+ }
+ update_tab_visibility (el, page, page);
+ break;
+ }
+ }
+
+ g_free (key);
+ }
+ }
+ g_free (keybase);
+}