diff options
Diffstat (limited to 'mixer/applet.c')
| -rw-r--r-- | mixer/applet.c | 1525 |
1 files changed, 1525 insertions, 0 deletions
diff --git a/mixer/applet.c b/mixer/applet.c new file mode 100644 index 00000000..ea539069 --- /dev/null +++ b/mixer/applet.c @@ -0,0 +1,1525 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ +/* MATE Volume Applet + * Copyright (C) 2004 Ronald Bultje <[email protected]> + * + * applet.c: the main applet + * + * 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 + +/* this is for lrint */ +#define _ISOC99_SOURCE +#include <math.h> +#include <string.h> + +#include <glib-object.h> +#include <gdk/gdkkeysyms.h> + +#include <gtk/gtk.h> + +#include <mateconf/mateconf-client.h> + +#include "applet.h" +#include "keys.h" +#include "preferences.h" + +#define IS_PANEL_HORIZONTAL(o) \ + (o == MATE_PANEL_APPLET_ORIENT_UP || o == MATE_PANEL_APPLET_ORIENT_DOWN) + +/* This is defined is load.c, we're doing this instead of creating a load.h file + * because nothing else is exported. */ +GList * mate_volume_applet_create_mixer_collection (void); + +static void mate_volume_applet_class_init (MateVolumeAppletClass *klass); +static void mate_volume_applet_init (MateVolumeApplet *applet); +static void mate_volume_applet_dispose (GObject *object); + +static void mate_volume_applet_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); + +static void mate_volume_applet_popup_dock (MateVolumeApplet *applet); +static void mate_volume_applet_popdown_dock (MateVolumeApplet *applet); + +/* This function and mate_volume_applet_key are not static so we can + * inject external events into the applet. Its to work around a GTK+ + * misfeature. See dock.c for details. */ +gboolean mate_volume_applet_scroll (GtkWidget *widget, + GdkEventScroll *event); +static gboolean mate_volume_applet_button (GtkWidget *widget, + GdkEventButton *event); +gboolean mate_volume_applet_key (GtkWidget *widget, + GdkEventKey *event); +static gdouble mate_volume_applet_get_volume (GstMixer *mixer, + GstMixerTrack *track); + +static void mate_volume_applet_background (MatePanelApplet *mate_panel_applet, + MatePanelAppletBackgroundType type, + GdkColor *colour, + GdkPixmap *pixmap); +static void mate_volume_applet_orientation (MatePanelApplet *applet, + MatePanelAppletOrient orient); + +static gboolean mate_volume_applet_refresh (MateVolumeApplet *applet, + gboolean force_refresh, + gdouble volume, + gint mute); + +static void cb_notify_message (GstBus *bus, GstMessage *message, gpointer data); +static gboolean cb_check (gpointer data); + +static void cb_volume (GtkAdjustment *adj, + gpointer data); + +static void cb_mateconf (MateConfClient *client, + guint connection_id, + MateConfEntry *entry, + gpointer data); + +static void cb_verb (GtkAction *action, + gpointer data); + +static void cb_theme_change (GtkIconTheme *icon_theme, + gpointer data); +static void cb_stop_scroll_events (GtkWidget *widget, + GdkEvent *event); + +static MatePanelAppletClass *parent_class = NULL; + + +G_DEFINE_TYPE (MateVolumeApplet, mate_volume_applet, PANEL_TYPE_APPLET) + + +static void +init_pixbufs (MateVolumeApplet *applet) +{ + static const gchar *pix_filenames[] = { + "audio-volume-muted", + "audio-volume-low", + "audio-volume-medium", + "audio-volume-high", + NULL + }; + gint n; + + for (n = 0; pix_filenames[n] != NULL; n++) { + if (applet->pix[n]) { + g_object_unref (applet->pix[n]); + applet->pix[n] = NULL; // mate_icon_theme_load_icon can call us + // recursively, so we have to be careful. + } + + applet->pix[n] = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), + pix_filenames[n], + applet->panel_size - 4, + 0, + NULL); + if (applet->pix[n] != NULL && + gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) { + GdkPixbuf *temp; + + temp = gdk_pixbuf_flip (applet->pix[n], TRUE); + g_object_unref (G_OBJECT (applet->pix[n])); + applet->pix[n] = temp; + } + } +} + +static void +mate_volume_applet_class_init (MateVolumeAppletClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *gtkwidget_class = GTK_WIDGET_CLASS (klass); + MatePanelAppletClass *matepanelapplet_class = MATE_PANEL_APPLET_CLASS (klass); + + parent_class = g_type_class_ref (PANEL_TYPE_APPLET); + + gobject_class->dispose = mate_volume_applet_dispose; + gtkwidget_class->key_press_event = mate_volume_applet_key; + gtkwidget_class->button_press_event = mate_volume_applet_button; + gtkwidget_class->scroll_event = mate_volume_applet_scroll; + gtkwidget_class->size_allocate = mate_volume_applet_size_allocate; + matepanelapplet_class->change_orient = mate_volume_applet_orientation; + matepanelapplet_class->change_background = mate_volume_applet_background; + + /* FIXME: + * - style-set. + */ +} + +static void +mate_volume_applet_init (MateVolumeApplet *applet) +{ + GtkWidget *image; + AtkObject *ao; + + applet->timeout = 0; + applet->elements = NULL; + applet->client = mateconf_client_get_default (); + applet->mixer = NULL; + applet->tracks = NULL; + applet->lock = FALSE; + applet->state = -1; + applet->prefs = NULL; + applet->dock = NULL; + applet->adjustment = NULL; + applet->panel_size = 24; + + g_set_application_name (_("Volume Applet")); + + /* init pixbufs */ + init_pixbufs (applet); + + /* icon (our main UI) */ + image = gtk_image_new (); + applet->image = GTK_IMAGE (image); + gtk_container_add (GTK_CONTAINER (applet), image); + gtk_widget_show (image); + gtk_window_set_default_icon_name ("multimedia-volume-control"); + + /* dock window (expanded UI) */ + applet->pop = FALSE; + + /* tooltip over applet */ + gtk_widget_set_tooltip_text (GTK_WIDGET (applet), _("Volume Control")); + + /* prevent scroll events from reaching the tooltip */ + g_signal_connect (G_OBJECT (applet), + "event-after", G_CALLBACK (cb_stop_scroll_events), + NULL); + + /* handle icon theme changes */ + g_signal_connect (gtk_icon_theme_get_default (), + "changed", G_CALLBACK (cb_theme_change), + applet); + + /* other stuff */ + mate_panel_applet_add_preferences (MATE_PANEL_APPLET (applet), + "/schemas/apps/mixer_applet/prefs", + NULL); + mate_panel_applet_set_flags (MATE_PANEL_APPLET (applet), + MATE_PANEL_APPLET_EXPAND_MINOR); + + /* i18n */ + ao = gtk_widget_get_accessible (GTK_WIDGET (applet)); + atk_object_set_name (ao, _("Volume Control")); + + /* Watch for signals from GST. */ + applet->bus = gst_bus_new (); + gst_bus_add_signal_watch (applet->bus); + g_signal_connect (G_OBJECT (applet->bus), "message::element", + (GCallback) cb_notify_message, applet); + +} + +/* Parse the list of tracks that are stored in MateConf */ + +static char ** +parse_track_list (const char *track_list) +{ + if (track_list) + return g_strsplit (track_list, ":", 0); + else + return NULL; +} + +static GList * +select_tracks (GstElement *element, + const char *active_track_names, + gboolean reset_state) +{ + const GList *tracks, *l; + GstMixerTrack *track_fallback; + GList *active_tracks; + char **active_track_name_list; + + active_tracks = NULL; + track_fallback = NULL; + active_track_name_list = NULL; + + if (reset_state) { + gst_element_set_state (element, GST_STATE_READY); + if (gst_element_get_state(element, NULL, NULL, -1) != GST_STATE_CHANGE_SUCCESS) + return NULL; + } + + tracks = gst_mixer_list_tracks (GST_MIXER (element)); + if (active_track_names) + active_track_name_list = parse_track_list (active_track_names); + + for (l = tracks; l; l = l->next) { + GstMixerTrack *track = l->data; + gint i; + + if (!track->num_channels) + continue; + + if (!track_fallback) + track_fallback = track; + + if (GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_MASTER)) + track_fallback = track; + + if (active_track_name_list) { + for (i = 0; active_track_name_list[i] != NULL; i++) { + gchar *track_test = active_track_name_list[i]; + + if (!strcmp (track_test, track->label)) + active_tracks = g_list_append (active_tracks, track); + } + } + } + + /* if the list had no matches and we've got a fallback track, + * then use it. */ + + if (!active_tracks && track_fallback) + active_tracks = g_list_append (active_tracks, track_fallback); + + if (!active_tracks && reset_state) { + gst_element_set_state (element, GST_STATE_NULL); + } + + g_strfreev (active_track_name_list); + return active_tracks; +} + +static gboolean +select_element_and_track (MateVolumeApplet *applet, + GList *elements, + const char *active_element_name, + const char *active_track_names) +{ + GstElement *active_element; + GList *active_tracks, *l; + + applet->elements = elements; + + active_element = NULL; + active_tracks = NULL; + + if (active_element_name) { + for (l = elements; l; l = l->next) { + GstElement *element = l->data; + const char *element_name; + + element_name = g_object_get_data (G_OBJECT (element), + "mate-volume-applet-name"); + + if (!strcmp (element_name, active_element_name)) { + active_element = element; + break; + } + } + } + + if (active_element) + active_tracks = select_tracks (active_element, active_track_names, TRUE); + + if (!active_tracks) { + active_element = NULL; + for (l = elements; l; l = l->next) { + GstElement *element = l->data; + + if ((active_tracks = select_tracks (element, active_track_names, TRUE))) { + active_element = element; + break; + } + } + } + + if (!active_element) + return FALSE; + + applet->mixer = g_object_ref (active_element); + gst_element_set_bus (GST_ELEMENT (applet->mixer), applet->bus); + applet->tracks = active_tracks; + g_list_foreach (applet->tracks, (GFunc) g_object_ref, NULL); + + return TRUE; +} + +static void +mate_volume_applet_setup_timeout (MateVolumeApplet *applet) +{ + gboolean need_timeout = TRUE; + need_timeout = ((gst_mixer_get_mixer_flags (GST_MIXER (applet->mixer)) & + GST_MIXER_FLAG_AUTO_NOTIFICATIONS) == 0); + + if (need_timeout) { + if (applet->timeout == 0) { + applet->timeout = g_timeout_add (100, cb_check, applet); + } + } + else { + if (applet->timeout != 0) { + g_source_remove (applet->timeout); + applet->timeout = 0; + } + } +} + +gboolean +mate_volume_applet_setup (MateVolumeApplet *applet, + GList *elements) +{ + GtkObject *adj; + static const GtkActionEntry actions[] = { + { "RunMixer", NULL, N_("_Open Volume Control"), + NULL, NULL, + G_CALLBACK (cb_verb) }, + { "Help", GTK_STOCK_HELP, N_("_Help"), + NULL, NULL, + G_CALLBACK (cb_verb) }, + { "About", GTK_STOCK_ABOUT, N_("_About"), + NULL, NULL, + G_CALLBACK (cb_verb) }, + { "Pref", GTK_STOCK_PROPERTIES, N_("_Preferences"), + NULL, NULL, + G_CALLBACK (cb_verb) } + }; + static const GtkToggleActionEntry toggle_actions[] = { + { "Mute", NULL, N_("Mu_te"), + NULL, NULL, + G_CALLBACK (cb_verb), FALSE } + }; + + gchar *key; + gchar *active_element_name; + gchar *active_track_name; + gchar *ui_path; + GstMixerTrack *first_track; + gboolean res; + + active_element_name = mate_panel_applet_mateconf_get_string (MATE_PANEL_APPLET (applet), + MATE_VOLUME_APPLET_KEY_ACTIVE_ELEMENT, + NULL); + + active_track_name = mate_panel_applet_mateconf_get_string (MATE_PANEL_APPLET (applet), + MATE_VOLUME_APPLET_KEY_ACTIVE_TRACK, + NULL); + + res = select_element_and_track (applet, elements, active_element_name, + active_track_name); + g_free (active_element_name); + g_free (active_track_name); + + if (res) { + first_track = g_list_first (applet->tracks)->data; + + applet->adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (50, 0, 100, + 4, 10, 0)); + /* We want a reference from the applet as well as from the dock it + * will be attached to. */ + g_object_ref_sink (applet->adjustment); + g_signal_connect (applet->adjustment, "value-changed", + G_CALLBACK (cb_volume), applet); + + gtk_adjustment_set_value (applet->adjustment, + mate_volume_applet_get_volume (applet->mixer, + first_track)); + } + + mate_volume_applet_orientation (MATE_PANEL_APPLET (applet), + mate_panel_applet_get_orient (MATE_PANEL_APPLET (applet))); + + /* menu */ + applet->action_group = gtk_action_group_new ("Mixer Applet Actions"); + gtk_action_group_set_translation_domain (applet->action_group, GETTEXT_PACKAGE); + gtk_action_group_add_actions (applet->action_group, + actions, + G_N_ELEMENTS (actions), + applet); + gtk_action_group_add_toggle_actions (applet->action_group, + toggle_actions, + G_N_ELEMENTS (toggle_actions), + applet); + ui_path = g_build_filename (MIXER_MENU_UI_DIR, "mixer-applet-menu.xml", NULL); + mate_panel_applet_setup_menu_from_file (MATE_PANEL_APPLET (applet), + ui_path, applet->action_group); + g_free (ui_path); + + mate_volume_applet_refresh (applet, TRUE, -1, -1); + if (res) { + mate_volume_applet_setup_timeout (applet); + + /* mateconf */ + key = mate_panel_applet_mateconf_get_full_key (MATE_PANEL_APPLET (applet), + MATE_VOLUME_APPLET_KEY_ACTIVE_ELEMENT); + mateconf_client_notify_add (applet->client, key, + cb_mateconf, applet, NULL, NULL); + g_free (key); + key = mate_panel_applet_mateconf_get_full_key (MATE_PANEL_APPLET (applet), + MATE_VOLUME_APPLET_KEY_ACTIVE_TRACK); + mateconf_client_notify_add (applet->client, key, + cb_mateconf, applet, NULL, NULL); + g_free (key); + } + + gtk_widget_show (GTK_WIDGET (applet)); + + return TRUE; +} + +static void +mate_volume_applet_dispose (GObject *object) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (object); + gint n; + + mate_volume_applet_popdown_dock (applet); + + if (applet->action_group) { + g_object_unref (applet->action_group); + applet->action_group = NULL; + } + + if (applet->elements) { + GList *item; + + for (item = applet->elements; item != NULL; item = item->next) { + GstElement *element = GST_ELEMENT (item->data); + + gst_element_set_state (element, GST_STATE_NULL); + gst_object_unref (GST_OBJECT (element)); + } + g_list_free (applet->elements); + applet->elements = NULL; + } + + if (applet->tracks) { + g_list_foreach (applet->tracks, (GFunc) g_object_unref, NULL); + g_list_free (applet->tracks); + applet->tracks = NULL; + } + + if (applet->mixer) { + gst_object_unref (GST_OBJECT (applet->mixer)); + applet->mixer = NULL; + } + + if (applet->timeout) { + g_source_remove (applet->timeout); + applet->timeout = 0; + } + + if (applet->dock) { + g_object_unref (applet->dock); + applet->dock = NULL; + } + + if (applet->adjustment) { + g_object_unref (applet->adjustment); + applet->adjustment = NULL; + } + + for (n = 0; n < 5; n++) { + if (applet->pix[n] != NULL) { + g_object_unref (G_OBJECT (applet->pix[n])); + applet->pix[n] = NULL; + } + } + + if (applet->bus) { + gst_bus_remove_signal_watch (applet->bus); + gst_object_unref (applet->bus); + applet->bus = NULL; + } + + G_OBJECT_CLASS (parent_class)->dispose (object); +} + +/* + * Show a dialog (once) when no mixer is available. + */ + +static void +show_no_mixer_dialog (MateVolumeApplet *applet) +{ + static gboolean shown = FALSE; + GtkWidget *dialog; + + if (shown) + return; + shown = TRUE; + + dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, "%s\n\n%s", + _("The volume control did not find any elements and/or " + "devices to control. This means either that you don't " + "have the right GStreamer plugins installed, or that you " + "don't have a sound card configured."), + _("You can remove the volume control from the panel by " + "right-clicking the speaker icon on the panel and " + "selecting \"Remove From Panel\" from the menu.")); + gtk_widget_show (dialog); + g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); +} + +/* + * get position that the dock should get based on applet position. + */ + +static void +mate_volume_applet_get_dock_position (MateVolumeApplet *applet, + gint *_x, gint *_y) +{ + GtkWidget *widget = GTK_WIDGET (applet); + GtkAllocation widget_allocation, dock_allocation; + gint x, y; + + gtk_widget_get_allocation (GTK_WIDGET (applet->dock), &dock_allocation); + gtk_widget_get_allocation (widget, &widget_allocation); + + gdk_window_get_origin (gtk_widget_get_window (widget), &x, &y); + switch (mate_panel_applet_get_orient (MATE_PANEL_APPLET (applet))) { + case MATE_PANEL_APPLET_ORIENT_DOWN: + x += widget_allocation.x; + x -= (dock_allocation.width - + widget_allocation.width) / 2; + y += widget_allocation.height + widget_allocation.y; + break; + case MATE_PANEL_APPLET_ORIENT_UP: + x += widget_allocation.x; + x -= (dock_allocation.width - + widget_allocation.width) / 2; + y += widget_allocation.y; + y -= dock_allocation.height; + break; + case MATE_PANEL_APPLET_ORIENT_RIGHT: + x += widget_allocation.width + widget_allocation.x; + y += widget_allocation.y; + y -= (dock_allocation.height - + widget_allocation.height) / 2; + break; + case MATE_PANEL_APPLET_ORIENT_LEFT: + x += widget_allocation.x; + x -= dock_allocation.width; + y += widget_allocation.y; + y -= (dock_allocation.height - + widget_allocation.height) / 2; + break; + default: + g_assert_not_reached (); + } + + *_x = x; + *_y = y; +} + +/* + * popup (show) or popdown (hide) the dock. + */ + +static void +mate_volume_applet_popup_dock (MateVolumeApplet *applet) +{ + GtkWidget *widget = GTK_WIDGET (applet); + gint x, y; + + /* Get it in just about the right position so that it + * doesn't flicker to obviously when we reposition it. */ + mate_volume_applet_get_dock_position (applet, &x, &y); + gtk_window_move (GTK_WINDOW (applet->dock), x, y); + + gtk_widget_show_all (GTK_WIDGET (applet->dock)); + + /* Reposition the window now that we know its actual size + * and can center it. */ + mate_volume_applet_get_dock_position (applet, &x, &y); + gtk_window_move (GTK_WINDOW (applet->dock), x, y); + + /* Set the keyboard focus in the correct place. */ + mate_volume_applet_dock_set_focus (applet->dock); + + /* set menu item as active */ + gtk_widget_set_state (GTK_WIDGET (applet), GTK_STATE_SELECTED); + + /* keep state */ + applet->pop = TRUE; +} + +static void +mate_volume_applet_popdown_dock (MateVolumeApplet *applet) +{ + GtkWidget *widget = GTK_WIDGET (applet); + + if (!applet->pop) + return; + + /* hide */ + gtk_widget_hide_all (GTK_WIDGET (applet->dock)); + + /* set menu item as active */ + gtk_widget_set_state (GTK_WIDGET (applet), GTK_STATE_NORMAL); + + /* keep state */ + applet->pop = FALSE; +} + +static void +mate_volume_applet_pop_dock (MateVolumeApplet *applet) +{ + if (applet->pop) { + mate_volume_applet_popdown_dock (applet); + } else { + mate_volume_applet_popup_dock (applet); + } +} + +static void +mate_volume_applet_update_mute_action (MateVolumeApplet *applet, + gboolean newmute) +{ + GtkAction *action; + + if (!applet->action_group) + return; + + action = gtk_action_group_get_action (applet->action_group, "Mute"); + if (newmute == gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action))) + return; + + gtk_action_block_activate (action); + gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), newmute); + gtk_action_unblock_activate (action); +} + +gboolean +mixer_is_muted (MateVolumeApplet *applet) +{ + return applet->state & 1; +} + +/* + * Toggle mute. + */ + +void +mate_volume_applet_toggle_mute (MateVolumeApplet *applet) +{ + gboolean mute = mixer_is_muted (applet); + gboolean newmute = !mute; + GList *tracks; + + for (tracks = g_list_first (applet->tracks); tracks; tracks = tracks->next) + gst_mixer_set_mute (applet->mixer, tracks->data, !mute); + + if (mute) { + /* sync back actual volume */ + cb_volume (applet->adjustment, applet); + } + + /* update menu */ + mate_volume_applet_update_mute_action (applet, newmute); + + /* update graphic - this should happen automagically after the next + * idle call, but apparently doesn't for some people... */ + mate_volume_applet_refresh (applet, TRUE, -1, newmute); +} + +/* + * Run g-v-c. + */ + +void +mate_volume_applet_run_mixer (MateVolumeApplet *applet) +{ + GError *error = NULL; + + gdk_spawn_command_line_on_screen (gtk_widget_get_screen (GTK_WIDGET (applet)), + "mate-volume-control", &error); + + if (error) { + GtkWidget *dialog; + + dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("Failed to start Volume Control: %s"), + error->message); + g_signal_connect (dialog, "response", + G_CALLBACK (gtk_widget_destroy), NULL); + gtk_widget_show (dialog); + g_error_free (error); + } +} + +/* + * Control events, change volume and so on. + */ + +/* This is not static so we can inject external events + * into the applet. Its to work around a GTK+ misfeature. See dock.c + * for details. */ + +gboolean +mate_volume_applet_scroll (GtkWidget *widget, + GdkEventScroll *event) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (widget); + + if (!applet->mixer) { + show_no_mixer_dialog (applet); + return TRUE; + } + + if (event->type == GDK_SCROLL) { + switch (event->direction) { + case GDK_SCROLL_UP: + case GDK_SCROLL_DOWN: { + gdouble volume = gtk_adjustment_get_value (applet->adjustment); + + if (event->direction == GDK_SCROLL_UP) { + volume += gtk_adjustment_get_step_increment (applet->adjustment); + if (volume > gtk_adjustment_get_upper (applet->adjustment)) + volume = gtk_adjustment_get_upper (applet->adjustment); + } else { + volume -= gtk_adjustment_get_step_increment (applet->adjustment); + if (volume < gtk_adjustment_get_lower (applet->adjustment)) + volume = gtk_adjustment_get_lower (applet->adjustment); + } + + gtk_adjustment_set_value (applet->adjustment, volume); + return TRUE; + } + default: + break; + } + } + + if (GTK_WIDGET_CLASS (parent_class)->scroll_event) + return GTK_WIDGET_CLASS (parent_class)->scroll_event (widget, event); + else + return FALSE; +} + +static gboolean +mate_volume_applet_button (GtkWidget *widget, + GdkEventButton *event) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (widget); + + if (event->window != gtk_widget_get_window (GTK_WIDGET (applet)) && + event->type == GDK_BUTTON_PRESS) { + mate_volume_applet_popdown_dock (applet); + return TRUE; + } else if (event->window == gtk_widget_get_window (GTK_WIDGET (applet))) { + switch (event->button) { + case 1: + switch (event->type) { + case GDK_BUTTON_PRESS: + if (!applet->mixer) { + show_no_mixer_dialog (applet); + } else { + mate_volume_applet_pop_dock (applet); + } + return TRUE; + case GDK_2BUTTON_PRESS: + if (applet->mixer) { + mate_volume_applet_popdown_dock (applet); + } + mate_volume_applet_toggle_mute (applet); + return TRUE; + default: + break; + } + break; + case 2: /* move */ + case 3: /* menu */ + if (applet->pop) { + mate_volume_applet_popdown_dock (applet); + return TRUE; + } + break; + default: + break; + } + } + + if (GTK_WIDGET_CLASS (parent_class)->button_press_event) + return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, event); + + return FALSE; +} + +/* This is not static so we can inject external events + * into the applet. Its to work around a GTK+ misfeature. See dock.c + * for details. */ + +gboolean +mate_volume_applet_key (GtkWidget *widget, + GdkEventKey *event) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (widget); + + if (!applet->mixer) { + show_no_mixer_dialog (applet); + } else switch (event->keyval) { + case GDK_KP_Enter: + case GDK_ISO_Enter: + case GDK_3270_Enter: + case GDK_Return: + case GDK_space: + case GDK_KP_Space: + mate_volume_applet_pop_dock (applet); + return TRUE; + case GDK_m: + if (event->state == GDK_CONTROL_MASK) { + mate_volume_applet_toggle_mute (applet); + return TRUE; + } + break; + case GDK_o: + if (event->state == GDK_CONTROL_MASK) { + mate_volume_applet_run_mixer (applet); + return TRUE; + } + break; + case GDK_Escape: + mate_volume_applet_popdown_dock (applet); + return TRUE; + case GDK_Page_Up: + case GDK_Page_Down: + case GDK_Left: + case GDK_Right: + case GDK_Up: + case GDK_Down: { + gdouble volume = gtk_adjustment_get_value (applet->adjustment); + gdouble increment; + + if (event->state != 0) + break; + + if (event->keyval == GDK_Up || event->keyval == GDK_Down + ||event->keyval == GDK_Left) + increment = gtk_adjustment_get_step_increment (applet->adjustment); + else + increment = gtk_adjustment_get_page_increment (applet->adjustment); + + if (event->keyval == GDK_Page_Up || event->keyval == GDK_Up + ||event->keyval == GDK_Right) { + volume += increment; + if (volume > gtk_adjustment_get_upper (applet->adjustment)) + volume = gtk_adjustment_get_upper (applet->adjustment); + } else { + volume -= increment; + if (volume < gtk_adjustment_get_lower (applet->adjustment)) + volume = gtk_adjustment_get_lower (applet->adjustment); + } + + gtk_adjustment_set_value (applet->adjustment, volume); + return TRUE; + } + default: + break; + } + + return GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event); +} + +static gboolean +mate_volume_applet_dock_focus_out (GtkWidget *dock, GdkEventFocus *event, + MateVolumeApplet *applet) +{ + mate_volume_applet_popdown_dock (applet); + + return FALSE; +} + +/* + * Change orientation or size of panel. + */ + +static void +mate_volume_applet_orientation (MatePanelApplet *_applet, + MatePanelAppletOrient orientation) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (_applet); + GtkWidget *dock; + + if (applet->dock) { + gtk_widget_destroy (GTK_WIDGET (applet->dock)); + } + dock = mate_volume_applet_dock_new (GTK_ORIENTATION_VERTICAL, + applet); + g_object_ref_sink (dock); /* It isn't a child, but we do own it. */ + gtk_widget_add_events (dock, GDK_FOCUS_CHANGE_MASK); + g_signal_connect (G_OBJECT (dock), "focus-out-event", + G_CALLBACK (mate_volume_applet_dock_focus_out), + applet); + applet->dock = MATE_VOLUME_APPLET_DOCK (dock); + mate_volume_applet_dock_change (applet->dock, applet->adjustment); + + if (MATE_PANEL_APPLET_CLASS (parent_class)->change_orient) + MATE_PANEL_APPLET_CLASS (parent_class)->change_orient (_applet, orientation); +} + +void mate_volume_applet_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (widget); + MatePanelAppletOrient orient; + + if (GTK_WIDGET_CLASS (parent_class)->size_allocate) + GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation); + + orient = mate_panel_applet_get_orient (MATE_PANEL_APPLET (applet)); + + if (orient == MATE_PANEL_APPLET_ORIENT_UP || orient == MATE_PANEL_APPLET_ORIENT_DOWN) { + if (applet->panel_size == allocation->height) + return; + applet->panel_size = allocation->height; + } + else { + if (applet->panel_size == allocation->width) + return; + applet->panel_size = allocation->width; + } + + init_pixbufs (applet); + mate_volume_applet_refresh (applet, TRUE, -1, -1); +} + +static void +mate_volume_applet_background (MatePanelApplet *_applet, + MatePanelAppletBackgroundType type, + GdkColor *colour, + GdkPixmap *pixmap) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (_applet); + GtkRcStyle *rc_style; + GtkStyle *style; + + /* reset style */ + gtk_widget_set_style (GTK_WIDGET (applet), NULL); + rc_style = gtk_rc_style_new (); + gtk_widget_modify_style (GTK_WIDGET (applet), rc_style); + g_object_unref (rc_style); + + switch (type) { + case PANEL_NO_BACKGROUND: + break; + case PANEL_COLOR_BACKGROUND: + gtk_widget_modify_bg (GTK_WIDGET (applet), + GTK_STATE_NORMAL, colour); + break; + case PANEL_PIXMAP_BACKGROUND: + style = gtk_style_copy (gtk_widget_get_style (GTK_WIDGET (applet))); + if (style->bg_pixmap[GTK_STATE_NORMAL]) + g_object_unref (style->bg_pixmap[GTK_STATE_NORMAL]); + style->bg_pixmap[GTK_STATE_NORMAL] = g_object_ref (pixmap); + gtk_widget_set_style (GTK_WIDGET (applet), style); + g_object_unref (style); + break; + } +} + +/* + * This needs to be here because not all tracks have the same volume range, + * so you can send this function the track and a new volume and it will be + * scaled according to the volume range of the track in question. + */ + +void +mate_volume_applet_adjust_volume (GstMixer *mixer, + GstMixerTrack *track, + gdouble volume) +{ + int range = track->max_volume - track->min_volume; + gdouble scale = ((gdouble) range) / 100; + int *volumes, n, volint; + + if (volume == 1.0) { + volint = track->max_volume; + } else if (volume == 0.0) { + volint = track->min_volume; + } else { + volume *= scale; + volume += track->min_volume; + volint = lrint (volume); + } + + volumes = g_new (gint, track->num_channels); + for (n = 0; n < track->num_channels; n++) + volumes[n] = volint; + gst_mixer_set_volume (mixer, track, volumes); + + g_free (volumes); +} + +static gdouble +mate_volume_applet_get_volume (GstMixer *mixer, + GstMixerTrack *track) +{ + int *volumes, n; + gdouble j; + + if (!track || !mixer) + return -1; + + volumes = g_new (gint, track->num_channels); + gst_mixer_get_volume (mixer, track, volumes); + + j = 0; + for (n = 0; n < track->num_channels; n++) + j += volumes[n]; + g_free (volumes); + j /= track->num_channels; + + return 100 * (j - track->min_volume) / (track->max_volume - track->min_volume); +} + +/* + * Volume changed. + */ + +static void +cb_volume (GtkAdjustment *adj, + gpointer data) +{ + MateVolumeApplet *applet = data; + gdouble v; + GList *iter; + + if (applet->lock) + return; + applet->lock = TRUE; + + v = gtk_adjustment_get_value (adj); + + for (iter = g_list_first (applet->tracks); iter; iter = iter->next) { + GstMixerTrack *track = iter->data; + mate_volume_applet_adjust_volume (applet->mixer, track, v); + } + + applet->lock = FALSE; + applet->force_next_update = TRUE; + mate_volume_applet_refresh (MATE_VOLUME_APPLET (data), FALSE, v, -1); +} + +/* + * Automatic timer. Check for changes. + */ + +#define STATE(vol,m) (((gint) vol << 1) | (m ? 1 : 0)) + +static gboolean +mate_volume_applet_refresh (MateVolumeApplet *applet, + gboolean force_refresh, + gdouble volume, + gint mute) +{ + GdkPixbuf *pixbuf; + gint n; + gboolean show_mute, did_change; + gchar *tooltip_str; + GstMixerTrack *first_track; + GString *track_names; + GList *iter; + + show_mute = 0; + + if (!applet->mixer) { + n = 0; + show_mute = 0; + mute = 0; + } else if (!applet->tracks) { + return FALSE; + } else { + first_track = g_list_first (applet->tracks)->data; + if (volume == -1) { + /* only first track */ + volume = mate_volume_applet_get_volume (applet->mixer, first_track); + } + if (mute == -1) { + mute = GST_MIXER_TRACK_HAS_FLAG (first_track, + GST_MIXER_TRACK_MUTE) ? 1 : 0; + } + if (volume <= 0 || mute) { + show_mute = 1; + n = 0; + } + else { + /* select image */ + n = 3 * volume / 100 + 1; + if (n < 1) + n = 1; + if (n > 3) + n = 3; + } + } + + did_change = (force_refresh || (STATE (volume, mute) != applet->state) || + applet->force_next_update); + applet->force_next_update = FALSE; + + if (did_change) { + if (show_mute) { + pixbuf = applet->pix[0]; + } else { + pixbuf = applet->pix[n]; + } + + gtk_image_set_from_pixbuf (applet->image, pixbuf); + applet->state = STATE (volume, mute); + + if (applet->dock) { + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (applet->dock->mute), + mute); + } + } + + if (!did_change || !applet->mixer) + return did_change; + + /* build names of selecter tracks */ + track_names = g_string_new (""); + for (iter = g_list_first (applet->tracks); iter; iter = iter->next) { + GstMixerTrack *track = iter->data; + + if (iter->next != NULL) + g_string_append_printf (track_names, "%s / ", track->label); + else + track_names = g_string_append (track_names, track->label); + } + + if (show_mute) { + tooltip_str = g_strdup_printf (_("%s: muted"), track_names->str); + } else { + /* Translator comment: I'm not all too sure if this makes sense + * to mark as a translation, but anyway. The string is a list of + * selected tracks, the number is the volume in percent. You + * most likely want to keep this as-is. */ + tooltip_str = g_strdup_printf (_("%s: %d%%"), track_names->str, + (int) volume); + } + g_string_free (track_names, TRUE); + + gtk_widget_set_tooltip_text (GTK_WIDGET (applet), tooltip_str); + g_free (tooltip_str); + + applet->lock = TRUE; + if (volume != 0) { + gtk_adjustment_set_value (applet->adjustment, volume); + } + applet->lock = FALSE; + + /* update mute status */ + mate_volume_applet_update_mute_action (applet, mute); + + return did_change; +} + +static void +cb_notify_message (GstBus *bus, GstMessage *message, gpointer data) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (data); + GstMixerMessageType type; + GstMixerTrack *first_track; + GstMixerTrack *track = NULL; + gint mute; + gdouble volume; + + if (applet->tracks == NULL || + GST_MESSAGE_SRC (message) != GST_OBJECT (applet->mixer)) { + /* No tracks, or not from our mixer - can't update anything anyway */ + return; + } + + volume = mute = -1; + + first_track = g_list_first (applet->tracks)->data; + + /* 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) { + gboolean muted; + gst_mixer_message_parse_mute_toggled (message, &track, &muted); + mute = muted ? 1 : 0; + } + else if (type == GST_MIXER_MESSAGE_VOLUME_CHANGED) { + gint n, num_channels, *vols; + volume = 0.0; + + gst_mixer_message_parse_volume_changed (message, &track, &vols, &num_channels); + for (n = 0; n < num_channels; n++) + volume += vols[n]; + volume /= track->num_channels; + volume = 100 * volume / (track->max_volume - track->min_volume); + } else + { + return; + } + + if (first_track == track) + mate_volume_applet_refresh (MATE_VOLUME_APPLET (data), FALSE, volume, mute); +} + +static gboolean +cb_check (gpointer data) +{ + static int time_counter = -1; + static int timeout = 15; + static gboolean recent_change = FALSE; + gboolean did_change; + + time_counter++; + + /* + * This timeout is called 10 times per second. Only do the update every + * 15 times this function is called (every 1.5 seconds), unless the value + * actually changed. + */ + if (time_counter % timeout == 0 || recent_change) { + did_change = mate_volume_applet_refresh (MATE_VOLUME_APPLET (data), + FALSE, -1, -1); + + /* + * If a change was done, set recent_change so that the update is + * done 10 times a second for 10 seconds and reset the counter to 0. + * This way we update frequently for 10 seconds after the last time + * the value is actually changed. + */ + if (did_change) { + recent_change = TRUE; + time_counter = 0; + timeout = 100; + } else if (time_counter % timeout == 0) { + /* + * When the counter gets to the timeout, reset recent_change and + * time_counter so we go back to the behavior where we only check + * every 15 times the function is called. + */ + recent_change = FALSE; + time_counter = 0; + timeout = 15; + } + } + + return TRUE; +} + +/* + * MateConf callback. + */ + +static void +cb_mateconf (MateConfClient *client, + guint connection_id, + MateConfEntry *entry, + gpointer data) +{ + MateVolumeApplet *applet = data; + MateConfValue *value; + const gchar *str, *key; + const GList *item; + gboolean newdevice = FALSE; + gchar *keyroot; + GList *active_tracks; + + active_tracks = NULL; + + keyroot = mate_panel_applet_mateconf_get_full_key (MATE_PANEL_APPLET (applet), ""); + key = mateconf_entry_get_key (entry); + if (strncmp (key, keyroot, strlen (keyroot))) { + g_free (keyroot); + return; + } + key += strlen (keyroot); + g_free (keyroot); + + g_list_free(applet->elements); + applet->elements = mate_volume_applet_create_mixer_collection (); + + if ((value = mateconf_entry_get_value (entry)) != NULL && + (value->type == MATECONF_VALUE_STRING) && + (str = mateconf_value_get_string (value)) != NULL) { + if (!strcmp (key, MATE_VOLUME_APPLET_KEY_ACTIVE_ELEMENT)) { + for (item = applet->elements; item != NULL; item = item->next) { + gchar *cur_el_str = g_object_get_data (item->data, + "mate-volume-applet-name"); + + if (!strcmp (cur_el_str, str)) { + GstElement *old_element = GST_ELEMENT (applet->mixer), + *new_element = item->data; + + if (new_element != old_element) { + /* change element */ + gst_element_set_state (item->data, GST_STATE_READY); + if (gst_element_get_state (item->data, NULL, NULL, -1) != GST_STATE_CHANGE_SUCCESS) + continue; + + /* save */ + gst_object_replace ((GstObject **) &applet->mixer, item->data); + gst_element_set_state (old_element, GST_STATE_NULL); + mate_volume_applet_setup_timeout (applet); + newdevice = TRUE; + } + break; + } + } + } + + if (!strcmp (key, MATE_VOLUME_APPLET_KEY_ACTIVE_TRACK) || newdevice) { + if (!active_tracks) { + active_tracks = select_tracks (GST_ELEMENT (applet->mixer), str, FALSE); + } + + if (active_tracks) { + GstMixerTrack *first_track; + + /* copy the newly created track list over to the main list */ + g_list_free (applet->tracks); + applet->tracks = g_list_copy (active_tracks); + + first_track = g_list_first (active_tracks)->data; + + /* dock */ + gtk_adjustment_set_value (applet->adjustment, + mate_volume_applet_get_volume (applet->mixer, + first_track)); + + /* if preferences window is open, update */ + if (applet->prefs) { + mate_volume_applet_preferences_change ( + MATE_VOLUME_APPLET_PREFERENCES (applet->prefs), + applet->mixer, applet->tracks); + } + + applet->force_next_update = TRUE; + } + } + } +} + +/* + * verb callback. + */ + +static void +cb_prefs_destroy (GtkWidget *widget, + gpointer data) +{ + MATE_VOLUME_APPLET (data)->prefs = NULL; +} + +static void +cb_verb (GtkAction *action, + gpointer data) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (data); + const gchar *verbname = gtk_action_get_name (action); + + if (!strcmp (verbname, "RunMixer")) { + mate_volume_applet_run_mixer (applet); + } else if (!strcmp (verbname, "Help")) { + GError *error = NULL; + + gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (applet)), + "ghelp:mixer_applet2", + gtk_get_current_event_time (), + &error); + + if (error) { + GtkWidget *dialog; + + dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("Failed to display help: %s"), + error->message); + g_signal_connect (dialog, "response", + G_CALLBACK (gtk_widget_destroy), NULL); + gtk_widget_show (dialog); + g_error_free (error); + } + } else if (!strcmp (verbname, "About")) { + + const gchar *authors[] = { "Ronald Bultje <[email protected]>", + NULL }; + + char *comments = g_strdup_printf ("%s\n\n%s", + _("Volume control for your MATE Panel."), + _("Using GStreamer 0.10.") + ); + + gtk_show_about_dialog (NULL, + "version", VERSION, + "copyright", "\xC2\xA9 2004 Ronald Bultje", + "comments", comments, + "authors", authors, + "translator-credits", _("translator-credits"), + "logo-icon-name", "multimedia-volume-control", + NULL); + + g_free (comments); + + } else if (!strcmp (verbname, "Pref")) { + if (!applet->mixer) { + show_no_mixer_dialog (applet); + } else { + if (applet->prefs) + return; + + g_list_free(applet->elements); + applet->elements = mate_volume_applet_create_mixer_collection (); + + applet->prefs = mate_volume_applet_preferences_new (MATE_PANEL_APPLET (applet), + applet->elements, + applet->mixer, + applet->tracks); + g_signal_connect (applet->prefs, "destroy", + G_CALLBACK (cb_prefs_destroy), applet); + gtk_widget_show (applet->prefs); + } + } else if (!strcmp (verbname, "Mute")) { + if (!applet->mixer) { + show_no_mixer_dialog (applet); + } else { + gboolean mute = applet->state & 1, + want_mute = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)); + if (mute != want_mute) + mate_volume_applet_toggle_mute (applet); + } + } else { + g_warning ("Unknown menu action '%s'", verbname); + } +} + +static void +cb_theme_change (GtkIconTheme *icon_theme, + gpointer data) +{ + MateVolumeApplet *applet = MATE_VOLUME_APPLET (data); + + init_pixbufs (applet); + mate_volume_applet_refresh (applet, TRUE, -1, -1); +} + +/* + * Block the tooltips event-after handler on scroll events. + */ + +static void +cb_stop_scroll_events (GtkWidget *widget, + GdkEvent *event) +{ + if (event->type == GDK_SCROLL) + g_signal_stop_emission_by_name (widget, "event-after"); +} |