add gst-mixer-applet (moved from mate-applets package)

it will builds only if gstreamer is enabled

1 files changed, 354 insertions, 0 deletions

diff --git a/gst-mixer-applet/dock.c b/gst-mixer-applet/dock.c
new file mode 100644
index 0000000..f9132c2
--- /dev/null
+++ b/gst-mixer-applet/dock.c
@@ -0,0 +1,354 @@
+/* MATE Volume Applet
+ * Copyright (C) 2004 Ronald Bultje <[email protected]>
+ *
+ * dock.c: floating window containing volume widgets
+ *
+ * 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., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib-object.h>
+#include <glib/gi18n.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+
+#include "dock.h"
+
+static void	mate_volume_applet_dock_class_init	(MateVolumeAppletDockClass *klass);
+static void	mate_volume_applet_dock_init		(MateVolumeAppletDock *applet);
+static void	mate_volume_applet_dock_dispose	(GObject *object);
+
+static gboolean	cb_button_press				(GtkWidget *widget,
+							 GdkEventButton *button,
+							 gpointer   data);
+static gboolean	cb_button_release			(GtkWidget *widget,
+							 GdkEventButton *button,
+							 gpointer   data);
+static gboolean	cb_key_press			(GtkWidget *widget,
+						 GdkEventKey *event,
+						 gpointer   data);
+
+static GtkWindowClass *parent_class = NULL;
+
+G_DEFINE_TYPE (MateVolumeAppletDock, mate_volume_applet_dock, GTK_TYPE_WINDOW)
+
+static void
+mate_volume_applet_dock_class_init (MateVolumeAppletDockClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  parent_class = g_type_class_ref (GTK_TYPE_WINDOW);
+
+  gobject_class->dispose = mate_volume_applet_dock_dispose;
+}
+
+static void
+mate_volume_applet_dock_init (MateVolumeAppletDock *dock)
+{
+  dock->orientation = -1;
+  dock->timeout = 0;
+
+#if 1
+  /* We can't use a simple GDK_WINDOW_TYPE_HINT_DOCK here since
+   * the dock windows don't accept input by default. Instead we use
+   * the popup menu type. In the end we set everything by hand anyway
+   * since what happens depends very heavily on the window manager. */
+//  gtk_window_set_type_hint (GTK_WINDOW (dock),
+//      			    GDK_WINDOW_TYPE_HINT_POPUP_MENU);
+  gtk_window_set_keep_above (GTK_WINDOW (dock), TRUE);
+  gtk_window_set_decorated (GTK_WINDOW (dock), FALSE);
+  gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dock), TRUE);
+  gtk_window_set_skip_pager_hint (GTK_WINDOW (dock), TRUE);
+  gtk_window_set_resizable (GTK_WINDOW (dock), FALSE);
+  gtk_window_stick (GTK_WINDOW (dock));
+#else
+  /* This works well, except that keyboard focus is impossible. */
+  gtk_window_set_type_hint (GTK_WINDOW (dock),
+      			    GDK_WINDOW_TYPE_HINT_DOCK);
+  gtk_window_set_decorated (GTK_WINDOW (dock), FALSE);
+  gtk_window_set_resizable (GTK_WINDOW (dock), FALSE);
+  gtk_window_stick (GTK_WINDOW (dock));
+  GTK_WIDGET_SET_FLAGS (dock, GTK_CAN_FOCUS);
+#endif
+}
+
+static void mute_cb (GtkToggleButton *mute_widget, MateVolumeAppletDock *dock)
+{
+  /* Only toggle the mute if we are actually going to change the
+   * mute. This stops loops where the toggle_mute code calls us
+   * back to make sure our display is in sync with other mute buttons. */
+  if (mixer_is_muted (dock->model) !=
+      gtk_toggle_button_get_active (mute_widget))
+    mate_volume_applet_toggle_mute (dock->model);
+}
+
+static void launch_mixer_cb (GtkButton *button, MateVolumeAppletDock *dock)
+{
+  mate_volume_applet_run_mixer (dock->model);
+}
+
+/*
+ * This is evil.
+ *
+ * Because we can't get a horizontal slider to behave sanely
+ * with respect to up/down keys, we capture those keypress
+ * and send them to the main applet - which can handle them sanely.
+ * To emphasise that this is exceptional behaviour, the declarations
+ * of the appropriate functions are made here rather than in a header.
+ *
+ */
+gboolean mate_volume_applet_key (GtkWidget   *widget,
+				  GdkEventKey *event);
+gboolean mate_volume_applet_scroll (GtkWidget      *widget,
+				     GdkEventScroll *event);
+
+static gboolean proxy_key_event (GtkWidget *self, GdkEventKey *event,
+				 GtkWidget *applet)
+{
+  mate_volume_applet_key (applet, event);
+
+  return TRUE;
+}
+
+static gboolean proxy_scroll_event (GtkWidget *self, GdkEventScroll *event,
+				    GtkWidget *applet)
+{
+  mate_volume_applet_scroll (applet, event);
+
+  return TRUE;
+}
+
+GtkWidget *
+mate_volume_applet_dock_new (GtkOrientation orientation,
+			      MateVolumeApplet *parent)
+{
+  /* FIXME: Remove the orientation argument, or fix it for vertical
+     boxes (a "horizontal" orientation - the meaning is reversed for
+     historical reasons. */
+
+  GtkWidget *button, *scale, *mute, *more, *label;
+  GtkWidget *container, *outerline, *innerline, *frame;
+  MateVolumeAppletDock *dock;
+  gint i;
+  static struct {
+    GtkWidget * (* sfunc) (GtkAdjustment *adj);
+    GtkWidget * (* container) (gboolean, gint);
+    GtkWidget * (* subcontainer) (gboolean, gint);
+    gint sw, sh;
+    gboolean inverted;
+  } magic[2] = {
+    { gtk_vscale_new, gtk_hbox_new, gtk_vbox_new, -1, 200, TRUE},
+    { gtk_hscale_new, gtk_vbox_new, gtk_hbox_new, 200, -1, FALSE}
+  };
+
+  dock = g_object_new (MATE_VOLUME_APPLET_TYPE_DOCK,
+		       NULL);
+  gtk_window_set_screen (GTK_WINDOW (dock),
+                         gtk_widget_get_screen(GTK_WIDGET (parent)));
+  dock->orientation = orientation;
+  dock->model = parent;
+  g_signal_connect (dock, "key_press_event", G_CALLBACK (cb_key_press),
+		    NULL);
+
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
+  gtk_container_add (GTK_CONTAINER (dock), frame);
+
+  container = magic[orientation].container (FALSE, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (container), 6);
+  gtk_container_add (GTK_CONTAINER (frame), container);
+  outerline = magic[orientation].subcontainer (FALSE, 0);
+  innerline = magic[orientation].subcontainer (FALSE, 0);
+  gtk_box_pack_start (GTK_BOX (container), outerline, FALSE, FALSE, 0);
+  gtk_box_pack_start (GTK_BOX (container), innerline, FALSE, FALSE, 0);
+
+  dock->minus = GTK_BUTTON (gtk_button_new ());
+  gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->minus),
+		      FALSE, FALSE, 0);
+  gtk_container_add (GTK_CONTAINER (dock->minus),
+		     gtk_image_new_from_stock (GTK_STOCK_REMOVE,
+					       GTK_ICON_SIZE_BUTTON));
+  dock->plus = GTK_BUTTON (gtk_button_new ());
+  gtk_box_pack_end (GTK_BOX (outerline), GTK_WIDGET (dock->plus),
+		    FALSE, FALSE, 0);
+  gtk_container_add (GTK_CONTAINER (dock->plus),
+		     gtk_image_new_from_stock (GTK_STOCK_ADD,
+					       GTK_ICON_SIZE_BUTTON));
+
+  button = GTK_WIDGET (dock->plus);
+  for (i = 0; i<2; i++) { /* For button in (dock->plus, dock->minus): */
+    gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
+    g_signal_connect (button, "button-press-event",
+		      G_CALLBACK (cb_button_press), dock);
+    g_signal_connect (button, "button-release-event",
+		      G_CALLBACK (cb_button_release), dock);
+    button = GTK_WIDGET (dock->minus);
+  }
+
+  scale = magic[orientation].sfunc (NULL);
+  g_signal_connect (scale, "key-press-event", G_CALLBACK (proxy_key_event),
+		    parent);
+  g_signal_connect (scale, "scroll-event", G_CALLBACK (proxy_scroll_event),
+		    parent);
+  dock->scale = GTK_RANGE (scale);
+  gtk_widget_set_size_request (scale,
+			       magic[orientation].sw,
+			       magic[orientation].sh);
+  gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
+  gtk_range_set_inverted (dock->scale, magic[orientation].inverted);
+  gtk_box_pack_start (GTK_BOX (outerline), GTK_WIDGET (dock->scale),
+		      TRUE, TRUE, 0);
+
+  dock->mute = gtk_check_button_new_with_label (_("Mute"));
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dock->mute),
+				mixer_is_muted (dock->model));
+  g_signal_connect (dock->mute, "toggled", G_CALLBACK (mute_cb), dock);
+  gtk_box_pack_start (GTK_BOX (innerline), dock->mute, TRUE, TRUE, 0);
+
+  more = gtk_button_new_with_label (_("Volume Control..."));
+  g_signal_connect (more, "clicked", G_CALLBACK (launch_mixer_cb), dock);
+  gtk_box_pack_end (GTK_BOX (innerline), more, TRUE, TRUE, 0);
+
+  gtk_container_add (GTK_CONTAINER (dock), frame);
+
+  return GTK_WIDGET (dock);
+}
+
+static void
+destroy_source (MateVolumeAppletDock *dock)
+{
+  if (dock->timeout) {
+    g_source_remove (dock->timeout);
+    dock->timeout = 0;
+  }
+}
+
+static void
+mate_volume_applet_dock_dispose (GObject *object)
+{
+  MateVolumeAppletDock *dock = MATE_VOLUME_APPLET_DOCK (object);
+
+  destroy_source (dock);
+
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+/*
+ * Change the value of the slider. This is called both from a direct
+ * call from the +/- button callbacks and via a timer so holding down the
+ * buttons changes the volume.
+ */
+
+static gboolean
+cb_timeout (gpointer data)
+{
+  MateVolumeAppletDock *dock = data;
+  GtkAdjustment *adj;
+  gfloat volume;
+  gboolean res = TRUE;
+
+  if (!dock->timeout)
+    return FALSE;
+
+  adj = gtk_range_get_adjustment (dock->scale);
+  volume = gtk_range_get_value (dock->scale);
+  volume += dock->direction * gtk_adjustment_get_step_increment (adj);
+
+  if (volume <= gtk_adjustment_get_lower (adj)) {
+    volume = gtk_adjustment_get_lower (adj);
+    res = FALSE;
+  } else if (volume >= gtk_adjustment_get_upper (adj)) {
+    volume = gtk_adjustment_get_upper (adj);
+    res = FALSE;
+  }
+
+  gtk_range_set_value (dock->scale, volume);
+
+  if (!res)
+    dock->timeout = 0;
+
+  return res;
+}
+
+/*
+ * React if user presses +/- buttons.
+ */
+
+static gboolean
+cb_button_press (GtkWidget *widget,
+		 GdkEventButton *button,
+		 gpointer   data)
+{
+  MateVolumeAppletDock *dock = data;
+
+  dock->direction = (GTK_BUTTON (widget) == dock->plus) ? 1 : -1;
+  destroy_source (dock);
+  dock->timeout = g_timeout_add (100, cb_timeout, data);
+  cb_timeout (data);
+
+  return TRUE;
+}
+
+static gboolean
+cb_button_release (GtkWidget *widget,
+		   GdkEventButton *button,
+		   gpointer   data)
+{
+  MateVolumeAppletDock *dock = data;
+
+  destroy_source (dock);
+
+  return TRUE;
+}
+
+static gboolean
+cb_key_press (GtkWidget *widget,
+	      GdkEventKey *event,
+	      gpointer data)
+{
+
+  /* Trap the escape key to popdown the dock. */
+  if (event->keyval == GDK_Escape) {
+    /* This is trickier than it looks. The main applet is watching for
+     * this widget to loose focus. Hiding the widget causes a
+     * focus-loss, thus the applet gets the focus-out signal and all
+     * the book-keeping gets done (like setting the applet button
+     * hilight) without an explicit callback. */
+    gtk_widget_hide (widget);
+  }
+
+  return FALSE;
+}
+
+/*
+ * Set the adjustment for the slider.
+ */
+
+void
+mate_volume_applet_dock_change (MateVolumeAppletDock *dock,
+				 GtkAdjustment *adj)
+{
+  gtk_range_set_adjustment (dock->scale, adj);
+}
+
+void
+mate_volume_applet_dock_set_focus (MateVolumeAppletDock *dock)
+{
+  gtk_widget_grab_focus (GTK_WIDGET (dock->scale));
+}