← Back to branch summary

~ubuntu-branches/ubuntu/vivid/gnome-flashback/vivid

« back to all changes in this revision

Viewing changes to gnome-flashback/libsound-applet/gvc-applet.c

  • Committer: Package Import Robot
  • Author(s): Dmitry Shachnev
  • Date: 2014-09-19 17:09:43 UTC
  • Revision ID: package-import@ubuntu.com-20140919170943-oboafsedi6z69951
Tags: upstream-3.10.0
Import upstream version 3.10.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnome-flashback/libsound-applet/gvc-applet.c
 
1
/*
 
2
 * Copyright (C) 2008 Red Hat, Inc.
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation, either version 3 of the License, or
 
7
 * (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 
16
 */
 
17
 
 
18
#include "config.h"
 
19
 
 
20
#include <stdlib.h>
 
21
#include <stdio.h>
 
22
#include <fcntl.h>
 
23
#include <unistd.h>
 
24
#include <string.h>
 
25
#include <errno.h>
 
26
 
 
27
#include <glib.h>
 
28
#include <glib/gi18n.h>
 
29
#include <gtk/gtk.h>
 
30
#include <pulse/pulseaudio.h>
 
31
 
 
32
#include "gvc-applet.h"
 
33
#include "gvc-mixer-control.h"
 
34
#include "gvc-stream-status-icon.h"
 
35
 
 
36
#define GVC_APPLET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GVC_TYPE_APPLET, GvcAppletPrivate))
 
37
 
 
38
#define SCALE_SIZE 128
 
39
 
 
40
static const char *output_icon_names[] = {
 
41
        "audio-volume-muted-symbolic",
 
42
        "audio-volume-low-symbolic",
 
43
        "audio-volume-medium-symbolic",
 
44
        "audio-volume-high-symbolic",
 
45
        NULL
 
46
};
 
47
 
 
48
static const char *input_icon_names[] = {
 
49
        "audio-input-microphone-muted-symbolic",
 
50
        "audio-input-microphone-low-symbolic",
 
51
        "audio-input-microphone-medium-symbolic",
 
52
        "audio-input-microphone-high-symbolic",
 
53
        NULL
 
54
};
 
55
 
 
56
struct GvcAppletPrivate
 
57
{
 
58
        GvcStreamStatusIcon *input_status_icon;
 
59
        GvcStreamStatusIcon *output_status_icon;
 
60
        GvcMixerControl     *control;
 
61
};
 
62
 
 
63
static void     gvc_applet_class_init (GvcAppletClass *klass);
 
64
static void     gvc_applet_init       (GvcApplet      *applet);
 
65
static void     gvc_applet_finalize   (GObject        *object);
 
66
 
 
67
G_DEFINE_TYPE (GvcApplet, gvc_applet, G_TYPE_OBJECT)
 
68
 
 
69
static void
 
70
maybe_show_status_icons (GvcApplet *applet)
 
71
{
 
72
        gboolean        show;
 
73
        GvcMixerStream *stream;
 
74
        GSList         *source_outputs, *l;
 
75
 
 
76
        show = TRUE;
 
77
        stream = gvc_mixer_control_get_default_sink (applet->priv->control);
 
78
        if (stream == NULL) {
 
79
                show = FALSE;
 
80
        }
 
81
        gtk_status_icon_set_visible (GTK_STATUS_ICON (applet->priv->output_status_icon), show);
 
82
 
 
83
 
 
84
        show = FALSE;
 
85
        stream = gvc_mixer_control_get_default_source (applet->priv->control);
 
86
        source_outputs = gvc_mixer_control_get_source_outputs (applet->priv->control);
 
87
        if (stream != NULL && source_outputs != NULL) {
 
88
                /* Check that we're not trying to add the peak detector
 
89
                 * as an application doing recording */
 
90
                for (l = source_outputs ; l ; l = l->next) {
 
91
                        GvcMixerStream *s = l->data;
 
92
                        const char *id;
 
93
 
 
94
                        id = gvc_mixer_stream_get_application_id (s);
 
95
                        if (id == NULL) {
 
96
                                show = TRUE;
 
97
                                break;
 
98
                        }
 
99
 
 
100
                        if (!g_str_equal (id, "org.gnome.VolumeControl") &&
 
101
                            !g_str_equal (id, "org.PulseAudio.pavucontrol")) {
 
102
                                show = TRUE;
 
103
                                break;
 
104
                        }
 
105
                }
 
106
        }
 
107
        gtk_status_icon_set_visible (GTK_STATUS_ICON (applet->priv->input_status_icon), show);
 
108
 
 
109
        g_slist_free (source_outputs);
 
110
}
 
111
 
 
112
void
 
113
gvc_applet_start (GvcApplet *applet)
 
114
{
 
115
        g_return_if_fail (GVC_IS_APPLET (applet));
 
116
 
 
117
        maybe_show_status_icons (applet);
 
118
}
 
119
 
 
120
static void
 
121
gvc_applet_dispose (GObject *object)
 
122
{
 
123
        GvcApplet *applet = GVC_APPLET (object);
 
124
 
 
125
        if (applet->priv->control != NULL) {
 
126
                g_object_unref (applet->priv->control);
 
127
                applet->priv->control = NULL;
 
128
        }
 
129
 
 
130
        G_OBJECT_CLASS (gvc_applet_parent_class)->dispose (object);
 
131
}
 
132
 
 
133
static void
 
134
update_default_source (GvcApplet *applet)
 
135
{
 
136
        GvcMixerStream *stream;
 
137
 
 
138
        stream = gvc_mixer_control_get_default_source (applet->priv->control);
 
139
        if (stream != NULL) {
 
140
                gvc_stream_status_icon_set_mixer_stream (applet->priv->input_status_icon,
 
141
                                                         stream);
 
142
                maybe_show_status_icons(applet);
 
143
        } else {
 
144
                g_debug ("Unable to get default source, or no source available");
 
145
        }
 
146
}
 
147
 
 
148
static void
 
149
update_default_sink (GvcApplet *applet)
 
150
{
 
151
        GvcMixerStream *stream;
 
152
 
 
153
        stream = gvc_mixer_control_get_default_sink (applet->priv->control);
 
154
        if (stream != NULL) {
 
155
                gvc_stream_status_icon_set_mixer_stream (applet->priv->output_status_icon,
 
156
                                                         stream);
 
157
                maybe_show_status_icons(applet);
 
158
        } else {
 
159
                g_warning ("Unable to get default sink");
 
160
        }
 
161
}
 
162
 
 
163
static void
 
164
on_control_state_changed (GvcMixerControl      *control,
 
165
                          GvcMixerControlState  new_state,
 
166
                          GvcApplet            *applet)
 
167
{
 
168
        if (new_state == GVC_STATE_READY)  {
 
169
                update_default_sink (applet);
 
170
                update_default_source (applet);
 
171
        } else if (new_state == GVC_STATE_CONNECTING) {
 
172
                g_debug ("Connecting...");
 
173
        }
 
174
}
 
175
 
 
176
static void
 
177
on_control_default_sink_changed (GvcMixerControl *control,
 
178
                                 guint            id,
 
179
                                 GvcApplet       *applet)
 
180
{
 
181
        update_default_sink (applet);
 
182
}
 
183
 
 
184
static void
 
185
on_control_default_source_changed (GvcMixerControl *control,
 
186
                                   guint            id,
 
187
                                   GvcApplet       *applet)
 
188
{
 
189
        update_default_source (applet);
 
190
}
 
191
 
 
192
static void
 
193
on_control_stream_removed (GvcMixerControl *control,
 
194
                           guint            id,
 
195
                           GvcApplet       *applet)
 
196
{
 
197
        maybe_show_status_icons (applet);
 
198
}
 
199
 
 
200
static void
 
201
on_control_stream_added (GvcMixerControl *control,
 
202
                         guint            id,
 
203
                         GvcApplet       *applet)
 
204
{
 
205
        maybe_show_status_icons (applet);
 
206
}
 
207
 
 
208
static GObject *
 
209
gvc_applet_constructor (GType                  type,
 
210
                        guint                  n_construct_properties,
 
211
                        GObjectConstructParam *construct_params)
 
212
{
 
213
        GObject   *object;
 
214
        GvcApplet *self;
 
215
 
 
216
        object = G_OBJECT_CLASS (gvc_applet_parent_class)->constructor (type, n_construct_properties, construct_params);
 
217
 
 
218
        self = GVC_APPLET (object);
 
219
 
 
220
        self->priv->control = gvc_mixer_control_new ("GNOME Volume Control Applet");
 
221
        g_signal_connect (self->priv->control,
 
222
                          "state-changed",
 
223
                          G_CALLBACK (on_control_state_changed),
 
224
                          self);
 
225
        g_signal_connect (self->priv->control,
 
226
                          "default-sink-changed",
 
227
                          G_CALLBACK (on_control_default_sink_changed),
 
228
                          self);
 
229
        g_signal_connect (self->priv->control,
 
230
                          "default-source-changed",
 
231
                          G_CALLBACK (on_control_default_source_changed),
 
232
                          self);
 
233
        g_signal_connect (self->priv->control,
 
234
                          "stream-added",
 
235
                          G_CALLBACK (on_control_stream_added),
 
236
                          self);
 
237
        g_signal_connect (self->priv->control,
 
238
                          "stream-removed",
 
239
                          G_CALLBACK (on_control_stream_removed),
 
240
                          self);
 
241
 
 
242
        gvc_mixer_control_open (self->priv->control);
 
243
 
 
244
        return object;
 
245
}
 
246
 
 
247
static void
 
248
gvc_applet_class_init (GvcAppletClass *klass)
 
249
{
 
250
        GObjectClass   *object_class = G_OBJECT_CLASS (klass);
 
251
 
 
252
        object_class->finalize = gvc_applet_finalize;
 
253
        object_class->dispose = gvc_applet_dispose;
 
254
        object_class->constructor = gvc_applet_constructor;
 
255
 
 
256
        g_type_class_add_private (klass, sizeof (GvcAppletPrivate));
 
257
}
 
258
 
 
259
static void
 
260
gvc_applet_init (GvcApplet *applet)
 
261
{
 
262
        applet->priv = GVC_APPLET_GET_PRIVATE (applet);
 
263
 
 
264
        applet->priv->output_status_icon = gvc_stream_status_icon_new (NULL,
 
265
                                                                       output_icon_names);
 
266
        gvc_stream_status_icon_set_display_name (applet->priv->output_status_icon,
 
267
                                                 _("Output"));
 
268
        gtk_status_icon_set_title (GTK_STATUS_ICON (applet->priv->output_status_icon),
 
269
                                   _("Sound Output Volume"));
 
270
        applet->priv->input_status_icon = gvc_stream_status_icon_new (NULL,
 
271
                                                                      input_icon_names);
 
272
        gvc_stream_status_icon_set_display_name (applet->priv->input_status_icon,
 
273
                                                 _("Input"));
 
274
        gtk_status_icon_set_title (GTK_STATUS_ICON (applet->priv->input_status_icon),
 
275
                                   _("Microphone Volume"));
 
276
}
 
277
 
 
278
static void
 
279
gvc_applet_finalize (GObject *object)
 
280
{
 
281
        GvcApplet *applet;
 
282
 
 
283
        g_return_if_fail (object != NULL);
 
284
        g_return_if_fail (GVC_IS_APPLET (object));
 
285
 
 
286
        applet = GVC_APPLET (object);
 
287
 
 
288
        g_return_if_fail (applet->priv != NULL);
 
289
 
 
290
 
 
291
        G_OBJECT_CLASS (gvc_applet_parent_class)->finalize (object);
 
292
}
 
293
 
 
294
GvcApplet *
 
295
gvc_applet_new (void)
 
296
{
 
297
        GObject *applet;
 
298
 
 
299
        applet = g_object_new (GVC_TYPE_APPLET, NULL);
 
300
 
 
301
        gvc_applet_start (GVC_APPLET (applet));
 
302
 
 
303
        return GVC_APPLET (applet);
 
304
}