Mercurial > pidgin

comparison finch/gntsound.c @ 19186:eef82b050c21

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merge of 'bbeac90ad01d5059327da9e2504716614a191cab' and 'f30bfc6fc7aee19d096dd838aad5a784a7371d6c'
author Kevin Stange <kevin@simguy.net>
date Sat, 11 Aug 2007 21:08:27 +0000
parents cdb0fbe5de7b
children ed80bace0934
comparison
equal deleted inserted replaced
18842:e20619418edf 19186:eef82b050c21
21 * You should have received a copy of the GNU General Public License 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 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 23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */ 24 */
25 #include "internal.h" 25 #include "internal.h"
26 #include "finch.h"
27
28 #ifdef _WIN32
29 #include <windows.h>
30 #include <mmsystem.h>
31 #endif
32
33 #ifdef USE_GSTREAMER
34 #include <gst/gst.h>
35 #endif /* USE_GSTREAMER */
36
37 #include "debug.h"
38 #include "notify.h"
39 #include "prefs.h"
40 #include "sound.h"
41 #include "util.h"
42
43 #include "gntbox.h"
44 #include "gntwindow.h"
45 #include "gntcombobox.h"
46 #include "gntlabel.h"
47 #include "gntconv.h"
26 #include "gntsound.h" 48 #include "gntsound.h"
27 49 #include "gntwidget.h"
28 const char *finch_sound_get_active_profile(void) 50 #include "gntentry.h"
29 { 51 #include "gntcheckbox.h"
30 return NULL; 52 #include "gntline.h"
31 } 53 #include "gntslider.h"
32 54 #include "gnttree.h"
33 void finch_sound_set_active_profile(const char *name) 55 #include "gntfilesel.h"
34 { 56
35 } 57 typedef struct {
36 58 PurpleSoundEventID id;
37 GList *finch_sound_get_profiles(void) 59 char *label;
38 { 60 char *pref;
39 return NULL; 61 char *def;
40 } 62 char *file;
41 63 } FinchSoundEvent;
42 PurpleSoundUiOps *finch_sound_get_ui_ops(void) 64
43 { 65 typedef struct {
44 return NULL; 66 GntWidget *method;
45 } 67 GntWidget *command;
46 68 GntWidget *conv_focus;
47 void finch_sounds_show_all(void) 69 GntWidget *while_status;
48 { 70 GntWidget *volume;
49 } 71 GntWidget *events;
50 72 GntWidget *window;
73 GntWidget *selector;
74
75 GntWidget *profiles;
76 GntWidget *new_profile;
77 gchar * original_profile;
78 } SoundPrefDialog;
79
80 #define DEFAULT_PROFILE "default"
81
82 static SoundPrefDialog *pref_dialog;
83
84 #define PLAY_SOUND_TIMEOUT 15000
85
86 static guint mute_login_sounds_timeout = 0;
87 static gboolean mute_login_sounds = FALSE;
88
89 #ifdef USE_GSTREAMER
90 static gboolean gst_init_failed;
91 #endif /* USE_GSTREAMER */
92
93 static FinchSoundEvent sounds[PURPLE_NUM_SOUNDS] = {
94 {PURPLE_SOUND_BUDDY_ARRIVE, N_("Buddy logs in"), "login", "login.wav", NULL},
95 {PURPLE_SOUND_BUDDY_LEAVE, N_("Buddy logs out"), "logout", "logout.wav", NULL},
96 {PURPLE_SOUND_RECEIVE, N_("Message received"), "im_recv", "receive.wav", NULL},
97 {PURPLE_SOUND_FIRST_RECEIVE, N_("Message received begins conversation"), "first_im_recv", "receive.wav", NULL},
98 {PURPLE_SOUND_SEND, N_("Message sent"), "send_im", "send.wav", NULL},
99 {PURPLE_SOUND_CHAT_JOIN, N_("Person enters chat"), "join_chat", "login.wav", NULL},
100 {PURPLE_SOUND_CHAT_LEAVE, N_("Person leaves chat"), "left_chat", "logout.wav", NULL},
101 {PURPLE_SOUND_CHAT_YOU_SAY, N_("You talk in chat"), "send_chat_msg", "send.wav", NULL},
102 {PURPLE_SOUND_CHAT_SAY, N_("Others talk in chat"), "chat_msg_recv", "receive.wav", NULL},
103 {PURPLE_SOUND_POUNCE_DEFAULT, NULL, "pounce_default", "alert.wav", NULL},
104 {PURPLE_SOUND_CHAT_NICK, N_("Someone says your screen name in chat"), "nick_said", "alert.wav", NULL}
105 };
106
107 const char *
108 finch_sound_get_active_profile()
109 {
110 return purple_prefs_get_string(FINCH_PREFS_ROOT "/sound/actprofile");
111 }
112
113 /* This method creates a pref name based on the current active profile.
114 * So if "Home" is the current active profile the pref name
115 * [FINCH_PREFS_ROOT "/sound/profiles/Home/$NAME"] is created.
116 */
117 static gchar *
118 make_pref(const char *name)
119 {
120 static char pref_string[512];
121 g_snprintf(pref_string, sizeof(pref_string),
122 FINCH_PREFS_ROOT "/sound/profiles/%s%s", finch_sound_get_active_profile(), name);
123 return pref_string;
124 }
125
126
127 static gboolean
128 unmute_login_sounds_cb(gpointer data)
129 {
130 mute_login_sounds = FALSE;
131 mute_login_sounds_timeout = 0;
132 return FALSE;
133 }
134
135 static gboolean
136 chat_nick_matches_name(PurpleConversation *conv, const char *aname)
137 {
138 PurpleConvChat *chat = NULL;
139 char *nick = NULL;
140 char *name = NULL;
141 gboolean ret = FALSE;
142 chat = purple_conversation_get_chat_data(conv);
143
144 if (chat == NULL)
145 return ret;
146
147 nick = g_strdup(purple_normalize(conv->account, chat->nick));
148 name = g_strdup(purple_normalize(conv->account, aname));
149
150 if (g_utf8_collate(nick, name) == 0)
151 ret = TRUE;
152
153 g_free(nick);
154 g_free(name);
155
156 return ret;
157 }
158
159 /*
160 * play a sound event for a conversation, honoring make_sound flag
161 * of conversation and checking for focus if conv_focus pref is set
162 */
163 static void
164 play_conv_event(PurpleConversation *conv, PurpleSoundEventID event)
165 {
166 /* If we should not play the sound for some reason, then exit early */
167 if (conv != NULL)
168 {
169 FinchConv *gntconv;
170 gboolean has_focus;
171
172 gntconv = FINCH_CONV(conv);
173
174 has_focus = purple_conversation_has_focus(conv);
175
176 if (has_focus && !purple_prefs_get_bool(make_pref("/conv_focus")))
177 {
178 return;
179 }
180 }
181
182 purple_sound_play_event(event, conv ? purple_conversation_get_account(conv) : NULL);
183 }
184
185 static void
186 buddy_state_cb(PurpleBuddy *buddy, PurpleSoundEventID event)
187 {
188 purple_sound_play_event(event, purple_buddy_get_account(buddy));
189 }
190
191 static void
192 im_msg_received_cb(PurpleAccount *account, char *sender,
193 char *message, PurpleConversation *conv,
194 PurpleMessageFlags flags, PurpleSoundEventID event)
195 {
196 if (flags & PURPLE_MESSAGE_DELAYED)
197 return;
198
199 if (conv == NULL) {
200 purple_sound_play_event(PURPLE_SOUND_FIRST_RECEIVE, account);
201 } else {
202 play_conv_event(conv, event);
203 }
204 }
205
206 static void
207 im_msg_sent_cb(PurpleAccount *account, const char *receiver,
208 const char *message, PurpleSoundEventID event)
209 {
210 PurpleConversation *conv = purple_find_conversation_with_account(
211 PURPLE_CONV_TYPE_ANY, receiver, account);
212 play_conv_event(conv, event);
213 }
214
215 static void
216 chat_buddy_join_cb(PurpleConversation *conv, const char *name,
217 PurpleConvChatBuddyFlags flags, gboolean new_arrival,
218 PurpleSoundEventID event)
219 {
220 if (new_arrival && !chat_nick_matches_name(conv, name))
221 play_conv_event(conv, event);
222 }
223
224 static void
225 chat_buddy_left_cb(PurpleConversation *conv, const char *name,
226 const char *reason, PurpleSoundEventID event)
227 {
228 if (!chat_nick_matches_name(conv, name))
229 play_conv_event(conv, event);
230 }
231
232 static void
233 chat_msg_sent_cb(PurpleAccount *account, const char *message,
234 int id, PurpleSoundEventID event)
235 {
236 PurpleConnection *conn = purple_account_get_connection(account);
237 PurpleConversation *conv = NULL;
238
239 if (conn!=NULL)
240 conv = purple_find_chat(conn, id);
241
242 play_conv_event(conv, event);
243 }
244
245 static void
246 chat_msg_received_cb(PurpleAccount *account, char *sender,
247 char *message, PurpleConversation *conv,
248 PurpleMessageFlags flags, PurpleSoundEventID event)
249 {
250 PurpleConvChat *chat;
251
252 if (flags & PURPLE_MESSAGE_DELAYED)
253 return;
254
255 chat = purple_conversation_get_chat_data(conv);
256 g_return_if_fail(chat != NULL);
257
258 if (purple_conv_chat_is_user_ignored(chat, sender))
259 return;
260
261 if (chat_nick_matches_name(conv, sender))
262 return;
263
264 if (flags & PURPLE_MESSAGE_NICK || purple_utf8_has_word(message, chat->nick))
265 play_conv_event(conv, PURPLE_SOUND_CHAT_NICK);
266 else
267 play_conv_event(conv, event);
268 }
269
270 /*
271 * We mute sounds for the 10 seconds after you log in so that
272 * you don't get flooded with sounds when the blist shows all
273 * your buddies logging in.
274 */
275 static void
276 account_signon_cb(PurpleConnection *gc, gpointer data)
277 {
278 if (mute_login_sounds_timeout != 0)
279 g_source_remove(mute_login_sounds_timeout);
280 mute_login_sounds = TRUE;
281 mute_login_sounds_timeout = purple_timeout_add_seconds(10, unmute_login_sounds_cb, NULL);
282 }
283
284 static void *
285 finch_sound_get_handle()
286 {
287 static int handle;
288
289 return &handle;
290 }
291
292
293 /* This gets called when the active profile changes */
294 static void
295 initialize_profile(const char *name, PurplePrefType type, gconstpointer val, gpointer null)
296 {
297 if (purple_prefs_exists(make_pref("")))
298 return;
299
300 purple_prefs_add_none(make_pref(""));
301 purple_prefs_add_none(make_pref("/enabled"));
302 purple_prefs_add_none(make_pref("/file"));
303 purple_prefs_add_bool(make_pref("/enabled/login"), TRUE);
304 purple_prefs_add_path(make_pref("/file/login"), "");
305 purple_prefs_add_bool(make_pref("/enabled/logout"), TRUE);
306 purple_prefs_add_path(make_pref("/file/logout"), "");
307 purple_prefs_add_bool(make_pref("/enabled/im_recv"), TRUE);
308 purple_prefs_add_path(make_pref("/file/im_recv"), "");
309 purple_prefs_add_bool(make_pref("/enabled/first_im_recv"), FALSE);
310 purple_prefs_add_path(make_pref("/file/first_im_recv"), "");
311 purple_prefs_add_bool(make_pref("/enabled/send_im"), TRUE);
312 purple_prefs_add_path(make_pref("/file/send_im"), "");
313 purple_prefs_add_bool(make_pref("/enabled/join_chat"), FALSE);
314 purple_prefs_add_path(make_pref("/file/join_chat"), "");
315 purple_prefs_add_bool(make_pref("/enabled/left_chat"), FALSE);
316 purple_prefs_add_path(make_pref("/file/left_chat"), "");
317 purple_prefs_add_bool(make_pref("/enabled/send_chat_msg"), FALSE);
318 purple_prefs_add_path(make_pref("/file/send_chat_msg"), "");
319 purple_prefs_add_bool(make_pref("/enabled/chat_msg_recv"), FALSE);
320 purple_prefs_add_path(make_pref("/file/chat_msg_recv"), "");
321 purple_prefs_add_bool(make_pref("/enabled/nick_said"), FALSE);
322 purple_prefs_add_path(make_pref("/file/nick_said"), "");
323 purple_prefs_add_bool(make_pref("/enabled/pounce_default"), TRUE);
324 purple_prefs_add_path(make_pref("/file/pounce_default"), "");
325 purple_prefs_add_bool(make_pref("/conv_focus"), TRUE);
326 purple_prefs_add_bool(make_pref("/mute"), FALSE);
327 purple_prefs_add_path(make_pref("/command"), "");
328 purple_prefs_add_string(make_pref("/method"), "automatic");
329 purple_prefs_add_int(make_pref("/volume"), 50);
330 }
331
332 static void
333 finch_sound_init(void)
334 {
335 void *gnt_sound_handle = finch_sound_get_handle();
336 void *blist_handle = purple_blist_get_handle();
337 void *conv_handle = purple_conversations_get_handle();
338 #ifdef USE_GSTREAMER
339 GError *error = NULL;
340 #endif
341
342 purple_signal_connect(purple_connections_get_handle(), "signed-on",
343 gnt_sound_handle, PURPLE_CALLBACK(account_signon_cb),
344 NULL);
345
346 purple_prefs_add_none(FINCH_PREFS_ROOT "/sound");
347 purple_prefs_add_string(FINCH_PREFS_ROOT "/sound/actprofile", DEFAULT_PROFILE);
348 purple_prefs_add_none(FINCH_PREFS_ROOT "/sound/profiles");
349
350 purple_prefs_connect_callback(gnt_sound_handle, FINCH_PREFS_ROOT "/sound/actprofile", initialize_profile, NULL);
351 purple_prefs_trigger_callback(FINCH_PREFS_ROOT "/sound/actprofile");
352
353
354 #ifdef USE_GSTREAMER
355 purple_debug_info("sound", "Initializing sound output drivers.\n");
356 if ((gst_init_failed = !gst_init_check(NULL, NULL, &error))) {
357 purple_notify_error(NULL, _("GStreamer Failure"),
358 _("GStreamer failed to initialize."),
359 error ? error->message : "");
360 if (error) {
361 g_error_free(error);
362 error = NULL;
363 }
364 }
365 #endif /* USE_GSTREAMER */
366
367 purple_signal_connect(blist_handle, "buddy-signed-on",
368 gnt_sound_handle, PURPLE_CALLBACK(buddy_state_cb),
369 GINT_TO_POINTER(PURPLE_SOUND_BUDDY_ARRIVE));
370 purple_signal_connect(blist_handle, "buddy-signed-off",
371 gnt_sound_handle, PURPLE_CALLBACK(buddy_state_cb),
372 GINT_TO_POINTER(PURPLE_SOUND_BUDDY_LEAVE));
373 purple_signal_connect(conv_handle, "received-im-msg",
374 gnt_sound_handle, PURPLE_CALLBACK(im_msg_received_cb),
375 GINT_TO_POINTER(PURPLE_SOUND_RECEIVE));
376 purple_signal_connect(conv_handle, "sent-im-msg",
377 gnt_sound_handle, PURPLE_CALLBACK(im_msg_sent_cb),
378 GINT_TO_POINTER(PURPLE_SOUND_SEND));
379 purple_signal_connect(conv_handle, "chat-buddy-joined",
380 gnt_sound_handle, PURPLE_CALLBACK(chat_buddy_join_cb),
381 GINT_TO_POINTER(PURPLE_SOUND_CHAT_JOIN));
382 purple_signal_connect(conv_handle, "chat-buddy-left",
383 gnt_sound_handle, PURPLE_CALLBACK(chat_buddy_left_cb),
384 GINT_TO_POINTER(PURPLE_SOUND_CHAT_LEAVE));
385 purple_signal_connect(conv_handle, "sent-chat-msg",
386 gnt_sound_handle, PURPLE_CALLBACK(chat_msg_sent_cb),
387 GINT_TO_POINTER(PURPLE_SOUND_CHAT_YOU_SAY));
388 purple_signal_connect(conv_handle, "received-chat-msg",
389 gnt_sound_handle, PURPLE_CALLBACK(chat_msg_received_cb),
390 GINT_TO_POINTER(PURPLE_SOUND_CHAT_SAY));
391 }
392
393 static void
394 finch_sound_uninit(void)
395 {
396 #ifdef USE_GSTREAMER
397 if (!gst_init_failed)
398 gst_deinit();
399 #endif
400
401 purple_signals_disconnect_by_handle(finch_sound_get_handle());
402 }
403
404 #ifdef USE_GSTREAMER
405 static gboolean
406 bus_call (GstBus *bus, GstMessage *msg, gpointer data)
407 {
408 GstElement *play = data;
409 GError *err = NULL;
410
411 switch (GST_MESSAGE_TYPE (msg)) {
412 case GST_MESSAGE_EOS:
413 gst_element_set_state(play, GST_STATE_NULL);
414 gst_object_unref(GST_OBJECT(play));
415 break;
416 case GST_MESSAGE_ERROR:
417 gst_message_parse_error(msg, &err, NULL);
418 purple_debug_error("gstreamer", "%s\n", err->message);
419 g_error_free(err);
420 break;
421 case GST_MESSAGE_WARNING:
422 gst_message_parse_warning(msg, &err, NULL);
423 purple_debug_warning("gstreamer", "%s\n", err->message);
424 g_error_free(err);
425 break;
426 default:
427 break;
428 }
429 return TRUE;
430 }
431 #endif
432
433 static void
434 finch_sound_play_file(const char *filename)
435 {
436 const char *method;
437 #ifdef USE_GSTREAMER
438 float volume;
439 char *uri;
440 GstElement *sink = NULL;
441 GstElement *play = NULL;
442 GstBus *bus = NULL;
443 #endif
444 if (purple_prefs_get_bool(make_pref("/mute")))
445 return;
446
447 method = purple_prefs_get_string(make_pref("/method"));
448
449 if (!strcmp(method, "none")) {
450 return;
451 } else if (!strcmp(method, "beep")) {
452 beep();
453 return;
454 }
455
456 if (!g_file_test(filename, G_FILE_TEST_EXISTS)) {
457 purple_debug_error("gntsound", "sound file (%s) does not exist.\n", filename);
458 return;
459 }
460
461 #ifndef _WIN32
462 if (!strcmp(method, "custom")) {
463 const char *sound_cmd;
464 char *command;
465 char *esc_filename;
466 GError *error = NULL;
467
468 sound_cmd = purple_prefs_get_path(make_pref("/command"));
469
470 if (!sound_cmd || *sound_cmd == '\0') {
471 purple_debug_error("gntsound",
472 "'Command' sound method has been chosen, "
473 "but no command has been set.");
474 return;
475 }
476
477 esc_filename = g_shell_quote(filename);
478
479 if (strstr(sound_cmd, "%s"))
480 command = purple_strreplace(sound_cmd, "%s", esc_filename);
481 else
482 command = g_strdup_printf("%s %s", sound_cmd, esc_filename);
483
484 if (!g_spawn_command_line_async(command, &error)) {
485 purple_debug_error("gntsound", "sound command could not be launched: %s\n", error->message);
486 g_error_free(error);
487 }
488
489 g_free(esc_filename);
490 g_free(command);
491 return;
492 }
493 #ifdef USE_GSTREAMER
494 if (gst_init_failed) /* Perhaps do beep instead? */
495 return;
496 volume = (float)(CLAMP(purple_prefs_get_int(make_pref("/volume")), 0, 100)) / 50;
497 if (!strcmp(method, "automatic")) {
498 if (purple_running_gnome()) {
499 sink = gst_element_factory_make("gconfaudiosink", "sink");
500 }
501 if (!sink)
502 sink = gst_element_factory_make("autoaudiosink", "sink");
503 if (!sink) {
504 purple_debug_error("sound", "Unable to create GStreamer audiosink.\n");
505 return;
506 }
507 } else if (!strcmp(method, "esd")) {
508 sink = gst_element_factory_make("esdsink", "sink");
509 if (!sink) {
510 purple_debug_error("sound", "Unable to create GStreamer audiosink.\n");
511 return;
512 }
513 } else if (!strcmp(method, "alsa")) {
514 sink = gst_element_factory_make("alsasink", "sink");
515 if (!sink) {
516 purple_debug_error("sound", "Unable to create GStreamer audiosink.\n");
517 return;
518 }
519 } else {
520 purple_debug_error("sound", "Unknown sound method '%s'\n", method);
521 return;
522 }
523
524 play = gst_element_factory_make("playbin", "play");
525
526 if (play == NULL) {
527 return;
528 }
529
530 uri = g_strdup_printf("file://%s", filename);
531
532 g_object_set(G_OBJECT(play), "uri", uri,
533 "volume", volume,
534 "audio-sink", sink, NULL);
535
536 bus = gst_pipeline_get_bus(GST_PIPELINE(play));
537 gst_bus_add_watch(bus, bus_call, play);
538
539 gst_element_set_state(play, GST_STATE_PLAYING);
540
541 gst_object_unref(bus);
542 g_free(uri);
543
544 #else /* USE_GSTREAMER */
545 beep();
546 return;
547 #endif /* USE_GSTREAMER */
548 #else /* _WIN32 */
549 purple_debug_info("sound", "Playing %s\n", filename);
550
551 if (G_WIN32_HAVE_WIDECHAR_API ()) {
552 wchar_t *wc_filename = g_utf8_to_utf16(filename,
553 -1, NULL, NULL, NULL);
554 if (!PlaySoundW(wc_filename, NULL, SND_ASYNC | SND_FILENAME))
555 purple_debug(PURPLE_DEBUG_ERROR, "sound", "Error playing sound.\n");
556 g_free(wc_filename);
557 } else {
558 char *l_filename = g_locale_from_utf8(filename,
559 -1, NULL, NULL, NULL);
560 if (!PlaySoundA(l_filename, NULL, SND_ASYNC | SND_FILENAME))
561 purple_debug(PURPLE_DEBUG_ERROR, "sound", "Error playing sound.\n");
562 g_free(l_filename);
563 }
564 #endif /* _WIN32 */
565 }
566
567 static void
568 finch_sound_play_event(PurpleSoundEventID event)
569 {
570 char *enable_pref;
571 char *file_pref;
572 if ((event == PURPLE_SOUND_BUDDY_ARRIVE) && mute_login_sounds)
573 return;
574
575 if (event >= PURPLE_NUM_SOUNDS) {
576 purple_debug_error("sound", "got request for unknown sound: %d\n", event);
577 return;
578 }
579
580 enable_pref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s",
581 finch_sound_get_active_profile(),
582 sounds[event].pref);
583 file_pref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s", finch_sound_get_active_profile(), sounds[event].pref);
584
585 /* check NULL for sounds that don't have an option, ie buddy pounce */
586 if (purple_prefs_get_bool(enable_pref)) {
587 char *filename = g_strdup(purple_prefs_get_path(file_pref));
588 if (!filename || !strlen(filename)) {
589 g_free(filename);
590 /* XXX Consider creating a constant for "sounds/purple" to be shared with Pidgin */
591 filename = g_build_filename(DATADIR, "sounds", "purple", sounds[event].def, NULL);
592 }
593
594 purple_sound_play_file(filename, NULL);
595 g_free(filename);
596 }
597
598 g_free(enable_pref);
599 g_free(file_pref);
600 }
601
602 GList *
603 finch_sound_get_profiles()
604 {
605 GList *list = NULL, *iter;
606 iter = purple_prefs_get_children_names(FINCH_PREFS_ROOT "/sound/profiles");
607 while (iter) {
608 list = g_list_append(list, g_strdup(strrchr(iter->data, '/') + 1));
609 g_free(iter->data);
610 iter = g_list_delete_link(iter, iter);
611 }
612 return list;
613 }
614
615 /* This will also create it if it doesn't exist */
616 void
617 finch_sound_set_active_profile(const char *name)
618 {
619 purple_prefs_set_string(FINCH_PREFS_ROOT "/sound/actprofile", name);
620 }
621
622 static gboolean
623 finch_sound_profile_exists(const char *name)
624 {
625 gchar * tmp;
626 gboolean ret = purple_prefs_exists(tmp = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s", name));
627 g_free(tmp);
628 return ret;
629 }
630
631 static void
632 save_cb(GntWidget *button, gpointer win)
633 {
634 GList * itr;
635
636 purple_prefs_set_string(make_pref("/method"), gnt_combo_box_get_selected_data(GNT_COMBO_BOX(pref_dialog->method)));
637 purple_prefs_set_path(make_pref("/command"), gnt_entry_get_text(GNT_ENTRY(pref_dialog->command)));
638 purple_prefs_set_bool(make_pref("/conv_focus"), gnt_check_box_get_checked(GNT_CHECK_BOX(pref_dialog->conv_focus)));
639 purple_prefs_set_int("/purple/sound/while_status", GPOINTER_TO_INT(gnt_combo_box_get_selected_data(GNT_COMBO_BOX(pref_dialog->while_status))));
640 purple_prefs_set_int(make_pref("/volume"), gnt_slider_get_value(GNT_SLIDER(pref_dialog->volume)));
641
642 for (itr = gnt_tree_get_rows(GNT_TREE(pref_dialog->events)); itr; itr = itr->next) {
643 FinchSoundEvent * event = &sounds[GPOINTER_TO_INT(itr->data)];
644 char * filepref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s", finch_sound_get_active_profile(), event->pref);
645 char * boolpref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s", finch_sound_get_active_profile(), event->pref);
646 purple_prefs_set_bool(boolpref, gnt_tree_get_choice(GNT_TREE(pref_dialog->events), itr->data));
647 purple_prefs_set_path(filepref, event->file ? event->file : "");
648 g_free(filepref);
649 g_free(boolpref);
650 }
651 gnt_widget_destroy(GNT_WIDGET(win));
652 }
653
654 static void
655 file_cb(GntFileSel *w, const char *path, const char *file, gpointer data)
656 {
657 FinchSoundEvent *event = data;
658
659 g_free(event->file);
660 event->file = g_strdup(path);
661
662 gnt_tree_change_text(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(event->id), 1, file);
663 gnt_tree_set_choice(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(event->id), TRUE);
664
665 gnt_widget_destroy(GNT_WIDGET(w));
666 }
667
668 static void
669 test_cb(GntWidget *button, gpointer null)
670 {
671 PurpleSoundEventID id = GPOINTER_TO_INT(gnt_tree_get_selection_data(GNT_TREE(pref_dialog->events)));
672 FinchSoundEvent * event = &sounds[id];
673 char *enabled, *file, *tmpfile;
674 gboolean temp_value;
675
676 enabled = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s",
677 finch_sound_get_active_profile(), event->pref);
678 file = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s",
679 finch_sound_get_active_profile(), event->pref);
680
681 temp_value = purple_prefs_get_bool(enabled);
682 tmpfile = g_strdup(purple_prefs_get_string(file));
683
684 purple_prefs_set_string(file, event->file);
685 if (!temp_value) purple_prefs_set_bool(enabled, TRUE);
686
687 purple_sound_play_event(id, NULL);
688
689 if (!temp_value) purple_prefs_set_bool(enabled, FALSE);
690 purple_prefs_set_string(file, tmpfile);
691
692 g_free(enabled);
693 g_free(file);
694 g_free(tmpfile);
695 }
696
697 static void
698 reset_cb(GntWidget *button, gpointer null)
699 {
700 /* Don't dereference this pointer ! */
701 gpointer key = gnt_tree_get_selection_data(GNT_TREE(pref_dialog->events));
702
703 FinchSoundEvent * event = &sounds[GPOINTER_TO_INT(key)];
704 g_free(event->file);
705 event->file = NULL;
706 gnt_tree_change_text(GNT_TREE(pref_dialog->events), key, 1, _("(default)"));
707 }
708
709
710 static void
711 choose_cb(GntWidget *button, gpointer null)
712 {
713 GntWidget *w = gnt_file_sel_new();
714 GntFileSel *sel = GNT_FILE_SEL(w);
715 PurpleSoundEventID id = GPOINTER_TO_INT(gnt_tree_get_selection_data(GNT_TREE(pref_dialog->events)));
716 FinchSoundEvent * event = &sounds[id];
717 char *path = NULL;
718
719 gnt_box_set_title(GNT_BOX(w), _("Select Sound File ..."));
720 gnt_file_sel_set_current_location(sel,
721 (event && event->file) ? (path = g_path_get_dirname(event->file))
722 : purple_home_dir());
723
724 g_signal_connect_swapped(G_OBJECT(sel->cancel), "activate", G_CALLBACK(gnt_widget_destroy), sel);
725 g_signal_connect(G_OBJECT(sel), "file_selected", G_CALLBACK(file_cb), event);
726 g_signal_connect_swapped(G_OBJECT(sel), "destroy", G_CALLBACK(g_nullify_pointer), &pref_dialog->selector);
727
728 /* If there's an already open file-selector, close that one. */
729 if (pref_dialog->selector)
730 gnt_widget_destroy(pref_dialog->selector);
731
732 pref_dialog->selector = w;
733
734 gnt_widget_show(w);
735 g_free(path);
736 }
737
738 static void
739 release_pref_dialog(GntBindable *data, gpointer null)
740 {
741 GList * itr;
742 for (itr = gnt_tree_get_rows(GNT_TREE(pref_dialog->events)); itr; itr = itr->next) {
743 PurpleSoundEventID id = GPOINTER_TO_INT(itr->data);
744 FinchSoundEvent * e = &sounds[id];
745 g_free(e->file);
746 e->file = NULL;
747 }
748 if (pref_dialog->selector)
749 gnt_widget_destroy(pref_dialog->selector);
750 g_free(pref_dialog);
751 pref_dialog = NULL;
752 }
753
754 static void
755 load_pref_window(const char * profile)
756 {
757 gint i;
758
759 finch_sound_set_active_profile(profile);
760
761 gnt_combo_box_set_selected(GNT_COMBO_BOX(pref_dialog->method), (gchar *)purple_prefs_get_string(make_pref("/method")));
762
763 gnt_entry_set_text(GNT_ENTRY(pref_dialog->command), purple_prefs_get_path(make_pref("/command")));
764
765 gnt_check_box_set_checked(GNT_CHECK_BOX(pref_dialog->conv_focus), purple_prefs_get_bool(make_pref("/conv_focus")));
766
767 gnt_combo_box_set_selected(GNT_COMBO_BOX(pref_dialog->while_status), GINT_TO_POINTER(purple_prefs_get_int("/purple" "/sound/while_status")));
768
769 gnt_slider_set_value(GNT_SLIDER(pref_dialog->volume), CLAMP(purple_prefs_get_int(make_pref("/volume")), 0, 100));
770
771 for (i = 0; i < PURPLE_NUM_SOUNDS; i++) {
772 FinchSoundEvent * event = &sounds[i];
773 gchar *boolpref;
774 gchar *filepref, *basename = NULL;
775 const char * profile = finch_sound_get_active_profile();
776
777 filepref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s", profile, event->pref);
778
779 g_free(event->file);
780 event->file = g_strdup(purple_prefs_get_path(filepref));
781
782 g_free(filepref);
783 if (event->label == NULL) {
784 continue;
785 }
786
787 boolpref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s", profile, event->pref);
788
789 gnt_tree_change_text(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(i), 0, event->label);
790 gnt_tree_change_text(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(i), 1,
791 event->file[0] ? (basename = g_path_get_basename(event->file)) : _("(default)"));
792 g_free(basename);
793
794 gnt_tree_set_choice(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(i), purple_prefs_get_bool(boolpref));
795
796 g_free(boolpref);
797 }
798
799 gnt_tree_set_selected(GNT_TREE(pref_dialog->profiles), (gchar *)finch_sound_get_active_profile());
800
801 gnt_widget_draw(pref_dialog->window);
802 }
803
804 static void
805 reload_pref_window(const char *profile)
806 {
807 if (!strcmp(profile, finch_sound_get_active_profile()))
808 return;
809 load_pref_window(profile);
810 }
811
812 static void
813 prof_del_cb(GntWidget *button, gpointer null)
814 {
815 const char * profile = gnt_entry_get_text(GNT_ENTRY(pref_dialog->new_profile));
816 gchar * pref;
817
818 if (!strcmp(profile, DEFAULT_PROFILE))
819 return;
820
821 pref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s", profile);
822 purple_prefs_remove(pref);
823 g_free(pref);
824
825 if (!strcmp(pref_dialog->original_profile, profile)) {
826 g_free(pref_dialog->original_profile);
827 pref_dialog->original_profile = g_strdup(DEFAULT_PROFILE);
828 }
829
830 if(!strcmp(profile, finch_sound_get_active_profile()))
831 reload_pref_window(DEFAULT_PROFILE);
832
833 gnt_tree_remove(GNT_TREE(pref_dialog->profiles), (gchar *) profile);
834 }
835
836 static void
837 prof_add_cb(GntButton *button, GntEntry * entry)
838 {
839 const char * profile = gnt_entry_get_text(entry);
840 GntTreeRow * row;
841 if (!finch_sound_profile_exists(profile)) {
842 gpointer key = g_strdup(profile);
843 row = gnt_tree_create_row(GNT_TREE(pref_dialog->profiles), profile);
844 gnt_tree_add_row_after(GNT_TREE(pref_dialog->profiles), key,
845 row,
846 NULL, NULL);
847 gnt_entry_set_text(entry, "");
848 gnt_tree_set_selected(GNT_TREE(pref_dialog->profiles), key);
849 finch_sound_set_active_profile(key);
850 } else
851 reload_pref_window(profile);
852 }
853
854 static void
855 prof_load_cb(GntTree *tree, gpointer oldkey, gpointer newkey, gpointer null)
856 {
857 reload_pref_window(newkey);
858 }
859
860 static void
861 cancel_cb(GntButton *button, gpointer win)
862 {
863 finch_sound_set_active_profile(pref_dialog->original_profile);
864 gnt_widget_destroy(GNT_WIDGET(win));
865 }
866
867 void
868 finch_sounds_show_all(void)
869 {
870 GntWidget *box, *tmpbox, *splitbox, *cmbox, *slider;
871 GntWidget *entry;
872 GntWidget *chkbox;
873 GntWidget *button;
874 GntWidget *label;
875 GntWidget *tree;
876 GntWidget *win;
877
878 gint i;
879 GList *itr, *list;
880
881 if (pref_dialog) {
882 gnt_window_present(pref_dialog->window);
883 return;
884 }
885
886 pref_dialog = g_new0(SoundPrefDialog, 1);
887
888 pref_dialog->original_profile = g_strdup(finch_sound_get_active_profile());
889
890 pref_dialog->window = win = gnt_window_box_new(FALSE, TRUE);
891 gnt_box_set_pad(GNT_BOX(win), 0);
892 gnt_box_set_toplevel(GNT_BOX(win), TRUE);
893 gnt_box_set_title(GNT_BOX(win), _("Sound Preferences"));
894 gnt_box_set_fill(GNT_BOX(win), TRUE);
895 gnt_box_set_alignment(GNT_BOX(win), GNT_ALIGN_MID);
896
897 /* Profiles */
898 splitbox = gnt_hbox_new(FALSE);
899 gnt_box_set_pad(GNT_BOX(splitbox), 0);
900 gnt_box_set_alignment(GNT_BOX(splitbox), GNT_ALIGN_TOP);
901
902 box = gnt_vbox_new(FALSE);
903 gnt_box_set_pad(GNT_BOX(box), 0);
904 gnt_box_add_widget(GNT_BOX(box), gnt_label_new_with_format(_("Profiles"), GNT_TEXT_FLAG_BOLD));
905 pref_dialog->profiles = tree = gnt_tree_new();
906 gnt_tree_set_hash_fns(GNT_TREE(tree), g_str_hash, g_str_equal, g_free);
907 gnt_tree_set_compare_func(GNT_TREE(tree), (GCompareFunc)g_ascii_strcasecmp);
908 g_signal_connect(G_OBJECT(tree), "selection-changed", G_CALLBACK(prof_load_cb), NULL);
909
910 itr = list = finch_sound_get_profiles();
911 for (; itr; itr = itr->next) {
912 /* Do not free itr->data. It's the stored as a key for the tree, and will
913 * be freed when the tree is destroyed. */
914 gnt_tree_add_row_after(GNT_TREE(tree), itr->data,
915 gnt_tree_create_row(GNT_TREE(tree), itr->data), NULL, NULL);
916 }
917 g_list_free(list);
918
919 gnt_box_add_widget(GNT_BOX(box), tree);
920
921 pref_dialog->new_profile = entry = gnt_entry_new("");
922 gnt_box_add_widget(GNT_BOX(box), entry);
923
924 tmpbox = gnt_hbox_new(FALSE);
925 button = gnt_button_new("Add");
926 g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(prof_add_cb), entry);
927 gnt_box_add_widget(GNT_BOX(tmpbox), button);
928 button = gnt_button_new("Delete");
929 g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(prof_del_cb), NULL);
930 gnt_box_add_widget(GNT_BOX(tmpbox), button);
931 gnt_box_add_widget(GNT_BOX(box), tmpbox);
932 gnt_box_add_widget(GNT_BOX(splitbox), box);
933
934 gnt_box_add_widget(GNT_BOX(splitbox), gnt_vline_new());
935
936 /* Sound method */
937
938 box = gnt_vbox_new(FALSE);
939 gnt_box_set_pad(GNT_BOX(box), 0);
940
941 pref_dialog->method = cmbox = gnt_combo_box_new();
942 gnt_tree_set_hash_fns(GNT_TREE(GNT_COMBO_BOX(cmbox)->dropdown), g_str_hash, g_str_equal, NULL);
943 gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "automatic", _("Automatic"));
944 gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "alsa", "ALSA");
945 gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "esd", "ESD");
946 gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "beep", _("Console Beep"));
947 gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "custom", _("Command"));
948 gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), "nosound", _("No Sound"));
949
950 label = gnt_label_new_with_format(_("Sound Method"), GNT_TEXT_FLAG_BOLD);
951 gnt_box_add_widget(GNT_BOX(box), label);
952 tmpbox = gnt_hbox_new(TRUE);
953 gnt_box_set_fill(GNT_BOX(tmpbox), FALSE);
954 gnt_box_set_pad(GNT_BOX(tmpbox), 0);
955 gnt_box_add_widget(GNT_BOX(tmpbox), gnt_label_new(_("Method: ")));
956 gnt_box_add_widget(GNT_BOX(tmpbox), cmbox);
957 gnt_box_add_widget(GNT_BOX(box), tmpbox);
958
959 tmpbox = gnt_hbox_new(TRUE);
960 gnt_box_set_pad(GNT_BOX(tmpbox), 0);
961 gnt_box_set_fill(GNT_BOX(tmpbox), FALSE);
962 gnt_box_add_widget(GNT_BOX(tmpbox), gnt_label_new(_("Sound Command\n(%s for filename)")));
963 pref_dialog->command = entry = gnt_entry_new("");
964 gnt_box_add_widget(GNT_BOX(tmpbox), entry);
965 gnt_box_add_widget(GNT_BOX(box), tmpbox);
966
967 gnt_box_add_widget(GNT_BOX(box), gnt_line_new(FALSE));
968
969 /* Sound options */
970 gnt_box_add_widget(GNT_BOX(box), gnt_label_new_with_format(_("Sound Options"), GNT_TEXT_FLAG_BOLD));
971 pref_dialog->conv_focus = chkbox = gnt_check_box_new(_("Sounds when conversation has focus"));
972 gnt_box_add_widget(GNT_BOX(box), chkbox);
973
974 tmpbox = gnt_hbox_new(TRUE);
975 gnt_box_set_pad(GNT_BOX(tmpbox), 0);
976 gnt_box_set_fill(GNT_BOX(tmpbox), FALSE);
977 gnt_box_add_widget(GNT_BOX(tmpbox), gnt_label_new("Enable Sounds:"));
978 pref_dialog->while_status = cmbox = gnt_combo_box_new();
979 gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), GINT_TO_POINTER(3), _("Always"));
980 gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), GINT_TO_POINTER(1), _("Only when available"));
981 gnt_combo_box_add_data(GNT_COMBO_BOX(cmbox), GINT_TO_POINTER(2), _("Only when not available"));
982 gnt_box_add_widget(GNT_BOX(tmpbox), cmbox);
983 gnt_box_add_widget(GNT_BOX(box), tmpbox);
984
985 tmpbox = gnt_hbox_new(TRUE);
986 gnt_box_set_pad(GNT_BOX(tmpbox), 0);
987 gnt_box_set_fill(GNT_BOX(tmpbox), FALSE);
988 gnt_box_add_widget(GNT_BOX(tmpbox), gnt_label_new(_("Volume(0-100):")));
989
990 pref_dialog->volume = slider = gnt_slider_new(FALSE, 100, 0);
991 gnt_slider_set_step(GNT_SLIDER(slider), 5);
992 label = gnt_label_new("");
993 gnt_slider_reflect_label(GNT_SLIDER(slider), GNT_LABEL(label));
994 gnt_box_set_pad(GNT_BOX(tmpbox), 1);
995 gnt_box_add_widget(GNT_BOX(tmpbox), slider);
996 gnt_box_add_widget(GNT_BOX(tmpbox), label);
997 gnt_box_add_widget(GNT_BOX(box), tmpbox);
998 gnt_box_add_widget(GNT_BOX(splitbox), box);
999
1000 gnt_box_add_widget(GNT_BOX(win), splitbox);
1001
1002 gnt_box_add_widget(GNT_BOX(win), gnt_hline_new());
1003
1004 /* Sound events */
1005 gnt_box_add_widget(GNT_BOX(win), gnt_label_new_with_format(_("Sound Events"), GNT_TEXT_FLAG_BOLD));
1006 pref_dialog->events = tree = gnt_tree_new_with_columns(2);
1007 gnt_tree_set_column_titles(GNT_TREE(tree), _("Event"), _("File"));
1008 gnt_tree_set_show_title(GNT_TREE(tree), TRUE);
1009
1010 for (i = 0; i < PURPLE_NUM_SOUNDS; i++) {
1011 FinchSoundEvent * event = &sounds[i];
1012
1013 if (event->label == NULL) {
1014 continue;
1015 }
1016
1017 gnt_tree_add_choice(GNT_TREE(tree), GINT_TO_POINTER(i),
1018 gnt_tree_create_row(GNT_TREE(tree), "", ""),
1019 NULL, NULL);
1020 }
1021
1022 gnt_tree_adjust_columns(GNT_TREE(tree));
1023 gnt_box_add_widget(GNT_BOX(win), tree);
1024
1025 box = gnt_hbox_new(FALSE);
1026 button = gnt_button_new(_("Test"));
1027 g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(test_cb), NULL);
1028 gnt_box_add_widget(GNT_BOX(box), button);
1029 button = gnt_button_new(_("Reset"));
1030 g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(reset_cb), NULL);
1031 gnt_box_add_widget(GNT_BOX(box), button);
1032 button = gnt_button_new(_("Choose..."));
1033 g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(choose_cb), NULL);
1034 gnt_box_add_widget(GNT_BOX(box), button);
1035 gnt_box_add_widget(GNT_BOX(win), box);
1036
1037 gnt_box_add_widget(GNT_BOX(win), gnt_line_new(FALSE));
1038
1039 /* Add new stuff before this */
1040 box = gnt_hbox_new(FALSE);
1041 gnt_box_set_fill(GNT_BOX(box), TRUE);
1042 button = gnt_button_new(_("Save"));
1043 g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(save_cb), win);
1044 gnt_box_add_widget(GNT_BOX(box), button);
1045 button = gnt_button_new(_("Cancel"));
1046 g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(cancel_cb), win);
1047 gnt_box_add_widget(GNT_BOX(box), button);
1048 gnt_box_add_widget(GNT_BOX(win), box);
1049
1050 g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(release_pref_dialog), NULL);
1051
1052 load_pref_window(finch_sound_get_active_profile());
1053
1054 gnt_widget_show(win);
1055 }
1056
1057 static PurpleSoundUiOps sound_ui_ops =
1058 {
1059 finch_sound_init,
1060 finch_sound_uninit,
1061 finch_sound_play_file,
1062 finch_sound_play_event,
1063 NULL,
1064 NULL,
1065 NULL,
1066 NULL
1067 };
1068
1069 PurpleSoundUiOps *
1070 finch_sound_get_ui_ops(void)
1071 {
1072 return &sound_ui_ops;
1073 }
1074