moved from Mate-Extra

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);
+}