Mercurial > pidgin3 / file comparison

comparison: src/gtksound.c

src/gtksound.c

changeset 14253
b63ebf84c42b
parent 14252
d10dda2777a9
child 14254
77edc7a6191a
equal deleted inserted replaced
14252:d10dda2777a9 14253:b63ebf84c42b
1 /*
2 * @file gtksound.h GTK+ Sound
3 * @ingroup gtkui
4 *
5 * gaim
6 *
7 * Gaim is the legal property of its developers, whose names are too numerous
8 * to list here. Please refer to the COPYRIGHT file distributed with this
9 * source distribution.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26 #include "internal.h"
27 #include "gtkgaim.h"
28
29 #ifdef _WIN32
30 #include <windows.h>
31 #include <mmsystem.h>
32 #endif
33
34 #ifdef USE_GSTREAMER
35 # include <gst/gst.h>
36 #endif /* USE_GSTREAMER */
37
38 #include "debug.h"
39 #include "notify.h"
40 #include "prefs.h"
41 #include "sound.h"
42 #include "util.h"
43
44 #include "gtkconv.h"
45 #include "gtksound.h"
46
47 struct gaim_sound_event {
48 char *label;
49 char *pref;
50 char *def;
51 };
52
53 #define PLAY_SOUND_TIMEOUT 15000
54
55 static guint mute_login_sounds_timeout = 0;
56 static gboolean mute_login_sounds = FALSE;
57
58 static struct gaim_sound_event sounds[GAIM_NUM_SOUNDS] = {
59 {N_("Buddy logs in"), "login", "login.wav"},
60 {N_("Buddy logs out"), "logout", "logout.wav"},
61 {N_("Message received"), "im_recv", "receive.wav"},
62 {N_("Message received begins conversation"), "first_im_recv", "receive.wav"},
63 {N_("Message sent"), "send_im", "send.wav"},
64 {N_("Person enters chat"), "join_chat", "login.wav"},
65 {N_("Person leaves chat"), "left_chat", "logout.wav"},
66 {N_("You talk in chat"), "send_chat_msg", "send.wav"},
67 {N_("Others talk in chat"), "chat_msg_recv", "receive.wav"},
68 /* this isn't a terminator, it's the buddy pounce default sound event ;-) */
69 {NULL, "pounce_default", "alert.wav"},
70 {N_("Someone says your screen name in chat"), "nick_said", "alert.wav"}
71 };
72
73 static gboolean
74 unmute_login_sounds_cb(gpointer data)
75 {
76 mute_login_sounds = FALSE;
77 mute_login_sounds_timeout = 0;
78 return FALSE;
79 }
80
81 static gboolean
82 chat_nick_matches_name(GaimConversation *conv, const char *aname)
83 {
84 GaimConvChat *chat = NULL;
85 char *nick = NULL;
86 char *name = NULL;
87 gboolean ret = FALSE;
88 chat = gaim_conversation_get_chat_data(conv);
89
90 if (chat==NULL)
91 return ret;
92
93 nick = g_strdup(gaim_normalize(conv->account, chat->nick));
94 name = g_strdup(gaim_normalize(conv->account, aname));
95
96 if (g_utf8_collate(nick, name) == 0)
97 ret = TRUE;
98
99 g_free(nick);
100 g_free(name);
101
102 return ret;
103 }
104
105 /*
106 * play a sound event for a conversation, honoring make_sound flag
107 * of conversation and checking for focus if conv_focus pref is set
108 */
109 static void
110 play_conv_event(GaimConversation *conv, GaimSoundEventID event)
111 {
112 /* If we should not play the sound for some reason, then exit early */
113 if (conv != NULL)
114 {
115 GaimGtkConversation *gtkconv;
116 GaimGtkWindow *win;
117 gboolean has_focus;
118
119 gtkconv = GAIM_GTK_CONVERSATION(conv);
120 win = gtkconv->win;
121
122 has_focus = gaim_conversation_has_focus(conv);
123
124 if (!gtkconv->make_sound ||
125 (has_focus && !gaim_prefs_get_bool("/gaim/gtk/sound/conv_focus")))
126 {
127 return;
128 }
129 }
130
131 gaim_sound_play_event(event, conv ? gaim_conversation_get_account(conv) : NULL);
132 }
133
134 static void
135 buddy_state_cb(GaimBuddy *buddy, GaimSoundEventID event)
136 {
137 gaim_sound_play_event(event, gaim_buddy_get_account(buddy));
138 }
139
140 static void
141 im_msg_received_cb(GaimAccount *account, char *sender,
142 char *message, GaimConversation *conv,
143 int flags, GaimSoundEventID event)
144 {
145 if (flags & GAIM_MESSAGE_DELAYED)
146 return;
147
148 if (conv==NULL)
149 gaim_sound_play_event(GAIM_SOUND_FIRST_RECEIVE, account);
150 else
151 play_conv_event(conv, event);
152 }
153
154 static void
155 im_msg_sent_cb(GaimAccount *account, const char *receiver,
156 const char *message, GaimSoundEventID event)
157 {
158 GaimConversation *conv = gaim_find_conversation_with_account(
159 GAIM_CONV_TYPE_ANY, receiver, account);
160 play_conv_event(conv, event);
161 }
162
163 static void
164 chat_buddy_join_cb(GaimConversation *conv, const char *name,
165 GaimConvChatBuddyFlags flags, gboolean new_arrival,
166 GaimSoundEventID event)
167 {
168 if (new_arrival && !chat_nick_matches_name(conv, name))
169 play_conv_event(conv, event);
170 }
171
172 static void
173 chat_buddy_left_cb(GaimConversation *conv, const char *name,
174 const char *reason, GaimSoundEventID event)
175 {
176 if (!chat_nick_matches_name(conv, name))
177 play_conv_event(conv, event);
178 }
179
180 static void
181 chat_msg_sent_cb(GaimAccount *account, const char *message,
182 int id, GaimSoundEventID event)
183 {
184 GaimConnection *conn = gaim_account_get_connection(account);
185 GaimConversation *conv = NULL;
186
187 if (conn!=NULL)
188 conv = gaim_find_chat(conn,id);
189
190 play_conv_event(conv, event);
191 }
192
193 static void
194 chat_msg_received_cb(GaimAccount *account, char *sender,
195 char *message, GaimConversation *conv,
196 GaimMessageFlags flags, GaimSoundEventID event)
197 {
198 GaimConvChat *chat;
199
200 if (flags & GAIM_MESSAGE_DELAYED)
201 return;
202
203 chat = gaim_conversation_get_chat_data(conv);
204 g_return_if_fail(chat != NULL);
205
206 if (gaim_conv_chat_is_user_ignored(chat, sender))
207 return;
208
209 if (chat_nick_matches_name(conv, sender))
210 return;
211
212 if (flags & GAIM_MESSAGE_NICK || gaim_utf8_has_word(message, chat->nick))
213 play_conv_event(conv, GAIM_SOUND_CHAT_NICK);
214 else
215 play_conv_event(conv, event);
216 }
217
218 /*
219 * We mute sounds for the 10 seconds after you log in so that
220 * you don't get flooded with sounds when the blist shows all
221 * your buddies logging in.
222 */
223 static void
224 account_signon_cb(GaimConnection *gc, gpointer data)
225 {
226 if (mute_login_sounds_timeout != 0)
227 g_source_remove(mute_login_sounds_timeout);
228 mute_login_sounds = TRUE;
229 mute_login_sounds_timeout = gaim_timeout_add(10000, unmute_login_sounds_cb, NULL);
230 }
231
232 const char *
233 gaim_gtk_sound_get_event_option(GaimSoundEventID event)
234 {
235 if(event >= GAIM_NUM_SOUNDS)
236 return 0;
237
238 return sounds[event].pref;
239 }
240
241 char *
242 gaim_gtk_sound_get_event_label(GaimSoundEventID event)
243 {
244 if(event >= GAIM_NUM_SOUNDS)
245 return NULL;
246
247 return sounds[event].label;
248 }
249
250 void *
251 gaim_gtk_sound_get_handle()
252 {
253 static int handle;
254
255 return &handle;
256 }
257
258 static void
259 gaim_gtk_sound_init(void)
260 {
261 void *gtk_sound_handle = gaim_gtk_sound_get_handle();
262 void *blist_handle = gaim_blist_get_handle();
263 void *conv_handle = gaim_conversations_get_handle();
264
265 gaim_signal_connect(gaim_connections_get_handle(), "signed-on",
266 gtk_sound_handle, GAIM_CALLBACK(account_signon_cb),
267 NULL);
268
269 gaim_prefs_add_none("/gaim/gtk/sound");
270 gaim_prefs_add_none("/gaim/gtk/sound/enabled");
271 gaim_prefs_add_none("/gaim/gtk/sound/file");
272 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/login", TRUE);
273 gaim_prefs_add_string("/gaim/gtk/sound/file/login", "");
274 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/logout", TRUE);
275 gaim_prefs_add_string("/gaim/gtk/sound/file/logout", "");
276 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/im_recv", TRUE);
277 gaim_prefs_add_string("/gaim/gtk/sound/file/im_recv", "");
278 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/first_im_recv", FALSE);
279 gaim_prefs_add_string("/gaim/gtk/sound/file/first_im_recv", "");
280 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/send_im", TRUE);
281 gaim_prefs_add_string("/gaim/gtk/sound/file/send_im", "");
282 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/join_chat", FALSE);
283 gaim_prefs_add_string("/gaim/gtk/sound/file/join_chat", "");
284 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/left_chat", FALSE);
285 gaim_prefs_add_string("/gaim/gtk/sound/file/left_chat", "");
286 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/send_chat_msg", FALSE);
287 gaim_prefs_add_string("/gaim/gtk/sound/file/send_chat_msg", "");
288 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/chat_msg_recv", FALSE);
289 gaim_prefs_add_string("/gaim/gtk/sound/file/chat_msg_recv", "");
290 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/nick_said", FALSE);
291 gaim_prefs_add_string("/gaim/gtk/sound/file/nick_said", "");
292 gaim_prefs_add_bool("/gaim/gtk/sound/enabled/pounce_default", TRUE);
293 gaim_prefs_add_string("/gaim/gtk/sound/file/pounce_default", "");
294 gaim_prefs_add_bool("/gaim/gtk/sound/conv_focus", TRUE);
295 gaim_prefs_add_bool("/gaim/gtk/sound/mute", FALSE);
296 gaim_prefs_add_string("/gaim/gtk/sound/command", "");
297 gaim_prefs_add_string("/gaim/gtk/sound/method", "automatic");
298 gaim_prefs_add_int("/gaim/gtk/sound/volume", 50);
299
300 #ifdef USE_GSTREAMER
301 gaim_debug_info("sound", "Initializing sound output drivers.\n");
302 gst_init(NULL, NULL);
303 #endif /* USE_GSTREAMER */
304
305 gaim_signal_connect(blist_handle, "buddy-signed-on",
306 gtk_sound_handle, GAIM_CALLBACK(buddy_state_cb),
307 GINT_TO_POINTER(GAIM_SOUND_BUDDY_ARRIVE));
308 gaim_signal_connect(blist_handle, "buddy-signed-off",
309 gtk_sound_handle, GAIM_CALLBACK(buddy_state_cb),
310 GINT_TO_POINTER(GAIM_SOUND_BUDDY_LEAVE));
311 gaim_signal_connect(conv_handle, "received-im-msg",
312 gtk_sound_handle, GAIM_CALLBACK(im_msg_received_cb),
313 GINT_TO_POINTER(GAIM_SOUND_RECEIVE));
314 gaim_signal_connect(conv_handle, "sent-im-msg",
315 gtk_sound_handle, GAIM_CALLBACK(im_msg_sent_cb),
316 GINT_TO_POINTER(GAIM_SOUND_SEND));
317 gaim_signal_connect(conv_handle, "chat-buddy-joined",
318 gtk_sound_handle, GAIM_CALLBACK(chat_buddy_join_cb),
319 GINT_TO_POINTER(GAIM_SOUND_CHAT_JOIN));
320 gaim_signal_connect(conv_handle, "chat-buddy-left",
321 gtk_sound_handle, GAIM_CALLBACK(chat_buddy_left_cb),
322 GINT_TO_POINTER(GAIM_SOUND_CHAT_LEAVE));
323 gaim_signal_connect(conv_handle, "sent-chat-msg",
324 gtk_sound_handle, GAIM_CALLBACK(chat_msg_sent_cb),
325 GINT_TO_POINTER(GAIM_SOUND_CHAT_YOU_SAY));
326 gaim_signal_connect(conv_handle, "received-chat-msg",
327 gtk_sound_handle, GAIM_CALLBACK(chat_msg_received_cb),
328 GINT_TO_POINTER(GAIM_SOUND_CHAT_SAY));
329 }
330
331 static void
332 gaim_gtk_sound_uninit(void)
333 {
334 #ifdef USE_GSTREAMER
335 gst_deinit();
336 #endif
337
338 gaim_signals_disconnect_by_handle(gaim_gtk_sound_get_handle());
339 }
340
341 #ifdef USE_GSTREAMER
342 static gboolean
343 bus_call (GstBus *bus,
344 GstMessage *msg,
345 gpointer data)
346 {
347 GstElement *play = data;
348 GError *err;
349
350 switch (GST_MESSAGE_TYPE (msg)) {
351 case GST_MESSAGE_EOS:
352 gst_element_set_state(play, GST_STATE_NULL);
353 gst_object_unref(GST_OBJECT(play));
354 break;
355 case GST_MESSAGE_ERROR:
356 gst_message_parse_error(msg, &err, NULL);
357 gaim_debug_error("gstreamer", err->message);
358 g_error_free(err);
359 break;
360 case GST_MESSAGE_WARNING:
361 gst_message_parse_warning(msg, &err, NULL);
362 gaim_debug_warning("gstreamer", err->message);
363 g_error_free(err);
364 break;
365 default:
366 break;
367 }
368 return TRUE;
369 }
370 #endif
371
372 static void
373 gaim_gtk_sound_play_file(const char *filename)
374 {
375 const char *method;
376 #ifdef USE_GSTREAMER
377 float volume;
378 char *uri;
379 GstElement *sink = NULL;
380 GstElement *play = NULL;
381 #endif
382
383 if (gaim_prefs_get_bool("/gaim/gtk/sound/mute"))
384 return;
385
386 method = gaim_prefs_get_string("/gaim/gtk/sound/method");
387
388 if (!strcmp(method, "none")) {
389 return;
390 } else if (!strcmp(method, "beep")) {
391 gdk_beep();
392 return;
393 }
394
395 if (!g_file_test(filename, G_FILE_TEST_EXISTS)) {
396 gaim_debug_error("gtksound", "sound file (%s) does not exist.\n", filename);
397 return;
398 }
399
400 #ifndef _WIN32
401 if (!strcmp(method, "custom")) {
402 const char *sound_cmd;
403 char *command;
404 GError *error = NULL;
405
406 sound_cmd = gaim_prefs_get_string("/gaim/gtk/sound/command");
407
408 if (!sound_cmd || *sound_cmd == '\0') {
409 gaim_debug_error("gtksound",
410 "'Command' sound method has been chosen, "
411 "but no command has been set.");
412 return;
413 }
414
415 if(strstr(sound_cmd, "%s"))
416 command = gaim_strreplace(sound_cmd, "%s", filename);
417 else
418 command = g_strdup_printf("%s %s", sound_cmd, filename);
419
420 if(!g_spawn_command_line_async(command, &error)) {
421 char *tmp = g_strdup_printf("sound command could not be launched: %s\n", error->message);
422 gaim_debug_error("gtksound", tmp);
423 g_free(tmp);
424 g_error_free(error);
425 }
426
427 g_free(command);
428 return;
429 }
430 #ifdef USE_GSTREAMER
431 volume = (float)(CLAMP(gaim_prefs_get_int("/gaim/gtk/sound/volume"),0,100)) / 50;
432 if (!strcmp(method, "automatic")) {
433 if (gaim_running_gnome()) {
434 sink = gst_element_factory_make("gconfaudiosink", "sink");
435 }
436 } else if (!strcmp(method, "esd")) {
437 sink = gst_element_factory_make("esdsink", "sink");
438 } else if (!strcmp(method, "arts")) {
439 sink = gst_element_factory_make("artssink", "sink");
440 } else if (!strcmp(method, "nas")) {
441 sink = gst_element_factory_make("nassink", "sink");
442 }
443
444 uri = g_strdup_printf("file://%s", filename);
445 play = gst_element_factory_make("playbin", "play");
446
447 g_object_set(G_OBJECT(play), "uri", uri,
448 "volume", volume,
449 "audio-sink", sink, NULL);
450
451 gst_bus_add_watch(gst_pipeline_get_bus(GST_PIPELINE(play)),
452 bus_call, play);
453 gst_element_set_state(play, GST_STATE_PLAYING);
454
455 g_free(uri);
456
457 #else /* USE_GSTREAMER */
458 gdk_beep();
459 return;
460 #endif /* USE_GSTREAMER */
461 #else /* _WIN32 */
462 gaim_debug_info("sound", "Playing %s\n", filename);
463
464 if (G_WIN32_HAVE_WIDECHAR_API ()) {
465 wchar_t *wc_filename = g_utf8_to_utf16(filename,
466 -1, NULL, NULL, NULL);
467 if (!PlaySoundW(wc_filename, NULL, SND_ASYNC | SND_FILENAME))
468 gaim_debug(GAIM_DEBUG_ERROR, "sound", "Error playing sound.\n");
469 g_free(wc_filename);
470 } else {
471 char *l_filename = g_locale_from_utf8(filename,
472 -1, NULL, NULL, NULL);
473 if (!PlaySoundA(l_filename, NULL, SND_ASYNC | SND_FILENAME))
474 gaim_debug(GAIM_DEBUG_ERROR, "sound", "Error playing sound.\n");
475 g_free(l_filename);
476 }
477 #endif /* _WIN32 */
478 }
479
480 static void
481 gaim_gtk_sound_play_event(GaimSoundEventID event)
482 {
483 char *enable_pref;
484 char *file_pref;
485
486 if ((event == GAIM_SOUND_BUDDY_ARRIVE) && mute_login_sounds)
487 return;
488
489 if (event >= GAIM_NUM_SOUNDS) {
490 gaim_debug_error("sound", "got request for unknown sound: %d\n", event);
491 return;
492 }
493
494 enable_pref = g_strdup_printf("/gaim/gtk/sound/enabled/%s",
495 sounds[event].pref);
496 file_pref = g_strdup_printf("/gaim/gtk/sound/file/%s", sounds[event].pref);
497
498 /* check NULL for sounds that don't have an option, ie buddy pounce */
499 if (gaim_prefs_get_bool(enable_pref)) {
500 char *filename = g_strdup(gaim_prefs_get_string(file_pref));
501 if(!filename || !strlen(filename)) {
502 g_free(filename);
503 filename = g_build_filename(DATADIR, "sounds", "gaim", sounds[event].def, NULL);
504 }
505
506 gaim_sound_play_file(filename, NULL);
507 g_free(filename);
508 }
509
510 g_free(enable_pref);
511 g_free(file_pref);
512 }
513
514 static GaimSoundUiOps sound_ui_ops =
515 {
516 gaim_gtk_sound_init,
517 gaim_gtk_sound_uninit,
518 gaim_gtk_sound_play_file,
519 gaim_gtk_sound_play_event
520 };
521
522 GaimSoundUiOps *
523 gaim_gtk_sound_get_ui_ops(void)
524 {
525 return &sound_ui_ops;
526 }

Mercurial Repository: pidgin3

mercurial