?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Rewrite fb_http_urlcmp using SoupURI.
[pidgin-git.git] / pidgin / gtkprefs.c
blobe55222d680e8e055b02c2a4d6895fd2adc835981
1 /* pidgin
2 *
3 * Pidgin is the legal property of its developers, whose names are too numerous
4 * to list here. Please refer to the COPYRIGHT file distributed with this
5 * source distribution.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
20 *
21 */
22 #include <talkatu.h>
23
24 #include "internal.h"
25 #include "glibcompat.h"
26 #include "pidgin.h"
27
28 #include "debug.h"
29 #include "http.h"
30 #include "nat-pmp.h"
31 #include "notify.h"
32 #include "prefs.h"
33 #include "proxy.h"
34 #include "protocol.h"
35 #include "request.h"
36 #include "savedstatuses.h"
37 #include "sound.h"
38 #include "sound-theme.h"
39 #include "stun.h"
40 #include "theme-manager.h"
41 #include "upnp.h"
42 #include "util.h"
43 #include "network.h"
44 #include "keyring.h"
45
46 #include "gtkblist.h"
47 #include "gtkconv.h"
48 #include "gtkdialogs.h"
49 #include "gtkprefs.h"
50 #include "gtksavedstatuses.h"
51 #include "gtksmiley-theme.h"
52 #include "gtksound.h"
53 #include "gtkstatus-icon-theme.h"
54 #include "gtkutils.h"
55 #include "pidgindebug.h"
56 #include "pidginstock.h"
57 #ifdef USE_VV
58 #include "media-gst.h"
59 #include <gst/video/videooverlay.h>
60 #ifdef GDK_WINDOWING_WIN32
61 #include <gdk/gdkwin32.h>
62 #endif
63 #ifdef GDK_WINDOWING_X11
64 #include <gdk/gdkx.h>
65 #endif
66 #ifdef GDK_WINDOWING_QUARTZ
67 #include <gdk/gdkquartz.h>
68 #endif
69 #endif
70
71 #include "gtk3compat.h"
72
73 #define PREFS_OPTIMAL_ICON_SIZE 32
74
75 /* 25MB */
76 #define PREFS_MAX_DOWNLOADED_THEME_SIZE 26214400
77
78 struct theme_info {
79 gchar *type;
80 gchar *extension;
81 gchar *original_name;
82 };
83
84 typedef struct _PidginPrefCombo PidginPrefCombo;
85
86 typedef void (*PidginPrefsBindDropdownCallback)(GtkComboBox *combo_box,
87 PidginPrefCombo *combo);
88
89 struct _PidginPrefCombo {
90 GtkWidget *combo;
91 PurplePrefType type;
92 const gchar *key;
93 union {
94 const char *string;
95 int integer;
96 gboolean boolean;
97 } value;
98 gint previously_active;
99 gint current_active;
100 PidginPrefsBindDropdownCallback cb;
101 };
102
103 struct _PidginPrefsWindow {
104 GtkDialog parent;
105
106 /* Stack */
107 GtkWidget *stack;
108
109 /* Interface page */
110 struct {
111 PidginPrefCombo docklet;
112 struct {
113 PidginPrefCombo hide_new;
114 } im;
115 struct {
116 GtkWidget *minimize_new_convs;
117 } win32;
118 struct {
119 GtkWidget *tabs;
120 GtkWidget *tabs_vbox;
121 GtkWidget *close_on_tabs;
122 PidginPrefCombo tab_side;
123 PidginPrefCombo placement;
124 } conversations;
125 } iface;
126
127 /* Browser page */
128 struct {
129 GtkWidget *page;
130 GtkWidget *stack;
131 /* GNOME version */
132 GtkWidget *gnome_not_found;
133 GtkWidget *gnome_program;
134 gchar *gnome_program_path;
135 /* Non-GNOME version */
136 PidginPrefCombo browser;
137 GtkWidget *place_hbox;
138 PidginPrefCombo place;
139 GtkWidget *manual_command_hbox;
140 GtkWidget *manual_command;
141 } browser;
142
143 /* Conversations page */
144 struct {
145 PidginPrefCombo notification_chat;
146 GtkWidget *show_incoming_formatting;
147 struct {
148 GtkWidget *close_immediately;
149 GtkWidget *show_buddy_icons;
150 GtkWidget *animate_buddy_icons;
151 GtkWidget *send_typing;
152 } im;
153 GtkWidget *spellcheck;
154 GtkWidget *use_smooth_scrolling;
155 struct {
156 GtkWidget *blink_im;
157 } win32;
158 GtkWidget *resize_custom_smileys;
159 GtkWidget *custom_smileys_size;
160 GtkWidget *minimum_entry_lines;
161 GtkTextBuffer *format_buffer;
162 GtkWidget *format_view;
163 /* Win32 specific frame */
164 GtkWidget *font_frame;
165 GtkWidget *use_theme_font;
166 GtkWidget *custom_font_hbox;
167 GtkWidget *custom_font;
168 } conversations;
169
170 /* Logging page */
171 struct {
172 PidginPrefCombo format;
173 GtkWidget *log_ims;
174 GtkWidget *log_chats;
175 GtkWidget *log_system;
176 } logging;
177
178 /* Network page */
179 struct {
180 GtkWidget *stun_server;
181 GtkWidget *auto_ip;
182 GtkWidget *public_ip;
183 GtkWidget *public_ip_hbox;
184 GtkWidget *map_ports;
185 GtkWidget *ports_range_use;
186 GtkWidget *ports_range_hbox;
187 GtkWidget *ports_range_start;
188 GtkWidget *ports_range_end;
189 GtkWidget *turn_server;
190 GtkWidget *turn_port_udp;
191 GtkWidget *turn_port_tcp;
192 GtkWidget *turn_username;
193 GtkWidget *turn_password;
194 } network;
195
196 /* Proxy page */
197 struct {
198 GtkWidget *stack;
199 /* GNOME version */
200 GtkWidget *gnome_not_found;
201 GtkWidget *gnome_program;
202 gchar *gnome_program_path;
203 /* Non-GNOME version */
204 GtkWidget *socks4_remotedns;
205 PidginPrefCombo type;
206 GtkWidget *options;
207 GtkWidget *host;
208 GtkWidget *port;
209 GtkWidget *username;
210 GtkWidget *password;
211 } proxy;
212
213 /* Keyrings page */
214 struct {
215 PidginPrefCombo active;
216 GtkWidget *vbox;
217 PurpleRequestFields *settings;
218 GtkWidget *settings_box;
219 GtkWidget *apply;
220 } keyring;
221
222 /* Sounds page */
223 struct {
224 PidginPrefCombo method;
225 GtkWidget *method_vbox;
226 GtkWidget *command;
227 GtkWidget *command_hbox;
228 GtkWidget *mute;
229 GtkWidget *conv_focus;
230 PidginPrefCombo while_status;
231 struct {
232 GtkWidget *view;
233 GtkListStore *store;
234 } event;
235 GtkWidget *entry;
236 } sound;
237
238 /* Away page */
239 struct {
240 PidginPrefCombo idle_reporting;
241 GtkWidget *mins_before_away;
242 GtkWidget *idle_hbox;
243 GtkWidget *away_when_idle;
244 PidginPrefCombo auto_reply;
245 GtkWidget *startup_current_status;
246 GtkWidget *startup_hbox;
247 GtkWidget *startup_label;
248 } away;
249
250 /* Themes page */
251 struct {
252 GtkWidget *blist;
253 GtkWidget *status;
254 GtkWidget *sound;
255 GtkWidget *smiley;
256 } theme;
257
258 #ifdef USE_VV
259 /* Voice/Video page */
260 struct {
261 struct {
262 PidginPrefCombo input;
263 PidginPrefCombo output;
264 GtkWidget *level;
265 GtkWidget *threshold;
266 GtkWidget *volume;
267 GtkWidget *test;
268 GstElement *pipeline;
269 } voice;
270
271 struct {
272 PidginPrefCombo input;
273 PidginPrefCombo output;
274 GtkWidget *drawing_area;
275 GtkWidget *test;
276 GstElement *pipeline;
277 } video;
278 } vv;
279 #endif
280 };
281
282 /* Main dialog */
283 static PidginPrefsWindow *prefs = NULL;
284
285 /* Themes page */
286 static GtkWidget *prefs_sound_themes_combo_box;
287 static GtkWidget *prefs_blist_themes_combo_box;
288 static GtkWidget *prefs_status_themes_combo_box;
289 static GtkWidget *prefs_smiley_themes_combo_box;
290 static PurpleHttpConnection *prefs_themes_running_request = NULL;
291
292 /* Sound theme specific */
293 static int sound_row_sel = 0;
294 static gboolean prefs_sound_themes_loading;
295
296 /* These exist outside the lifetime of the prefs dialog */
297 static GtkListStore *prefs_sound_themes;
298 static GtkListStore *prefs_blist_themes;
299 static GtkListStore *prefs_status_icon_themes;
300 static GtkListStore *prefs_smiley_themes;
301
302 /*
303 * PROTOTYPES
304 */
305 G_DEFINE_TYPE(PidginPrefsWindow, pidgin_prefs_window, GTK_TYPE_DIALOG);
306 static void delete_prefs(GtkWidget *, void *);
307
308 static void
309 update_spin_value(GtkWidget *w, GtkWidget *spin)
310 {
311 const char *key = g_object_get_data(G_OBJECT(spin), "val");
312 int value;
313
314 value = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
315
316 purple_prefs_set_int(key, value);
317 }
318
319 GtkWidget *
320 pidgin_prefs_labeled_spin_button(GtkWidget *box, const gchar *title,
321 const char *key, int min, int max, GtkSizeGroup *sg)
322 {
323 GtkWidget *spin;
324 GtkAdjustment *adjust;
325 int val;
326
327 val = purple_prefs_get_int(key);
328
329 adjust = GTK_ADJUSTMENT(gtk_adjustment_new(val, min, max, 1, 1, 0));
330 spin = gtk_spin_button_new(adjust, 1, 0);
331 g_object_set_data(G_OBJECT(spin), "val", (char *)key);
332 if (max < 10000)
333 gtk_widget_set_size_request(spin, 50, -1);
334 else
335 gtk_widget_set_size_request(spin, 60, -1);
336 g_signal_connect(G_OBJECT(adjust), "value-changed",
337 G_CALLBACK(update_spin_value), GTK_WIDGET(spin));
338 gtk_widget_show(spin);
339
340 return pidgin_add_widget_to_vbox(GTK_BOX(box), title, sg, spin, FALSE, NULL);
341 }
342
343 static void
344 pidgin_prefs_bind_spin_button(const char *key, GtkWidget *spin)
345 {
346 GtkAdjustment *adjust;
347 int val;
348
349 val = purple_prefs_get_int(key);
350
351 adjust = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(spin));
352 gtk_adjustment_set_value(adjust, val);
353 g_object_set_data(G_OBJECT(spin), "val", (char *)key);
354 g_signal_connect(G_OBJECT(adjust), "value-changed",
355 G_CALLBACK(update_spin_value), GTK_WIDGET(spin));
356 }
357
358 static void
359 entry_set(GtkEntry *entry, gpointer data)
360 {
361 const char *key = (const char*)data;
362
363 purple_prefs_set_string(key, gtk_entry_get_text(entry));
364 }
365
366 GtkWidget *
367 pidgin_prefs_labeled_entry(GtkWidget *page, const gchar *title,
368 const char *key, GtkSizeGroup *sg)
369 {
370 GtkWidget *entry;
371 const gchar *value;
372
373 value = purple_prefs_get_string(key);
374
375 entry = gtk_entry_new();
376 gtk_entry_set_text(GTK_ENTRY(entry), value);
377 g_signal_connect(G_OBJECT(entry), "changed",
378 G_CALLBACK(entry_set), (char*)key);
379 gtk_widget_show(entry);
380
381 return pidgin_add_widget_to_vbox(GTK_BOX(page), title, sg, entry, TRUE, NULL);
382 }
383
384 static void
385 pidgin_prefs_bind_entry(const char *key, GtkWidget *entry)
386 {
387 const gchar *value;
388
389 value = purple_prefs_get_string(key);
390
391 gtk_entry_set_text(GTK_ENTRY(entry), value);
392 g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(entry_set),
393 (char*)key);
394 }
395
396 GtkWidget *
397 pidgin_prefs_labeled_password(GtkWidget *page, const gchar *title,
398 const char *key, GtkSizeGroup *sg)
399 {
400 GtkWidget *entry;
401 const gchar *value;
402
403 value = purple_prefs_get_string(key);
404
405 entry = gtk_entry_new();
406 gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
407 gtk_entry_set_text(GTK_ENTRY(entry), value);
408 g_signal_connect(G_OBJECT(entry), "changed",
409 G_CALLBACK(entry_set), (char*)key);
410 gtk_widget_show(entry);
411
412 return pidgin_add_widget_to_vbox(GTK_BOX(page), title, sg, entry, TRUE, NULL);
413 }
414
415 /* TODO: Maybe move this up somewheres... */
416 enum {
417 PREF_DROPDOWN_TEXT,
418 PREF_DROPDOWN_VALUE,
419 PREF_DROPDOWN_COUNT
420 };
421
422 typedef struct
423 {
424 PurplePrefType type;
425 union {
426 const char *string;
427 int integer;
428 gboolean boolean;
429 } value;
430 } PidginPrefValue;
431
432 typedef void (*PidginPrefsDropdownCallback)(GtkComboBox *combo_box,
433 PidginPrefValue value);
434
435 static void
436 dropdown_set(GtkComboBox *combo_box, gpointer _cb)
437 {
438 PidginPrefsDropdownCallback cb = _cb;
439 GtkTreeIter iter;
440 GtkTreeModel *tree_model;
441 PidginPrefValue active;
442
443 tree_model = gtk_combo_box_get_model(combo_box);
444 if (!gtk_combo_box_get_active_iter(combo_box, &iter))
445 return;
446 active.type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(combo_box),
447 "type"));
448
449 g_object_set_data(G_OBJECT(combo_box), "previously_active",
450 g_object_get_data(G_OBJECT(combo_box), "current_active"));
451 g_object_set_data(G_OBJECT(combo_box), "current_active",
452 GINT_TO_POINTER(gtk_combo_box_get_active(combo_box)));
453
454 if (active.type == PURPLE_PREF_INT) {
455 gtk_tree_model_get(tree_model, &iter, PREF_DROPDOWN_VALUE,
456 &active.value.integer, -1);
457 }
458 else if (active.type == PURPLE_PREF_STRING) {
459 gtk_tree_model_get(tree_model, &iter, PREF_DROPDOWN_VALUE,
460 &active.value.string, -1);
461 }
462 else if (active.type == PURPLE_PREF_BOOLEAN) {
463 gtk_tree_model_get(tree_model, &iter, PREF_DROPDOWN_VALUE,
464 &active.value.boolean, -1);
465 }
466
467 cb(combo_box, active);
468 }
469
470 static void
471 pidgin_prefs_bind_dropdown_revert_active(PidginPrefCombo *combo)
472 {
473 g_return_if_fail(combo != NULL);
474
475 combo->current_active = combo->previously_active;
476
477 gtk_combo_box_set_active(GTK_COMBO_BOX(combo->combo),
478 combo->previously_active);
479 }
480
481 static GtkWidget *
482 pidgin_prefs_dropdown_from_list_with_cb(GtkWidget *box, const gchar *title,
483 GtkComboBox **dropdown_out, GList *menuitems,
484 PidginPrefValue initial, PidginPrefsDropdownCallback cb)
485 {
486 GtkWidget *dropdown;
487 GtkWidget *label = NULL;
488 gchar *text;
489 GtkListStore *store = NULL;
490 GtkTreeIter iter;
491 GtkTreeIter active;
492 GtkCellRenderer *renderer;
493 gpointer current_active;
494
495 g_return_val_if_fail(menuitems != NULL, NULL);
496
497 if (initial.type == PURPLE_PREF_INT) {
498 store = gtk_list_store_new(PREF_DROPDOWN_COUNT, G_TYPE_STRING, G_TYPE_INT);
499 } else if (initial.type == PURPLE_PREF_STRING) {
500 store = gtk_list_store_new(PREF_DROPDOWN_COUNT, G_TYPE_STRING, G_TYPE_STRING);
501 } else if (initial.type == PURPLE_PREF_BOOLEAN) {
502 store = gtk_list_store_new(PREF_DROPDOWN_COUNT, G_TYPE_STRING, G_TYPE_BOOLEAN);
503 } else {
504 g_warn_if_reached();
505 return NULL;
506 }
507
508 dropdown = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
509 if (dropdown_out != NULL)
510 *dropdown_out = GTK_COMBO_BOX(dropdown);
511 g_object_set_data(G_OBJECT(dropdown), "type", GINT_TO_POINTER(initial.type));
512
513 while (menuitems != NULL && (text = (char *)menuitems->data) != NULL) {
514 int int_value = 0;
515 const char *str_value = NULL;
516 gboolean bool_value = FALSE;
517
518 menuitems = g_list_next(menuitems);
519 g_return_val_if_fail(menuitems != NULL, NULL);
520
521 gtk_list_store_append(store, &iter);
522 gtk_list_store_set(store, &iter,
523 PREF_DROPDOWN_TEXT, text,
524 -1);
525
526 if (initial.type == PURPLE_PREF_INT) {
527 int_value = GPOINTER_TO_INT(menuitems->data);
528 gtk_list_store_set(store, &iter,
529 PREF_DROPDOWN_VALUE, int_value,
530 -1);
531 }
532 else if (initial.type == PURPLE_PREF_STRING) {
533 str_value = (const char *)menuitems->data;
534 gtk_list_store_set(store, &iter,
535 PREF_DROPDOWN_VALUE, str_value,
536 -1);
537 }
538 else if (initial.type == PURPLE_PREF_BOOLEAN) {
539 bool_value = (gboolean)GPOINTER_TO_INT(menuitems->data);
540 gtk_list_store_set(store, &iter,
541 PREF_DROPDOWN_VALUE, bool_value,
542 -1);
543 }
544
545 if ((initial.type == PURPLE_PREF_INT &&
546 initial.value.integer == int_value) ||
547 (initial.type == PURPLE_PREF_STRING &&
548 purple_strequal(initial.value.string, str_value)) ||
549 (initial.type == PURPLE_PREF_BOOLEAN &&
550 (initial.value.boolean == bool_value))) {
551
552 active = iter;
553 }
554
555 menuitems = g_list_next(menuitems);
556 }
557
558 renderer = gtk_cell_renderer_text_new();
559 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dropdown), renderer, TRUE);
560 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(dropdown), renderer,
561 "text", 0,
562 NULL);
563
564 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(dropdown), &active);
565 current_active = GINT_TO_POINTER(gtk_combo_box_get_active(GTK_COMBO_BOX(
566 dropdown)));
567 g_object_set_data(G_OBJECT(dropdown), "current_active", current_active);
568 g_object_set_data(G_OBJECT(dropdown), "previously_active", current_active);
569
570 g_signal_connect(G_OBJECT(dropdown), "changed",
571 G_CALLBACK(dropdown_set), cb);
572
573 pidgin_add_widget_to_vbox(GTK_BOX(box), title, NULL, dropdown, FALSE, &label);
574
575 return label;
576 }
577
578 static void
579 pidgin_prefs_dropdown_from_list_cb(GtkComboBox *combo_box,
580 PidginPrefValue value)
581 {
582 const char *key;
583
584 key = g_object_get_data(G_OBJECT(combo_box), "key");
585
586 if (value.type == PURPLE_PREF_INT) {
587 purple_prefs_set_int(key, value.value.integer);
588 } else if (value.type == PURPLE_PREF_STRING) {
589 purple_prefs_set_string(key, value.value.string);
590 } else if (value.type == PURPLE_PREF_BOOLEAN) {
591 purple_prefs_set_bool(key, value.value.boolean);
592 } else {
593 g_return_if_reached();
594 }
595 }
596
597 GtkWidget *
598 pidgin_prefs_dropdown_from_list(GtkWidget *box, const gchar *title,
599 PurplePrefType type, const char *key, GList *menuitems)
600 {
601 PidginPrefValue initial;
602 GtkComboBox *dropdown = NULL;
603 GtkWidget *label;
604
605 initial.type = type;
606 if (type == PURPLE_PREF_INT) {
607 initial.value.integer = purple_prefs_get_int(key);
608 } else if (type == PURPLE_PREF_STRING) {
609 initial.value.string = purple_prefs_get_string(key);
610 } else if (type == PURPLE_PREF_BOOLEAN) {
611 initial.value.boolean = purple_prefs_get_bool(key);
612 } else {
613 g_return_val_if_reached(NULL);
614 }
615
616 label = pidgin_prefs_dropdown_from_list_with_cb(box, title, &dropdown,
617 menuitems, initial, pidgin_prefs_dropdown_from_list_cb);
618
619 g_object_set_data(G_OBJECT(dropdown), "key", (gpointer)key);
620
621 return label;
622 }
623
624 GtkWidget *
625 pidgin_prefs_dropdown(GtkWidget *box, const gchar *title, PurplePrefType type,
626 const char *key, ...)
627 {
628 va_list ap;
629 GList *menuitems = NULL;
630 GtkWidget *dropdown = NULL;
631 char *name;
632 int int_value;
633 const char *str_value;
634
635 g_return_val_if_fail(type == PURPLE_PREF_BOOLEAN || type == PURPLE_PREF_INT ||
636 type == PURPLE_PREF_STRING, NULL);
637
638 va_start(ap, key);
639 while ((name = va_arg(ap, char *)) != NULL) {
640
641 menuitems = g_list_prepend(menuitems, name);
642
643 if (type == PURPLE_PREF_INT || type == PURPLE_PREF_BOOLEAN) {
644 int_value = va_arg(ap, int);
645 menuitems = g_list_prepend(menuitems, GINT_TO_POINTER(int_value));
646 }
647 else {
648 str_value = va_arg(ap, const char *);
649 menuitems = g_list_prepend(menuitems, (char *)str_value);
650 }
651 }
652 va_end(ap);
653
654 g_return_val_if_fail(menuitems != NULL, NULL);
655
656 menuitems = g_list_reverse(menuitems);
657
658 dropdown = pidgin_prefs_dropdown_from_list(box, title, type, key,
659 menuitems);
660
661 g_list_free(menuitems);
662
663 return dropdown;
664 }
665
666 static void
667 pidgin_prefs_bind_dropdown_from_list_cb(GtkComboBox *combo_box,
668 PidginPrefCombo *combo)
669 {
670 if (combo->type == PURPLE_PREF_INT) {
671 purple_prefs_set_int(combo->key, combo->value.integer);
672 } else if (combo->type == PURPLE_PREF_STRING) {
673 purple_prefs_set_string(combo->key, combo->value.string);
674 } else if (combo->type == PURPLE_PREF_BOOLEAN) {
675 purple_prefs_set_bool(combo->key, combo->value.boolean);
676 } else {
677 g_return_if_reached();
678 }
679 }
680
681 static void
682 bind_dropdown_set(GtkComboBox *combo_box, gpointer data)
683 {
684 PidginPrefCombo *combo = data;
685 GtkTreeIter iter;
686 GtkTreeModel *tree_model;
687
688 tree_model = gtk_combo_box_get_model(combo_box);
689 if (!gtk_combo_box_get_active_iter(combo_box, &iter))
690 return;
691
692 combo->previously_active = combo->current_active;
693 combo->current_active = gtk_combo_box_get_active(combo_box);
694
695 if (combo->type == PURPLE_PREF_INT) {
696 gtk_tree_model_get(tree_model, &iter, PREF_DROPDOWN_VALUE,
697 &combo->value.integer, -1);
698 }
699 else if (combo->type == PURPLE_PREF_STRING) {
700 gtk_tree_model_get(tree_model, &iter, PREF_DROPDOWN_VALUE,
701 &combo->value.string, -1);
702 }
703 else if (combo->type == PURPLE_PREF_BOOLEAN) {
704 gtk_tree_model_get(tree_model, &iter, PREF_DROPDOWN_VALUE,
705 &combo->value.boolean, -1);
706 }
707
708 combo->cb(combo_box, combo);
709 }
710
711 static void
712 pidgin_prefs_bind_dropdown_from_list(PidginPrefCombo *combo, GList *menuitems)
713 {
714 gchar *text;
715 GtkListStore *store = NULL;
716 GtkTreeIter iter;
717 GtkTreeIter active;
718
719 g_return_if_fail(menuitems != NULL);
720
721 if (combo->type == PURPLE_PREF_INT) {
722 combo->value.integer = purple_prefs_get_int(combo->key);
723 } else if (combo->type == PURPLE_PREF_STRING) {
724 combo->value.string = purple_prefs_get_string(combo->key);
725 } else if (combo->type == PURPLE_PREF_BOOLEAN) {
726 combo->value.boolean = purple_prefs_get_bool(combo->key);
727 } else {
728 g_return_if_reached();
729 }
730
731 store = GTK_LIST_STORE(
732 gtk_combo_box_get_model(GTK_COMBO_BOX(combo->combo)));
733
734 while (menuitems != NULL && (text = (char *)menuitems->data) != NULL) {
735 int int_value = 0;
736 const char *str_value = NULL;
737 gboolean bool_value = FALSE;
738
739 menuitems = g_list_next(menuitems);
740 g_return_if_fail(menuitems != NULL);
741
742 gtk_list_store_append(store, &iter);
743 gtk_list_store_set(store, &iter,
744 PREF_DROPDOWN_TEXT, text,
745 -1);
746
747 if (combo->type == PURPLE_PREF_INT) {
748 int_value = GPOINTER_TO_INT(menuitems->data);
749 gtk_list_store_set(store, &iter,
750 PREF_DROPDOWN_VALUE, int_value,
751 -1);
752 }
753 else if (combo->type == PURPLE_PREF_STRING) {
754 str_value = (const char *)menuitems->data;
755 gtk_list_store_set(store, &iter,
756 PREF_DROPDOWN_VALUE, str_value,
757 -1);
758 }
759 else if (combo->type == PURPLE_PREF_BOOLEAN) {
760 bool_value = (gboolean)GPOINTER_TO_INT(menuitems->data);
761 gtk_list_store_set(store, &iter,
762 PREF_DROPDOWN_VALUE, bool_value,
763 -1);
764 }
765
766 if ((combo->type == PURPLE_PREF_INT &&
767 combo->value.integer == int_value) ||
768 (combo->type == PURPLE_PREF_STRING &&
769 purple_strequal(combo->value.string, str_value)) ||
770 (combo->type == PURPLE_PREF_BOOLEAN &&
771 (combo->value.boolean == bool_value))) {
772
773 active = iter;
774 }
775
776 menuitems = g_list_next(menuitems);
777 }
778
779 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo->combo), &active);
780 combo->current_active = gtk_combo_box_get_active(
781 GTK_COMBO_BOX(combo->combo));
782 combo->previously_active = combo->current_active;
783
784 combo->cb = pidgin_prefs_bind_dropdown_from_list_cb;
785 g_signal_connect(G_OBJECT(combo->combo), "changed",
786 G_CALLBACK(bind_dropdown_set), combo);
787 }
788
789 static void
790 pidgin_prefs_bind_dropdown(PidginPrefCombo *combo)
791 {
792 GtkTreeModel *store = NULL;
793 GtkTreeIter iter;
794 GtkTreeIter active;
795
796 if (combo->type == PURPLE_PREF_INT) {
797 combo->value.integer = purple_prefs_get_int(combo->key);
798 } else if (combo->type == PURPLE_PREF_STRING) {
799 combo->value.string = purple_prefs_get_string(combo->key);
800 } else if (combo->type == PURPLE_PREF_BOOLEAN) {
801 combo->value.boolean = purple_prefs_get_bool(combo->key);
802 } else {
803 g_return_if_reached();
804 }
805
806 store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo->combo));
807
808 if (!gtk_tree_model_get_iter_first(store, &iter)) {
809 g_return_if_reached();
810 }
811
812 do {
813 int int_value = 0;
814 const char *str_value = NULL;
815 gboolean bool_value = FALSE;
816
817 if (combo->type == PURPLE_PREF_INT) {
818 gtk_tree_model_get(store, &iter,
819 PREF_DROPDOWN_VALUE, &int_value,
820 -1);
821 if (combo->value.integer == int_value) {
822 active = iter;
823 break;
824 }
825 }
826 else if (combo->type == PURPLE_PREF_STRING) {
827 gtk_tree_model_get(store, &iter,
828 PREF_DROPDOWN_VALUE, &str_value,
829 -1);
830 if (purple_strequal(combo->value.string, str_value)) {
831 active = iter;
832 break;
833 }
834 }
835 else if (combo->type == PURPLE_PREF_BOOLEAN) {
836 gtk_tree_model_get(store, &iter,
837 PREF_DROPDOWN_VALUE, &bool_value,
838 -1);
839 if (combo->value.boolean == bool_value) {
840 active = iter;
841 break;
842 }
843 }
844 } while (gtk_tree_model_iter_next(store, &iter));
845
846 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo->combo), &active);
847
848 combo->current_active = gtk_combo_box_get_active(
849 GTK_COMBO_BOX(combo->combo));
850 combo->previously_active = combo->current_active;
851
852 combo->cb = pidgin_prefs_bind_dropdown_from_list_cb;
853 g_signal_connect(G_OBJECT(combo->combo), "changed",
854 G_CALLBACK(bind_dropdown_set), combo);
855 }
856
857 static void
858 set_bool_pref(GtkWidget *w, const char *key)
859 {
860 purple_prefs_set_bool(key,
861 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
862 }
863
864 GtkWidget *
865 pidgin_prefs_checkbox(const char *text, const char *key, GtkWidget *page)
866 {
867 GtkWidget *button;
868
869 button = gtk_check_button_new_with_mnemonic(text);
870 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
871 purple_prefs_get_bool(key));
872
873 gtk_box_pack_start(GTK_BOX(page), button, FALSE, FALSE, 0);
874
875 g_signal_connect(G_OBJECT(button), "clicked",
876 G_CALLBACK(set_bool_pref), (char *)key);
877
878 gtk_widget_show(button);
879
880 return button;
881 }
882
883 static void
884 pidgin_prefs_bind_checkbox(const char *key, GtkWidget *button)
885 {
886 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
887 purple_prefs_get_bool(key));
888 g_signal_connect(G_OBJECT(button), "toggled",
889 G_CALLBACK(set_bool_pref), (char *)key);
890 }
891
892 static void keyring_page_cleanup(PidginPrefsWindow *win);
893
894 static void
895 delete_prefs(GtkWidget *asdf, void *gdsa)
896 {
897 /* Close any "select sound" request dialogs */
898 purple_request_close_with_handle(prefs);
899
900 purple_notify_close_with_handle(prefs);
901
902 /* Unregister callbacks. */
903 purple_prefs_disconnect_by_handle(prefs);
904
905 /* NULL-ify globals */
906 sound_row_sel = 0;
907 prefs_sound_themes_loading = FALSE;
908
909 prefs_sound_themes_combo_box = NULL;
910 prefs_blist_themes_combo_box = NULL;
911 prefs_status_themes_combo_box = NULL;
912 prefs_smiley_themes_combo_box = NULL;
913
914 keyring_page_cleanup(prefs);
915
916 g_free(prefs->proxy.gnome_program_path);
917 g_free(prefs->browser.gnome_program_path);
918 prefs = NULL;
919 }
920
921 static gchar *
922 get_theme_markup(const char *name, gboolean custom, const char *author,
923 const char *description)
924 {
925
926 return g_strdup_printf("<b>%s</b>%s%s%s%s\n<span foreground='dim grey'>%s</span>",
927 name, custom ? " " : "", custom ? _("(Custom)") : "",
928 author != NULL ? " - " : "", author != NULL ? author : "",
929 description != NULL ? description : "");
930 }
931
932 static void
933 smileys_refresh_theme_list(void)
934 {
935 GList *it;
936 GtkTreeIter iter;
937 gchar *description;
938
939 description = get_theme_markup(_("none"), FALSE, _("Penguin Pimps"),
940 _("Selecting this disables graphical emoticons."));
941 gtk_list_store_append(prefs_smiley_themes, &iter);
942 gtk_list_store_set(prefs_smiley_themes, &iter,
943 0, NULL, 1, description, 2, "none", -1);
944 g_free(description);
945
946 for (it = pidgin_smiley_theme_get_all(); it; it = g_list_next(it)) {
947 PidginSmileyTheme *theme = it->data;
948
949 description = get_theme_markup(
950 _(pidgin_smiley_theme_get_name(theme)), FALSE,
951 _(pidgin_smiley_theme_get_author(theme)),
952 _(pidgin_smiley_theme_get_description(theme)));
953
954 gtk_list_store_append(prefs_smiley_themes, &iter);
955 gtk_list_store_set(prefs_smiley_themes, &iter,
956 0, pidgin_smiley_theme_get_icon(theme),
957 1, description,
958 2, pidgin_smiley_theme_get_name(theme),
959 -1);
960
961 g_free(description);
962 }
963 }
964
965 /* Rebuild the markup for the sound theme selection for "(Custom)" themes */
966 static void
967 pref_sound_generate_markup(void)
968 {
969 gboolean print_custom, customized;
970 const gchar *author, *description, *current_theme;
971 gchar *name, *markup;
972 PurpleSoundTheme *theme;
973 GtkTreeIter iter;
974
975 customized = pidgin_sound_is_customized();
976 current_theme = purple_prefs_get_string(PIDGIN_PREFS_ROOT "/sound/theme");
977
978 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(prefs_sound_themes), &iter)) {
979 do {
980 gtk_tree_model_get(GTK_TREE_MODEL(prefs_sound_themes), &iter, 2, &name, -1);
981
982 print_custom = customized && name && purple_strequal(current_theme, name);
983
984 if (!name || *name == '\0') {
985 g_free(name);
986 name = g_strdup(_("Default"));
987 author = _("Penguin Pimps");
988 description = _("The default Pidgin sound theme");
989 } else {
990 theme = PURPLE_SOUND_THEME(purple_theme_manager_find_theme(name, "sound"));
991 author = purple_theme_get_author(PURPLE_THEME(theme));
992 description = purple_theme_get_description(PURPLE_THEME(theme));
993 }
994
995 markup = get_theme_markup(name, print_custom, author, description);
996
997 gtk_list_store_set(prefs_sound_themes, &iter, 1, markup, -1);
998
999 g_free(name);
1000 g_free(markup);
1001
1002 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(prefs_sound_themes), &iter));
1003 }
1004 }
1005
1006 /* adds the themes to the theme list from the manager so they can be displayed in prefs */
1007 static void
1008 prefs_themes_sort(PurpleTheme *theme)
1009 {
1010 GdkPixbuf *pixbuf = NULL;
1011 GtkTreeIter iter;
1012 gchar *image_full = NULL, *markup;
1013 const gchar *name, *author, *description;
1014
1015 if (PURPLE_IS_SOUND_THEME(theme)){
1016
1017 image_full = purple_theme_get_image_full(theme);
1018 if (image_full != NULL){
1019 pixbuf = pidgin_pixbuf_new_from_file_at_scale(image_full, PREFS_OPTIMAL_ICON_SIZE, PREFS_OPTIMAL_ICON_SIZE, TRUE);
1020 g_free(image_full);
1021 } else
1022 pixbuf = NULL;
1023
1024 gtk_list_store_append(prefs_sound_themes, &iter);
1025 gtk_list_store_set(prefs_sound_themes, &iter, 0, pixbuf, 2, purple_theme_get_name(theme), -1);
1026
1027 if (pixbuf != NULL)
1028 g_object_unref(G_OBJECT(pixbuf));
1029
1030 } else if (PIDGIN_IS_BLIST_THEME(theme) || PIDGIN_IS_STATUS_ICON_THEME(theme)){
1031 GtkListStore *store;
1032
1033 if (PIDGIN_IS_BLIST_THEME(theme))
1034 store = prefs_blist_themes;
1035 else
1036 store = prefs_status_icon_themes;
1037
1038 image_full = purple_theme_get_image_full(theme);
1039 if (image_full != NULL){
1040 pixbuf = pidgin_pixbuf_new_from_file_at_scale(image_full, PREFS_OPTIMAL_ICON_SIZE, PREFS_OPTIMAL_ICON_SIZE, TRUE);
1041 g_free(image_full);
1042 } else
1043 pixbuf = NULL;
1044
1045 name = purple_theme_get_name(theme);
1046 author = purple_theme_get_author(theme);
1047 description = purple_theme_get_description(theme);
1048
1049 markup = get_theme_markup(name, FALSE, author, description);
1050
1051 gtk_list_store_append(store, &iter);
1052 gtk_list_store_set(store, &iter, 0, pixbuf, 1, markup, 2, name, -1);
1053
1054 g_free(markup);
1055 if (pixbuf != NULL)
1056 g_object_unref(G_OBJECT(pixbuf));
1057
1058 }
1059 }
1060
1061 static void
1062 prefs_set_active_theme_combo(GtkWidget *combo_box, GtkListStore *store, const gchar *current_theme)
1063 {
1064 GtkTreeIter iter;
1065 gchar *theme = NULL;
1066 gboolean unset = TRUE;
1067
1068 if (current_theme && *current_theme && gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) {
1069 do {
1070 gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 2, &theme, -1);
1071
1072 if (purple_strequal(current_theme, theme)) {
1073 gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo_box), &iter);
1074 unset = FALSE;
1075 }
1076
1077 g_free(theme);
1078 } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
1079 }
1080
1081 if (unset)
1082 gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), 0);
1083 }
1084
1085 static void
1086 prefs_themes_refresh(void)
1087 {
1088 GdkPixbuf *pixbuf = NULL;
1089 gchar *tmp;
1090 GtkTreeIter iter;
1091
1092 prefs_sound_themes_loading = TRUE;
1093 /* refresh the list of themes in the manager */
1094 purple_theme_manager_refresh();
1095
1096 tmp = g_build_filename(PURPLE_DATADIR, "icons", "hicolor", "32x32",
1097 "apps", "im.pidgin.Pidgin3.png", NULL);
1098 pixbuf = pidgin_pixbuf_new_from_file_at_scale(tmp, PREFS_OPTIMAL_ICON_SIZE, PREFS_OPTIMAL_ICON_SIZE, TRUE);
1099 g_free(tmp);
1100
1101 /* sound themes */
1102 gtk_list_store_clear(prefs_sound_themes);
1103 gtk_list_store_append(prefs_sound_themes, &iter);
1104 gtk_list_store_set(prefs_sound_themes, &iter, 0, pixbuf, 2, "", -1);
1105
1106 /* blist themes */
1107 gtk_list_store_clear(prefs_blist_themes);
1108 gtk_list_store_append(prefs_blist_themes, &iter);
1109 tmp = get_theme_markup(_("Default"), FALSE, _("Penguin Pimps"),
1110 _("The default Pidgin buddy list theme"));
1111 gtk_list_store_set(prefs_blist_themes, &iter, 0, pixbuf, 1, tmp, 2, "", -1);
1112 g_free(tmp);
1113
1114 /* status icon themes */
1115 gtk_list_store_clear(prefs_status_icon_themes);
1116 gtk_list_store_append(prefs_status_icon_themes, &iter);
1117 tmp = get_theme_markup(_("Default"), FALSE, _("Penguin Pimps"),
1118 _("The default Pidgin status icon theme"));
1119 gtk_list_store_set(prefs_status_icon_themes, &iter, 0, pixbuf, 1, tmp, 2, "", -1);
1120 g_free(tmp);
1121 if (pixbuf)
1122 g_object_unref(G_OBJECT(pixbuf));
1123
1124 /* smiley themes */
1125 gtk_list_store_clear(prefs_smiley_themes);
1126
1127 purple_theme_manager_for_each_theme(prefs_themes_sort);
1128 pref_sound_generate_markup();
1129 smileys_refresh_theme_list();
1130
1131 /* set active */
1132 prefs_set_active_theme_combo(prefs_sound_themes_combo_box, prefs_sound_themes, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/sound/theme"));
1133 prefs_set_active_theme_combo(prefs_blist_themes_combo_box, prefs_blist_themes, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/blist/theme"));
1134 prefs_set_active_theme_combo(prefs_status_themes_combo_box, prefs_status_icon_themes, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/status/icon-theme"));
1135 prefs_set_active_theme_combo(prefs_smiley_themes_combo_box, prefs_smiley_themes, purple_prefs_get_string(PIDGIN_PREFS_ROOT "/smileys/theme"));
1136 prefs_sound_themes_loading = FALSE;
1137 }
1138
1139 /* init all the theme variables so that the themes can be sorted later and used by pref pages */
1140 static void
1141 prefs_themes_init(void)
1142 {
1143 prefs_sound_themes = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
1144
1145 prefs_blist_themes = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
1146
1147 prefs_status_icon_themes = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
1148
1149 prefs_smiley_themes = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
1150 }
1151
1152 /*
1153 * prefs_theme_find_theme:
1154 * @path: A directory containing a theme. The theme could be at the
1155 * top level of this directory or in any subdirectory thereof.
1156 * @type: The type of theme to load. The loader for this theme type
1157 * will be used and this loader will determine what constitutes a
1158 * "theme."
1159 *
1160 * Attempt to load the given directory as a theme. If we are unable to
1161 * open the path as a theme then we recurse into path and attempt to
1162 * load each subdirectory that we encounter.
1163 *
1164 * Returns: A new reference to a #PurpleTheme.
1165 */
1166 static PurpleTheme *
1167 prefs_theme_find_theme(const gchar *path, const gchar *type)
1168 {
1169 PurpleTheme *theme = purple_theme_manager_load_theme(path, type);
1170 GDir *dir = g_dir_open(path, 0, NULL);
1171 const gchar *next;
1172
1173 while (!PURPLE_IS_THEME(theme) && (next = g_dir_read_name(dir))) {
1174 gchar *next_path = g_build_filename(path, next, NULL);
1175
1176 if (g_file_test(next_path, G_FILE_TEST_IS_DIR))
1177 theme = prefs_theme_find_theme(next_path, type);
1178
1179 g_free(next_path);
1180 }
1181
1182 g_dir_close(dir);
1183
1184 return theme;
1185 }
1186
1187 /* Eww. Seriously ewww. But thanks, grim! This is taken from guifications2 */
1188 static gboolean
1189 purple_theme_file_copy(const gchar *source, const gchar *destination)
1190 {
1191 FILE *src, *dest;
1192 gint chr = EOF;
1193
1194 if(!(src = g_fopen(source, "rb")))
1195 return FALSE;
1196 if(!(dest = g_fopen(destination, "wb"))) {
1197 fclose(src);
1198 return FALSE;
1199 }
1200
1201 while((chr = fgetc(src)) != EOF) {
1202 fputc(chr, dest);
1203 }
1204
1205 fclose(dest);
1206 fclose(src);
1207
1208 return TRUE;
1209 }
1210
1211 static void
1212 free_theme_info(struct theme_info *info)
1213 {
1214 if (info != NULL) {
1215 g_free(info->type);
1216 g_free(info->extension);
1217 g_free(info->original_name);
1218 g_free(info);
1219 }
1220 }
1221
1222 /* installs a theme, info is freed by function */
1223 static void
1224 theme_install_theme(char *path, struct theme_info *info)
1225 {
1226 gchar *destdir;
1227 const char *tail;
1228 gboolean is_smiley_theme, is_archive;
1229 PurpleTheme *theme = NULL;
1230
1231 if (info == NULL)
1232 return;
1233
1234 /* check the extension */
1235 tail = info->extension ? info->extension : strrchr(path, '.');
1236
1237 if (!tail) {
1238 free_theme_info(info);
1239 return;
1240 }
1241
1242 is_archive = !g_ascii_strcasecmp(tail, ".gz") || !g_ascii_strcasecmp(tail, ".tgz");
1243
1244 /* Just to be safe */
1245 g_strchomp(path);
1246
1247 if ((is_smiley_theme = purple_strequal(info->type, "smiley")))
1248 destdir = g_build_filename(purple_data_dir(), "smileys", NULL);
1249 else
1250 destdir = g_build_filename(purple_data_dir(), "themes", "temp", NULL);
1251
1252 /* We'll check this just to make sure. This also lets us do something different on
1253 * other platforms, if need be */
1254 if (is_archive) {
1255 #ifndef _WIN32
1256 gchar *path_escaped = g_shell_quote(path);
1257 gchar *destdir_escaped = g_shell_quote(destdir);
1258 gchar *command;
1259
1260 if (!g_file_test(destdir, G_FILE_TEST_IS_DIR))
1261 purple_build_dir(destdir, S_IRUSR | S_IWUSR | S_IXUSR);
1262
1263 command = g_strdup_printf("tar > /dev/null xzf %s -C %s", path_escaped, destdir_escaped);
1264 g_free(path_escaped);
1265 g_free(destdir_escaped);
1266
1267 /* Fire! */
1268 if (system(command)) {
1269 purple_notify_error(NULL, NULL, _("Theme failed to unpack."), NULL, NULL);
1270 g_free(command);
1271 g_free(destdir);
1272 free_theme_info(info);
1273 return;
1274 }
1275 g_free(command);
1276 #else
1277 if (!winpidgin_gz_untar(path, destdir)) {
1278 purple_notify_error(NULL, NULL, _("Theme failed to unpack."), NULL, NULL);
1279 g_free(destdir);
1280 free_theme_info(info);
1281 return;
1282 }
1283 #endif
1284 }
1285
1286 if (is_smiley_theme) {
1287 /* just extract the folder to the smiley directory */
1288 prefs_themes_refresh();
1289
1290 } else if (is_archive) {
1291 theme = prefs_theme_find_theme(destdir, info->type);
1292
1293 if (PURPLE_IS_THEME(theme)) {
1294 /* create the location for the theme */
1295 gchar *theme_dest = g_build_filename(purple_data_dir(), "themes",
1296 purple_theme_get_name(theme),
1297 "purple", info->type, NULL);
1298
1299 if (!g_file_test(theme_dest, G_FILE_TEST_IS_DIR))
1300 purple_build_dir(theme_dest, S_IRUSR | S_IWUSR | S_IXUSR);
1301
1302 g_free(theme_dest);
1303 theme_dest = g_build_filename(purple_data_dir(), "themes",
1304 purple_theme_get_name(theme),
1305 "purple", info->type, NULL);
1306
1307 /* move the entire directory to new location */
1308 if (g_rename(purple_theme_get_dir(theme), theme_dest)) {
1309 purple_debug_error("gtkprefs", "Error renaming %s to %s: "
1310 "%s\n", purple_theme_get_dir(theme), theme_dest,
1311 g_strerror(errno));
1312 }
1313
1314 g_free(theme_dest);
1315 if (g_remove(destdir) != 0) {
1316 purple_debug_error("gtkprefs",
1317 "couldn't remove temp (dest) path\n");
1318 }
1319 g_object_unref(theme);
1320
1321 prefs_themes_refresh();
1322
1323 } else {
1324 /* something was wrong with the theme archive */
1325 g_unlink(destdir);
1326 purple_notify_error(NULL, NULL, _("Theme failed to load."), NULL, NULL);
1327 }
1328
1329 } else { /* just a single file so copy it to a new temp directory and attempt to load it*/
1330 gchar *temp_path, *temp_file;
1331
1332 temp_path = g_build_filename(purple_data_dir(), "themes", "temp",
1333 "sub_folder", NULL);
1334
1335 if (info->original_name != NULL) {
1336 /* name was changed from the original (probably a dnd) change it back before loading */
1337 temp_file = g_build_filename(temp_path, info->original_name, NULL);
1338
1339 } else {
1340 gchar *source_name = g_path_get_basename(path);
1341 temp_file = g_build_filename(temp_path, source_name, NULL);
1342 g_free(source_name);
1343 }
1344
1345 if (!g_file_test(temp_path, G_FILE_TEST_IS_DIR))
1346 purple_build_dir(temp_path, S_IRUSR | S_IWUSR | S_IXUSR);
1347
1348 if (purple_theme_file_copy(path, temp_file)) {
1349 /* find the theme, could be in subfolder */
1350 theme = prefs_theme_find_theme(temp_path, info->type);
1351
1352 if (PURPLE_IS_THEME(theme)) {
1353 gchar *theme_dest =
1354 g_build_filename(purple_data_dir(), "themes",
1355 purple_theme_get_name(theme), "purple",
1356 info->type, NULL);
1357
1358 if(!g_file_test(theme_dest, G_FILE_TEST_IS_DIR))
1359 purple_build_dir(theme_dest, S_IRUSR | S_IWUSR | S_IXUSR);
1360
1361 if (g_rename(purple_theme_get_dir(theme), theme_dest)) {
1362 purple_debug_error("gtkprefs", "Error renaming %s to %s: "
1363 "%s\n", purple_theme_get_dir(theme), theme_dest,
1364 g_strerror(errno));
1365 }
1366
1367 g_free(theme_dest);
1368 g_object_unref(theme);
1369
1370 prefs_themes_refresh();
1371 } else {
1372 if (g_remove(temp_path) != 0) {
1373 purple_debug_error("gtkprefs",
1374 "couldn't remove temp path");
1375 }
1376 purple_notify_error(NULL, NULL, _("Theme failed to load."), NULL, NULL);
1377 }
1378 } else {
1379 purple_notify_error(NULL, NULL, _("Theme failed to copy."), NULL, NULL);
1380 }
1381
1382 g_free(temp_file);
1383 g_free(temp_path);
1384 }
1385
1386 g_free(destdir);
1387 free_theme_info(info);
1388 }
1389
1390 static void
1391 theme_got_url(PurpleHttpConnection *http_conn, PurpleHttpResponse *response,
1392 gpointer _info)
1393 {
1394 struct theme_info *info = _info;
1395 const gchar *themedata;
1396 size_t len;
1397 FILE *f;
1398 gchar *path;
1399 size_t wc;
1400
1401 g_assert(http_conn == prefs_themes_running_request);
1402 prefs_themes_running_request = NULL;
1403
1404 if (!purple_http_response_is_successful(response)) {
1405 free_theme_info(info);
1406 return;
1407 }
1408
1409 themedata = purple_http_response_get_data(response, &len);
1410
1411 f = purple_mkstemp(&path, TRUE);
1412 wc = fwrite(themedata, len, 1, f);
1413 if (wc != 1) {
1414 purple_debug_warning("theme_got_url", "Unable to write theme data.\n");
1415 fclose(f);
1416 g_unlink(path);
1417 g_free(path);
1418 free_theme_info(info);
1419 return;
1420 }
1421 fclose(f);
1422
1423 theme_install_theme(path, info);
1424
1425 g_unlink(path);
1426 g_free(path);
1427 }
1428
1429 static void
1430 theme_dnd_recv(GtkWidget *widget, GdkDragContext *dc, guint x, guint y,
1431 GtkSelectionData *sd, guint info, guint t, gpointer user_data)
1432 {
1433 gchar *name = g_strchomp((gchar *)gtk_selection_data_get_data(sd));
1434
1435 if ((gtk_selection_data_get_length(sd) >= 0)
1436 && (gtk_selection_data_get_format(sd) == 8)) {
1437 /* Well, it looks like the drag event was cool.
1438 * Let's do something with it */
1439 gchar *temp;
1440 struct theme_info *info = g_new0(struct theme_info, 1);
1441 info->type = g_strdup((gchar *)user_data);
1442 info->extension = g_strdup(g_strrstr(name,"."));
1443 temp = g_strrstr(name, "/");
1444 info->original_name = temp ? g_strdup(++temp) : NULL;
1445
1446 if (!g_ascii_strncasecmp(name, "file://", 7)) {
1447 GError *converr = NULL;
1448 gchar *tmp;
1449 /* It looks like we're dealing with a local file. Let's
1450 * just untar it in the right place */
1451 if(!(tmp = g_filename_from_uri(name, NULL, &converr))) {
1452 purple_debug(PURPLE_DEBUG_ERROR, "theme dnd", "%s\n",
1453 (converr ? converr->message :
1454 "g_filename_from_uri error"));
1455 free_theme_info(info);
1456 return;
1457 }
1458 theme_install_theme(tmp, info);
1459 g_free(tmp);
1460 } else if (!g_ascii_strncasecmp(name, "http://", 7) ||
1461 !g_ascii_strncasecmp(name, "https://", 8)) {
1462 /* Oo, a web drag and drop. This is where things
1463 * will start to get interesting */
1464 PurpleHttpRequest *hr;
1465 purple_http_conn_cancel(prefs_themes_running_request);
1466
1467 hr = purple_http_request_new(name);
1468 purple_http_request_set_max_len(hr,
1469 PREFS_MAX_DOWNLOADED_THEME_SIZE);
1470 prefs_themes_running_request = purple_http_request(
1471 NULL, hr, theme_got_url, info);
1472 purple_http_request_unref(hr);
1473 } else
1474 free_theme_info(info);
1475
1476 gtk_drag_finish(dc, TRUE, FALSE, t);
1477 }
1478
1479 gtk_drag_finish(dc, FALSE, FALSE, t);
1480 }
1481
1482 /* builds a theme combo box from a list store with colums: icon preview, markup, theme name */
1483 static void
1484 prefs_build_theme_combo_box(GtkWidget *combo_box, GtkListStore *store,
1485 const char *current_theme, const char *type)
1486 {
1487 GtkTargetEntry te[3] = {
1488 {"text/plain", 0, 0},
1489 {"text/uri-list", 0, 1},
1490 {"STRING", 0, 2}
1491 };
1492
1493 g_return_if_fail(store != NULL && current_theme != NULL);
1494
1495 gtk_combo_box_set_model(GTK_COMBO_BOX(combo_box),
1496 GTK_TREE_MODEL(store));
1497
1498 gtk_drag_dest_set(combo_box, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, te,
1499 sizeof(te) / sizeof(GtkTargetEntry) , GDK_ACTION_COPY | GDK_ACTION_MOVE);
1500
1501 g_signal_connect(G_OBJECT(combo_box), "drag_data_received", G_CALLBACK(theme_dnd_recv), (gpointer) type);
1502 }
1503
1504 /* sets the current sound theme */
1505 static void
1506 prefs_set_sound_theme_cb(GtkComboBox *combo_box, gpointer user_data)
1507 {
1508 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(user_data);
1509 gint i;
1510 gchar *pref;
1511 gchar *new_theme;
1512 GtkTreeIter new_iter;
1513
1514 if(gtk_combo_box_get_active_iter(combo_box, &new_iter) && !prefs_sound_themes_loading) {
1515
1516 gtk_tree_model_get(GTK_TREE_MODEL(prefs_sound_themes), &new_iter, 2, &new_theme, -1);
1517
1518 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/sound/theme", new_theme);
1519
1520 /* New theme removes all customization */
1521 for(i = 0; i < PURPLE_NUM_SOUNDS; i++){
1522 pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s",
1523 pidgin_sound_get_event_option(i));
1524 purple_prefs_set_path(pref, "");
1525 g_free(pref);
1526 }
1527
1528 /* gets rid of the "(Custom)" from the last selection */
1529 pref_sound_generate_markup();
1530
1531 gtk_entry_set_text(GTK_ENTRY(win->sound.entry), _("(default)"));
1532
1533 g_free(new_theme);
1534 }
1535 }
1536
1537 /* sets the current smiley theme */
1538 static void
1539 prefs_set_smiley_theme_cb(GtkComboBox *combo_box, gpointer user_data)
1540 {
1541 gchar *new_theme;
1542 GtkTreeIter new_iter;
1543
1544 if (gtk_combo_box_get_active_iter(combo_box, &new_iter)) {
1545
1546 gtk_tree_model_get(GTK_TREE_MODEL(prefs_smiley_themes), &new_iter, 2, &new_theme, -1);
1547
1548 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/smileys/theme", new_theme);
1549
1550 g_free(new_theme);
1551 }
1552 }
1553
1554
1555 /* Does same as normal sort, except "none" is sorted first */
1556 static gint pidgin_sort_smileys (GtkTreeModel *model,
1557 GtkTreeIter *a,
1558 GtkTreeIter *b,
1559 gpointer userdata)
1560 {
1561 gint ret = 0;
1562 gchar *name1 = NULL, *name2 = NULL;
1563
1564 gtk_tree_model_get(model, a, 2, &name1, -1);
1565 gtk_tree_model_get(model, b, 2, &name2, -1);
1566
1567 if (name1 == NULL || name2 == NULL) {
1568 if (!(name1 == NULL && name2 == NULL))
1569 ret = (name1 == NULL) ? -1: 1;
1570 } else if (!g_ascii_strcasecmp(name1, "none")) {
1571 if (!g_utf8_collate(name1, name2))
1572 ret = 0;
1573 else
1574 /* Sort name1 first */
1575 ret = -1;
1576 } else if (!g_ascii_strcasecmp(name2, "none")) {
1577 /* Sort name2 first */
1578 ret = 1;
1579 } else {
1580 /* Neither string is "none", default to normal sort */
1581 ret = purple_utf8_strcasecmp(name1, name2);
1582 }
1583
1584 g_free(name1);
1585 g_free(name2);
1586
1587 return ret;
1588 }
1589
1590 /* sets the current buddy list theme */
1591 static void
1592 prefs_set_blist_theme_cb(GtkComboBox *combo_box, gpointer user_data)
1593 {
1594 PidginBlistTheme *theme = NULL;
1595 GtkTreeIter iter;
1596 gchar *name = NULL;
1597
1598 if(gtk_combo_box_get_active_iter(combo_box, &iter)) {
1599
1600 gtk_tree_model_get(GTK_TREE_MODEL(prefs_blist_themes), &iter, 2, &name, -1);
1601
1602 if(!name || *name)
1603 theme = PIDGIN_BLIST_THEME(purple_theme_manager_find_theme(name, "blist"));
1604
1605 g_free(name);
1606
1607 pidgin_blist_set_theme(theme);
1608 }
1609 }
1610
1611 /* sets the current icon theme */
1612 static void
1613 prefs_set_status_icon_theme_cb(GtkComboBox *combo_box, gpointer user_data)
1614 {
1615 PidginStatusIconTheme *theme = NULL;
1616 GtkTreeIter iter;
1617 gchar *name = NULL;
1618
1619 if(gtk_combo_box_get_active_iter(combo_box, &iter)) {
1620
1621 gtk_tree_model_get(GTK_TREE_MODEL(prefs_status_icon_themes), &iter, 2, &name, -1);
1622
1623 if(!name || *name)
1624 theme = PIDGIN_STATUS_ICON_THEME(purple_theme_manager_find_theme(name, "status-icon"));
1625
1626 g_free(name);
1627
1628 pidgin_stock_load_status_icon_theme(theme);
1629 pidgin_blist_refresh(purple_blist_get_default());
1630 }
1631 }
1632
1633 static void
1634 bind_theme_page(PidginPrefsWindow *win)
1635 {
1636 /* Buddy List Themes */
1637 prefs_build_theme_combo_box(win->theme.blist, prefs_blist_themes,
1638 PIDGIN_PREFS_ROOT "/blist/theme", "blist");
1639 prefs_blist_themes_combo_box = win->theme.blist;
1640
1641 /* Status Icon Themes */
1642 prefs_build_theme_combo_box(win->theme.status, prefs_status_icon_themes,
1643 PIDGIN_PREFS_ROOT "/status/icon-theme",
1644 "icon");
1645 prefs_status_themes_combo_box = win->theme.status;
1646
1647 /* Sound Themes */
1648 prefs_build_theme_combo_box(win->theme.sound, prefs_sound_themes,
1649 PIDGIN_PREFS_ROOT "/sound/theme", "sound");
1650 prefs_sound_themes_combo_box = win->theme.sound;
1651
1652 /* Smiley Themes */
1653 prefs_build_theme_combo_box(win->theme.smiley, prefs_smiley_themes,
1654 PIDGIN_PREFS_ROOT "/smileys/theme",
1655 "smiley");
1656 prefs_smiley_themes_combo_box = win->theme.smiley;
1657
1658 /* Custom sort so "none" theme is at top of list */
1659 gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(prefs_smiley_themes),
1660 2, pidgin_sort_smileys, NULL, NULL);
1661 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(prefs_smiley_themes),
1662 2, GTK_SORT_ASCENDING);
1663 }
1664
1665 static void
1666 formatting_toggle_cb(TalkatuActionGroup *ag, GAction *action, const gchar *name, gpointer data)
1667 {
1668 gboolean activated = talkatu_action_group_get_action_activated(ag, name);
1669 if(g_ascii_strcasecmp(TALKATU_ACTION_FORMAT_BOLD, name) != 0) {
1670 purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold",
1671 activated);
1672 } else if(g_ascii_strcasecmp(TALKATU_ACTION_FORMAT_ITALIC, name) != 0) {
1673 purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic",
1674 activated);
1675 } else if(g_ascii_strcasecmp(TALKATU_ACTION_FORMAT_UNDERLINE, name) != 0) {
1676 purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline",
1677 activated);
1678 } else if(g_ascii_strcasecmp(TALKATU_ACTION_FORMAT_STRIKETHROUGH, name) != 0) {
1679 purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike",
1680 activated);
1681 }
1682 }
1683
1684 static void
1685 bind_interface_page(PidginPrefsWindow *win)
1686 {
1687 GList *names = NULL;
1688
1689 /* System Tray */
1690 win->iface.docklet.type = PURPLE_PREF_STRING;
1691 win->iface.docklet.key = PIDGIN_PREFS_ROOT "/docklet/show";
1692 pidgin_prefs_bind_dropdown(&win->iface.docklet);
1693
1694 win->iface.im.hide_new.type = PURPLE_PREF_STRING;
1695 win->iface.im.hide_new.key = PIDGIN_PREFS_ROOT "/conversations/im/hide_new";
1696 pidgin_prefs_bind_dropdown(&win->iface.im.hide_new);
1697
1698 #ifdef _WIN32
1699 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/win32/minimize_new_convs",
1700 win->iface.win32.minimize_new_convs);
1701 #else
1702 gtk_widget_hide(win->iface.win32.minimize_new_convs);
1703 #endif
1704
1705 /* All the tab options! */
1706 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/conversations/tabs",
1707 win->iface.conversations.tabs);
1708
1709 /*
1710 * Connect a signal to the above preference. When conversations are not
1711 * shown in a tabbed window then all tabbing options should be disabled.
1712 */
1713 g_object_bind_property(win->iface.conversations.tabs, "active",
1714 win->iface.conversations.tabs_vbox, "sensitive",
1715 G_BINDING_SYNC_CREATE);
1716
1717 pidgin_prefs_bind_checkbox(
1718 PIDGIN_PREFS_ROOT "/conversations/close_on_tabs",
1719 win->iface.conversations.close_on_tabs);
1720
1721 win->iface.conversations.tab_side.type = PURPLE_PREF_INT;
1722 win->iface.conversations.tab_side.key = PIDGIN_PREFS_ROOT "/conversations/tab_side";
1723 pidgin_prefs_bind_dropdown(&win->iface.conversations.tab_side);
1724
1725 win->iface.conversations.placement.type = PURPLE_PREF_STRING;
1726 win->iface.conversations.placement.key = PIDGIN_PREFS_ROOT "/conversations/placement";
1727 names = pidgin_conv_placement_get_options();
1728 pidgin_prefs_bind_dropdown_from_list(
1729 &win->iface.conversations.placement,
1730 names);
1731 g_list_free(names);
1732 }
1733
1734 /* This is also Win32-specific, but must be visible for Glade binding. */
1735 static void
1736 apply_custom_font(GtkWidget *unused, PidginPrefsWindow *win)
1737 {
1738 PangoFontDescription *desc = NULL;
1739 if (!purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/use_theme_font")) {
1740 const char *font = purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/custom_font");
1741 desc = pango_font_description_from_string(font);
1742 }
1743
1744 gtk_widget_override_font(win->conversations.format_view, desc);
1745 if (desc)
1746 pango_font_description_free(desc);
1747
1748 }
1749
1750 static void
1751 pidgin_custom_font_set(GtkWidget *font_button, PidginPrefsWindow *win)
1752 {
1753
1754 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/custom_font",
1755 gtk_font_chooser_get_font(GTK_FONT_CHOOSER(font_button)));
1756
1757 apply_custom_font(font_button, win);
1758 }
1759
1760 static void
1761 bind_conv_page(PidginPrefsWindow *win)
1762 {
1763 GSimpleActionGroup *ag = NULL;
1764
1765 win->conversations.notification_chat.type = PURPLE_PREF_INT;
1766 win->conversations.notification_chat.key = PIDGIN_PREFS_ROOT "/conversations/notification_chat";
1767 pidgin_prefs_bind_dropdown(&win->conversations.notification_chat);
1768
1769 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/conversations/show_incoming_formatting",
1770 win->conversations.show_incoming_formatting);
1771 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/conversations/im/close_immediately",
1772 win->conversations.im.close_immediately);
1773
1774 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/conversations/im/show_buddy_icons",
1775 win->conversations.im.show_buddy_icons);
1776 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/conversations/im/animate_buddy_icons",
1777 win->conversations.im.animate_buddy_icons);
1778 g_object_bind_property(win->conversations.im.show_buddy_icons, "active",
1779 win->conversations.im.animate_buddy_icons, "sensitive",
1780 G_BINDING_SYNC_CREATE);
1781
1782 pidgin_prefs_bind_checkbox("/purple/conversations/im/send_typing",
1783 win->conversations.im.send_typing);
1784 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/conversations/spellcheck",
1785 win->conversations.spellcheck);
1786
1787 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/conversations/use_smooth_scrolling",
1788 win->conversations.use_smooth_scrolling);
1789
1790 #ifdef _WIN32
1791 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/win32/blink_im",
1792 win->conversations.win32.blink_im);
1793 #else
1794 gtk_widget_hide(win->conversations.win32.blink_im);
1795 #endif
1796
1797 #if 0
1798 /* TODO: it's not implemented */
1799 pidgin_prefs_bind_checkbox(
1800 PIDGIN_PREFS_ROOT "/conversations/resize_custom_smileys",
1801 win->conversations.resize_custom_smileys);
1802
1803 pidgin_prefs_bind_spin_button(
1804 PIDGIN_PREFS_ROOT "/conversations/custom_smileys_size",
1805 win->conversations.custom_smileys_size);
1806
1807 g_object_bind_property(win->conversations.resize_custom_smileys, "active",
1808 win->conversations.custom_smileys_size, "sensitive",
1809 G_BINDING_SYNC_CREATE);
1810 #endif
1811
1812 pidgin_prefs_bind_spin_button(
1813 PIDGIN_PREFS_ROOT "/conversations/minimum_entry_lines",
1814 win->conversations.minimum_entry_lines);
1815
1816 #ifdef _WIN32
1817 {
1818 const char *font_name;
1819 gtk_widget_show(win->conversations.font_frame);
1820
1821 pidgin_prefs_bind_checkbox(
1822 PIDGIN_PREFS_ROOT "/conversations/use_theme_font",
1823 win->conversations.use_theme_font);
1824
1825 font_name = purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/custom_font");
1826 if (font_name != NULL && *font_name != '\0') {
1827 gtk_font_chooser_set_font(
1828 GTK_FONT_CHOOSER(win->conversations.custom_font),
1829 font_name);
1830 }
1831
1832 g_object_bind_property(win->conversations.use_theme_font, "active",
1833 win->conversations.custom_font_hbox, "sensitive",
1834 G_BINDING_SYNC_CREATE|G_BINDING_INVERT_BOOLEAN);
1835 }
1836 #endif
1837
1838 ag = talkatu_buffer_get_action_group(TALKATU_BUFFER(win->conversations.format_buffer));
1839 g_signal_connect_after(G_OBJECT(ag), "action-activated",
1840 G_CALLBACK(formatting_toggle_cb), NULL);
1841 }
1842
1843 static void
1844 network_ip_changed(GtkEntry *entry, gpointer data)
1845 {
1846 const gchar *text = gtk_entry_get_text(entry);
1847 GtkStyleContext *context = gtk_widget_get_style_context(GTK_WIDGET(entry));
1848
1849 if (text && *text) {
1850 if (g_hostname_is_ip_address(text)) {
1851 purple_network_set_public_ip(text);
1852 gtk_style_context_add_class(context, "good-ip");
1853 gtk_style_context_remove_class(context, "bad-ip");
1854 } else {
1855 gtk_style_context_add_class(context, "bad-ip");
1856 gtk_style_context_remove_class(context, "good-ip");
1857 }
1858
1859 } else {
1860 purple_network_set_public_ip("");
1861 gtk_style_context_remove_class(context, "bad-ip");
1862 gtk_style_context_remove_class(context, "good-ip");
1863 }
1864 }
1865
1866 static gboolean
1867 network_stun_server_changed_cb(GtkWidget *widget,
1868 GdkEventFocus *event, gpointer data)
1869 {
1870 GtkEntry *entry = GTK_ENTRY(widget);
1871 purple_prefs_set_string("/purple/network/stun_server",
1872 gtk_entry_get_text(entry));
1873 purple_network_set_stun_server(gtk_entry_get_text(entry));
1874
1875 return FALSE;
1876 }
1877
1878 static gboolean
1879 network_turn_server_changed_cb(GtkWidget *widget,
1880 GdkEventFocus *event, gpointer data)
1881 {
1882 GtkEntry *entry = GTK_ENTRY(widget);
1883 purple_prefs_set_string("/purple/network/turn_server",
1884 gtk_entry_get_text(entry));
1885 purple_network_set_turn_server(gtk_entry_get_text(entry));
1886
1887 return FALSE;
1888 }
1889
1890 static void
1891 proxy_changed_cb(const char *name, PurplePrefType type,
1892 gconstpointer value, gpointer data)
1893 {
1894 PidginPrefsWindow *win = data;
1895 const char *proxy = value;
1896
1897 if (!purple_strequal(proxy, "none") && !purple_strequal(proxy, "envvar"))
1898 gtk_widget_show_all(win->proxy.options);
1899 else
1900 gtk_widget_hide(win->proxy.options);
1901 }
1902
1903 static void
1904 proxy_print_option(GtkWidget *entry, PidginPrefsWindow *win)
1905 {
1906 if (entry == win->proxy.host) {
1907 purple_prefs_set_string("/purple/proxy/host",
1908 gtk_entry_get_text(GTK_ENTRY(entry)));
1909 } else if (entry == win->proxy.port) {
1910 purple_prefs_set_int("/purple/proxy/port",
1911 gtk_spin_button_get_value_as_int(
1912 GTK_SPIN_BUTTON(entry)));
1913 } else if (entry == win->proxy.username) {
1914 purple_prefs_set_string("/purple/proxy/username",
1915 gtk_entry_get_text(GTK_ENTRY(entry)));
1916 } else if (entry == win->proxy.password) {
1917 purple_prefs_set_string("/purple/proxy/password",
1918 gtk_entry_get_text(GTK_ENTRY(entry)));
1919 }
1920 }
1921
1922 static void
1923 proxy_button_clicked_cb(GtkWidget *button, PidginPrefsWindow *win)
1924 {
1925 GError *err = NULL;
1926
1927 if (g_spawn_command_line_async(win->proxy.gnome_program_path, &err))
1928 return;
1929
1930 purple_notify_error(NULL, NULL, _("Cannot start proxy configuration program."), err->message, NULL);
1931 g_error_free(err);
1932 }
1933
1934 static void
1935 browser_button_clicked_cb(GtkWidget *button, PidginPrefsWindow *win)
1936 {
1937 GError *err = NULL;
1938
1939 if (g_spawn_command_line_async(win->browser.gnome_program_path, &err))
1940 return;
1941
1942 purple_notify_error(NULL, NULL, _("Cannot start browser configuration program."), err->message, NULL);
1943 g_error_free(err);
1944 }
1945
1946 static void
1947 auto_ip_button_clicked_cb(GtkWidget *button, gpointer null)
1948 {
1949 const char *ip;
1950 PurpleStunNatDiscovery *stun;
1951 char *auto_ip_text;
1952
1953 /* purple_network_get_my_ip will return the IP that was set by the user with
1954 purple_network_set_public_ip, so make a lookup for the auto-detected IP
1955 ourselves. */
1956
1957 if (purple_prefs_get_bool("/purple/network/auto_ip")) {
1958 /* Check if STUN discovery was already done */
1959 stun = purple_stun_discover(NULL);
1960 if ((stun != NULL) && (stun->status == PURPLE_STUN_STATUS_DISCOVERED)) {
1961 ip = stun->publicip;
1962 } else {
1963 /* Attempt to get the IP from a NAT device using UPnP */
1964 ip = purple_upnp_get_public_ip();
1965 if (ip == NULL) {
1966 /* Attempt to get the IP from a NAT device using NAT-PMP */
1967 ip = purple_pmp_get_public_ip();
1968 if (ip == NULL) {
1969 /* Just fetch the IP of the local system */
1970 ip = purple_network_get_local_system_ip(-1);
1971 }
1972 }
1973 }
1974 }
1975 else
1976 ip = _("Disabled");
1977
1978 auto_ip_text = g_strdup_printf(_("Use _automatically detected IP address: %s"), ip);
1979 gtk_button_set_label(GTK_BUTTON(button), auto_ip_text);
1980 g_free(auto_ip_text);
1981 }
1982
1983 static void
1984 bind_network_page(PidginPrefsWindow *win)
1985 {
1986 GtkStyleContext *context;
1987 GtkCssProvider *ip_css;
1988 const gchar ip_style[] =
1989 ".bad-ip {"
1990 "color: @error_fg_color;"
1991 "text-shadow: 0 1px @error_text_shadow;"
1992 "background-image: none;"
1993 "background-color: @error_bg_color;"
1994 "}"
1995 ".good-ip {"
1996 "color: @question_fg_color;"
1997 "text-shadow: 0 1px @question_text_shadow;"
1998 "background-image: none;"
1999 "background-color: @success_color;"
2000 "}";
2001
2002 gtk_entry_set_text(GTK_ENTRY(win->network.stun_server),
2003 purple_prefs_get_string("/purple/network/stun_server"));
2004
2005 pidgin_prefs_bind_checkbox("/purple/network/auto_ip",
2006 win->network.auto_ip);
2007 auto_ip_button_clicked_cb(win->network.auto_ip, NULL); /* Update label */
2008
2009 gtk_entry_set_text(GTK_ENTRY(win->network.public_ip),
2010 purple_network_get_public_ip());
2011
2012 ip_css = gtk_css_provider_new();
2013 gtk_css_provider_load_from_data(ip_css, ip_style, -1, NULL);
2014 context = gtk_widget_get_style_context(win->network.public_ip);
2015 gtk_style_context_add_provider(context,
2016 GTK_STYLE_PROVIDER(ip_css),
2017 GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
2018
2019 g_object_bind_property(win->network.auto_ip, "active",
2020 win->network.public_ip_hbox, "sensitive",
2021 G_BINDING_SYNC_CREATE|G_BINDING_INVERT_BOOLEAN);
2022
2023 pidgin_prefs_bind_checkbox("/purple/network/map_ports",
2024 win->network.map_ports);
2025
2026 pidgin_prefs_bind_checkbox("/purple/network/ports_range_use",
2027 win->network.ports_range_use);
2028 g_object_bind_property(win->network.ports_range_use, "active",
2029 win->network.ports_range_hbox, "sensitive",
2030 G_BINDING_SYNC_CREATE);
2031
2032 pidgin_prefs_bind_spin_button("/purple/network/ports_range_start",
2033 win->network.ports_range_start);
2034 pidgin_prefs_bind_spin_button("/purple/network/ports_range_end",
2035 win->network.ports_range_end);
2036
2037 /* TURN server */
2038 gtk_entry_set_text(GTK_ENTRY(win->network.turn_server),
2039 purple_prefs_get_string("/purple/network/turn_server"));
2040
2041 pidgin_prefs_bind_spin_button("/purple/network/turn_port",
2042 win->network.turn_port_udp);
2043
2044 pidgin_prefs_bind_spin_button("/purple/network/turn_port_tcp",
2045 win->network.turn_port_tcp);
2046
2047 pidgin_prefs_bind_entry("/purple/network/turn_username",
2048 win->network.turn_username);
2049 pidgin_prefs_bind_entry("/purple/network/turn_password",
2050 win->network.turn_password);
2051 }
2052
2053 static gboolean
2054 manual_browser_set(GtkWidget *entry, GdkEventFocus *event, gpointer data)
2055 {
2056 const char *program = gtk_entry_get_text(GTK_ENTRY(entry));
2057
2058 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/browsers/manual_command", program);
2059
2060 /* carry on normally */
2061 return FALSE;
2062 }
2063
2064 #ifndef _WIN32
2065 static GList *
2066 get_available_browsers(void)
2067 {
2068 struct browser {
2069 char *name;
2070 char *command;
2071 };
2072
2073 /* Sorted reverse alphabetically */
2074 static const struct browser possible_browsers[] = {
2075 {N_("Seamonkey"), "seamonkey"},
2076 {N_("Opera"), "opera"},
2077 {N_("Mozilla"), "mozilla"},
2078 {N_("Konqueror"), "kfmclient"},
2079 {N_("Google Chrome"), "google-chrome"},
2080 /* Do not move the line below. Code below expects gnome-open to be in
2081 * this list immediately after xdg-open! */
2082 {N_("Desktop Default"), "xdg-open"},
2083 {N_("GNOME Default"), "gnome-open"},
2084 {N_("Galeon"), "galeon"},
2085 {N_("Firefox"), "firefox"},
2086 {N_("Firebird"), "mozilla-firebird"},
2087 {N_("Epiphany"), "epiphany"},
2088 /* Translators: please do not translate "chromium-browser" here! */
2089 {N_("Chromium (chromium-browser)"), "chromium-browser"},
2090 /* Translators: please do not translate "chrome" here! */
2091 {N_("Chromium (chrome)"), "chrome"}
2092 };
2093 static const int num_possible_browsers = G_N_ELEMENTS(possible_browsers);
2094
2095 GList *browsers = NULL;
2096 int i = 0;
2097 char *browser_setting = (char *)purple_prefs_get_string(PIDGIN_PREFS_ROOT "/browsers/browser");
2098
2099 browsers = g_list_prepend(browsers, (gpointer)"custom");
2100 browsers = g_list_prepend(browsers, (gpointer)_("Manual"));
2101
2102 for (i = 0; i < num_possible_browsers; i++) {
2103 if (purple_program_is_valid(possible_browsers[i].command)) {
2104 browsers = g_list_prepend(browsers,
2105 possible_browsers[i].command);
2106 browsers = g_list_prepend(browsers, (gpointer)_(possible_browsers[i].name));
2107 if(browser_setting && purple_strequal(possible_browsers[i].command, browser_setting))
2108 browser_setting = NULL;
2109 /* If xdg-open is valid, prefer it over gnome-open and skip forward */
2110 if(purple_strequal(possible_browsers[i].command, "xdg-open")) {
2111 if (purple_strequal("gnome-open", browser_setting)) {
2112 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/browsers/browser", possible_browsers[i].command);
2113 browser_setting = NULL;
2114 }
2115 i++;
2116 }
2117 }
2118 }
2119
2120 if(browser_setting)
2121 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/browsers/browser", "custom");
2122
2123 return browsers;
2124 }
2125
2126 static void
2127 browser_changed1_cb(const char *name, PurplePrefType type,
2128 gconstpointer value, gpointer data)
2129 {
2130 GtkWidget *hbox = data;
2131 const char *browser = value;
2132
2133 gtk_widget_set_sensitive(hbox, !purple_strequal(browser, "custom"));
2134 }
2135
2136 static void
2137 browser_changed2_cb(const char *name, PurplePrefType type,
2138 gconstpointer value, gpointer data)
2139 {
2140 GtkWidget *hbox = data;
2141 const char *browser = value;
2142
2143 gtk_widget_set_sensitive(hbox, purple_strequal(browser, "custom"));
2144 }
2145 #endif /* _WIN32 */
2146
2147 static void
2148 bind_browser_page(PidginPrefsWindow *win)
2149 {
2150 #ifdef _WIN32
2151 /* We use the registered default browser in windows */
2152 gtk_widget_hide(win->browser.page);
2153 return;
2154 #else
2155 /* if the user is running Mac OS X, hide the browsers tab */
2156 if (purple_running_osx()) {
2157 gtk_widget_hide(win->browser.page);
2158 } else if (purple_running_gnome()) {
2159 gchar *path;
2160
2161 gtk_stack_set_visible_child_name(GTK_STACK(win->browser.stack),
2162 "gnome");
2163
2164 path = g_find_program_in_path("gnome-control-center");
2165 if (path != NULL) {
2166 gchar *tmp = g_strdup_printf("%s info", path);
2167 g_free(path);
2168 path = tmp;
2169 } else {
2170 path = g_find_program_in_path("gnome-default-applications-properties");
2171 }
2172
2173 win->browser.gnome_program_path = path;
2174 gtk_widget_set_visible(win->browser.gnome_not_found,
2175 path == NULL);
2176 gtk_widget_set_visible(win->browser.gnome_program,
2177 path != NULL);
2178 } else {
2179 GList *browsers = NULL;
2180
2181 gtk_stack_set_visible_child_name(GTK_STACK(win->browser.stack),
2182 "nongnome");
2183
2184 win->browser.browser.type = PURPLE_PREF_STRING;
2185 win->browser.browser.key = PIDGIN_PREFS_ROOT "/browsers/browser";
2186 browsers = get_available_browsers();
2187 pidgin_prefs_bind_dropdown_from_list(
2188 &win->browser.browser,
2189 browsers);
2190 g_list_free(browsers);
2191
2192 win->browser.place.type = PURPLE_PREF_INT;
2193 win->browser.place.key = PIDGIN_PREFS_ROOT "/browsers/place";
2194 pidgin_prefs_bind_dropdown(&win->browser.place);
2195
2196 purple_prefs_connect_callback(prefs,
2197 PIDGIN_PREFS_ROOT "/browsers/browser",
2198 browser_changed1_cb,
2199 win->browser.place_hbox);
2200
2201 gtk_entry_set_text(GTK_ENTRY(win->browser.manual_command),
2202 purple_prefs_get_string(PIDGIN_PREFS_ROOT "/browsers/manual_command"));
2203 purple_prefs_connect_callback(prefs,
2204 PIDGIN_PREFS_ROOT "/browsers/browser",
2205 browser_changed2_cb,
2206 win->browser.manual_command_hbox);
2207
2208 if (purple_strequal(
2209 purple_prefs_get_string(
2210 PIDGIN_PREFS_ROOT "/browsers/browser"),
2211 "custom")) {
2212 gtk_widget_set_sensitive(win->browser.place_hbox,
2213 FALSE);
2214 } else {
2215 gtk_widget_set_sensitive(win->browser.manual_command_hbox,
2216 FALSE);
2217 }
2218 }
2219 #endif /* _WIN32 */
2220 }
2221
2222 static void
2223 bind_proxy_page(PidginPrefsWindow *win)
2224 {
2225 PurpleProxyInfo *proxy_info;
2226
2227 if(purple_running_gnome()) {
2228 gchar *path = NULL;
2229
2230 gtk_stack_set_visible_child_name(GTK_STACK(win->proxy.stack),
2231 "gnome");
2232
2233 path = g_find_program_in_path("gnome-network-properties");
2234 if (path == NULL)
2235 path = g_find_program_in_path("gnome-network-preferences");
2236 if (path == NULL) {
2237 path = g_find_program_in_path("gnome-control-center");
2238 if (path != NULL) {
2239 char *tmp = g_strdup_printf("%s network", path);
2240 g_free(path);
2241 path = tmp;
2242 }
2243 }
2244
2245 win->proxy.gnome_program_path = path;
2246 gtk_widget_set_visible(win->proxy.gnome_not_found,
2247 path == NULL);
2248 gtk_widget_set_visible(win->proxy.gnome_program,
2249 path != NULL);
2250 } else {
2251 gtk_stack_set_visible_child_name(GTK_STACK(win->proxy.stack),
2252 "nongnome");
2253
2254 /* This is a global option that affects SOCKS4 usage even with
2255 * account-specific proxy settings */
2256 pidgin_prefs_bind_checkbox("/purple/proxy/socks4_remotedns",
2257 win->proxy.socks4_remotedns);
2258
2259 win->proxy.type.type = PURPLE_PREF_STRING;
2260 win->proxy.type.key = "/purple/proxy/type";
2261 pidgin_prefs_bind_dropdown(&win->proxy.type);
2262 proxy_info = purple_global_proxy_get_info();
2263
2264 purple_prefs_connect_callback(prefs, "/purple/proxy/type",
2265 proxy_changed_cb, win);
2266
2267 if (proxy_info != NULL) {
2268 if (purple_proxy_info_get_host(proxy_info)) {
2269 gtk_entry_set_text(GTK_ENTRY(win->proxy.host),
2270 purple_proxy_info_get_host(proxy_info));
2271 }
2272
2273 if (purple_proxy_info_get_port(proxy_info) != 0) {
2274 gtk_spin_button_set_value(
2275 GTK_SPIN_BUTTON(win->proxy.port),
2276 purple_proxy_info_get_port(proxy_info));
2277 }
2278
2279 if (purple_proxy_info_get_username(proxy_info) != NULL) {
2280 gtk_entry_set_text(GTK_ENTRY(win->proxy.username),
2281 purple_proxy_info_get_username(proxy_info));
2282 }
2283
2284 if (purple_proxy_info_get_password(proxy_info) != NULL) {
2285 gtk_entry_set_text(GTK_ENTRY(win->proxy.password),
2286 purple_proxy_info_get_password(proxy_info));
2287 }
2288 }
2289
2290 proxy_changed_cb("/purple/proxy/type", PURPLE_PREF_STRING,
2291 purple_prefs_get_string("/purple/proxy/type"),
2292 win);
2293 }
2294 }
2295
2296 static void
2297 bind_logging_page(PidginPrefsWindow *win)
2298 {
2299 GList *names;
2300
2301 win->logging.format.type = PURPLE_PREF_STRING;
2302 win->logging.format.key = "/purple/logging/format";
2303 names = purple_log_logger_get_options();
2304 pidgin_prefs_bind_dropdown_from_list(&win->logging.format, names);
2305 g_list_free(names);
2306
2307 pidgin_prefs_bind_checkbox("/purple/logging/log_ims",
2308 win->logging.log_ims);
2309 pidgin_prefs_bind_checkbox("/purple/logging/log_chats",
2310 win->logging.log_chats);
2311 pidgin_prefs_bind_checkbox("/purple/logging/log_system",
2312 win->logging.log_system);
2313 }
2314
2315 /*** keyring page *******************************************************/
2316
2317 static void
2318 keyring_page_settings_changed(GtkWidget *widget, gpointer _setting)
2319 {
2320 PurpleRequestField *setting = _setting;
2321 PurpleRequestFieldType field_type;
2322
2323 gtk_widget_set_sensitive(prefs->keyring.apply, TRUE);
2324
2325 field_type = purple_request_field_get_field_type(setting);
2326
2327 if (field_type == PURPLE_REQUEST_FIELD_BOOLEAN) {
2328 purple_request_field_bool_set_value(setting,
2329 gtk_toggle_button_get_active(
2330 GTK_TOGGLE_BUTTON(widget)));
2331 } else if (field_type == PURPLE_REQUEST_FIELD_STRING) {
2332 purple_request_field_string_set_value(setting,
2333 gtk_entry_get_text(GTK_ENTRY(widget)));
2334 } else if (field_type == PURPLE_REQUEST_FIELD_INTEGER) {
2335 purple_request_field_int_set_value(setting,
2336 gtk_spin_button_get_value_as_int(
2337 GTK_SPIN_BUTTON(widget)));
2338 } else
2339 g_return_if_reached();
2340 }
2341
2342 static void
2343 keyring_page_add_settings_field(GtkBox *vbox, PurpleRequestField *setting,
2344 GtkSizeGroup *sg)
2345 {
2346 GtkWidget *widget;
2347 PurpleRequestFieldType field_type;
2348 const gchar *label;
2349
2350 label = purple_request_field_get_label(setting);
2351
2352 field_type = purple_request_field_get_field_type(setting);
2353 if (field_type == PURPLE_REQUEST_FIELD_BOOLEAN) {
2354 widget = gtk_check_button_new_with_label(label);
2355 label = NULL;
2356 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),
2357 purple_request_field_bool_get_value(setting));
2358 g_signal_connect(G_OBJECT(widget), "toggled",
2359 G_CALLBACK(keyring_page_settings_changed), setting);
2360 } else if (field_type == PURPLE_REQUEST_FIELD_STRING) {
2361 widget = gtk_entry_new();
2362 gtk_entry_set_text(GTK_ENTRY(widget),
2363 purple_request_field_string_get_value(setting));
2364 if (purple_request_field_string_is_masked(setting))
2365 gtk_entry_set_visibility(GTK_ENTRY(widget), FALSE);
2366 g_signal_connect(G_OBJECT(widget), "changed",
2367 G_CALLBACK(keyring_page_settings_changed), setting);
2368 } else if (field_type == PURPLE_REQUEST_FIELD_INTEGER) {
2369 widget = gtk_spin_button_new_with_range(
2370 purple_request_field_int_get_lower_bound(setting),
2371 purple_request_field_int_get_upper_bound(setting), 1);
2372 gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),
2373 purple_request_field_int_get_value(setting));
2374 g_signal_connect(G_OBJECT(widget), "value-changed",
2375 G_CALLBACK(keyring_page_settings_changed), setting);
2376 } else {
2377 purple_debug_error("gtkprefs", "Unsupported field type\n");
2378 return;
2379 }
2380
2381 pidgin_add_widget_to_vbox(vbox, label, sg, widget, FALSE, NULL);
2382 }
2383
2384 /* XXX: it could be available for all plugins, not keyrings only */
2385 static void
2386 keyring_page_add_settings(PidginPrefsWindow *win)
2387 {
2388 GtkWidget *box;
2389 GList *it, *groups;
2390 GtkSizeGroup *sg;
2391
2392 box = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
2393 gtk_box_pack_start(GTK_BOX(win->keyring.vbox), box, FALSE, FALSE, 0);
2394
2395 sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
2396
2397 groups = purple_request_fields_get_groups(win->keyring.settings);
2398 for (it = g_list_first(groups); it != NULL; it = g_list_next(it)) {
2399 GList *it2, *fields;
2400 GtkBox *vbox;
2401 PurpleRequestFieldGroup *group;
2402 const gchar *group_title;
2403
2404 group = it->data;
2405 group_title = purple_request_field_group_get_title(group);
2406 if (group_title) {
2407 vbox = GTK_BOX(pidgin_make_frame(box, group_title));
2408 } else {
2409 vbox = GTK_BOX(box);
2410 }
2411
2412 fields = purple_request_field_group_get_fields(group);
2413 for (it2 = g_list_first(fields); it2 != NULL;
2414 it2 = g_list_next(it2)) {
2415 keyring_page_add_settings_field(vbox, it2->data, sg);
2416 }
2417 }
2418
2419 g_object_unref(sg);
2420
2421 win->keyring.settings_box = box;
2422 }
2423
2424 static void
2425 keyring_page_settings_apply(GtkButton *button, gpointer data)
2426 {
2427 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
2428
2429 if (!purple_keyring_apply_settings(win, win->keyring.settings)) {
2430 return;
2431 }
2432
2433 gtk_widget_set_sensitive(win->keyring.apply, FALSE);
2434 }
2435
2436 static void
2437 keyring_page_update_settings(PidginPrefsWindow *win)
2438 {
2439 g_clear_pointer(&win->keyring.settings, purple_request_fields_destroy);
2440 win->keyring.settings = purple_keyring_read_settings();
2441 if (!win->keyring.settings) {
2442 return;
2443 }
2444
2445 keyring_page_add_settings(win);
2446
2447 win->keyring.apply = gtk_button_new_with_mnemonic(_("_Apply"));
2448 gtk_box_pack_start(GTK_BOX(win->keyring.settings_box),
2449 win->keyring.apply, FALSE, FALSE, 1);
2450 gtk_widget_set_sensitive(win->keyring.apply, FALSE);
2451 g_signal_connect(G_OBJECT(win->keyring.apply), "clicked",
2452 G_CALLBACK(keyring_page_settings_apply), win);
2453
2454 gtk_widget_show_all(win->keyring.settings_box);
2455 }
2456
2457 static void
2458 keyring_page_pref_set_inuse(GError *error, G_GNUC_UNUSED gpointer unused)
2459 {
2460 PurpleKeyring *in_use = purple_keyring_get_inuse();
2461
2462 if (prefs == NULL) {
2463 purple_debug_info("gtkprefs", "pref window already closed\n");
2464 return;
2465 }
2466
2467 gtk_widget_set_sensitive(GTK_WIDGET(prefs->keyring.active.combo), TRUE);
2468
2469 if (error != NULL) {
2470 pidgin_prefs_bind_dropdown_revert_active(
2471 &prefs->keyring.active);
2472 purple_notify_error(NULL, _("Keyring"),
2473 _("Failed to set new keyring"), error->message, NULL);
2474 return;
2475 }
2476
2477 g_return_if_fail(in_use != NULL);
2478 purple_prefs_set_string("/purple/keyring/active",
2479 purple_keyring_get_id(in_use));
2480
2481 keyring_page_update_settings(prefs);
2482 }
2483
2484 static void
2485 keyring_page_pref_changed(GtkComboBox *combo_box, PidginPrefCombo *combo)
2486 {
2487 const char *keyring_id;
2488 PurpleKeyring *keyring;
2489
2490 g_return_if_fail(combo_box != NULL);
2491
2492 keyring_id = combo->value.string;
2493 keyring = purple_keyring_find_keyring_by_id(keyring_id);
2494 if (keyring == NULL) {
2495 pidgin_prefs_bind_dropdown_revert_active(combo);
2496 purple_notify_error(NULL, _("Keyring"),
2497 _("Selected keyring is disabled"), NULL, NULL);
2498 return;
2499 }
2500
2501 gtk_widget_set_sensitive(GTK_WIDGET(combo_box), FALSE);
2502
2503 g_clear_pointer(&prefs->keyring.settings_box, gtk_widget_destroy);
2504 g_clear_pointer(&prefs->keyring.settings,
2505 purple_request_fields_destroy);
2506
2507 purple_keyring_set_inuse(keyring, FALSE, keyring_page_pref_set_inuse,
2508 NULL);
2509 }
2510
2511 static void
2512 keyring_page_cleanup(PidginPrefsWindow *win)
2513 {
2514 g_clear_pointer(&win->keyring.settings, purple_request_fields_destroy);
2515 }
2516
2517 static void
2518 bind_keyring_page(PidginPrefsWindow *win)
2519 {
2520 GList *names;
2521
2522 /* Keyring selection */
2523 names = purple_keyring_get_options();
2524 win->keyring.active.type = PURPLE_PREF_STRING;
2525 win->keyring.active.key = "/purple/keyring/active";
2526 pidgin_prefs_bind_dropdown_from_list(&win->keyring.active, names);
2527 /* Override the usual callback to defer changing the pref. */
2528 win->keyring.active.cb = keyring_page_pref_changed;
2529 g_list_free(names);
2530
2531 keyring_page_update_settings(win);
2532 }
2533
2534 /*** keyring page - end *************************************************/
2535
2536 static gboolean
2537 sound_method_filter(GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
2538 {
2539 gboolean any = FALSE;
2540 gboolean gstreamer = FALSE;
2541 gboolean win32 = FALSE;
2542
2543 gtk_tree_model_get(model, iter, 2, &any, 3, &gstreamer, 4, &win32, -1);
2544
2545 if (any) {
2546 return TRUE;
2547 }
2548
2549 if (gstreamer) {
2550 #ifdef USE_GSTREAMER
2551 #ifdef _WIN32
2552 return win32;
2553 #else
2554 return !win32;
2555 #endif
2556 #else
2557 return FALSE;
2558 #endif
2559 }
2560
2561 #ifdef _WIN32
2562 return win32;
2563 #else
2564 return !win32;
2565 #endif
2566 }
2567
2568 static gint
2569 sound_cmd_yeah(GtkEntry *entry, gpointer d)
2570 {
2571 purple_prefs_set_path(PIDGIN_PREFS_ROOT "/sound/command",
2572 gtk_entry_get_text(GTK_ENTRY(entry)));
2573 return TRUE;
2574 }
2575
2576 static void
2577 sound_changed1_cb(const char *name, PurplePrefType type,
2578 gconstpointer value, gpointer data)
2579 {
2580 GtkWidget *hbox = data;
2581 const char *method = value;
2582
2583 gtk_widget_set_sensitive(hbox, purple_strequal(method, "custom"));
2584 }
2585
2586 static void
2587 sound_changed2_cb(const char *name, PurplePrefType type,
2588 gconstpointer value, gpointer data)
2589 {
2590 GtkWidget *vbox = data;
2591 const char *method = value;
2592
2593 gtk_widget_set_sensitive(vbox, !purple_strequal(method, "none"));
2594 }
2595
2596
2597 static void
2598 event_toggled(GtkCellRendererToggle *cell, gchar *pth, gpointer data)
2599 {
2600 GtkTreeModel *model = (GtkTreeModel *)data;
2601 GtkTreeIter iter;
2602 GtkTreePath *path = gtk_tree_path_new_from_string(pth);
2603 char *pref;
2604
2605 gtk_tree_model_get_iter (model, &iter, path);
2606 gtk_tree_model_get (model, &iter,
2607 2, &pref,
2608 -1);
2609
2610 purple_prefs_set_bool(pref, !gtk_cell_renderer_toggle_get_active(cell));
2611 g_free(pref);
2612
2613 gtk_list_store_set(GTK_LIST_STORE (model), &iter,
2614 0, !gtk_cell_renderer_toggle_get_active(cell),
2615 -1);
2616
2617 gtk_tree_path_free(path);
2618 }
2619
2620 static void
2621 test_sound(GtkWidget *button, gpointer i_am_NULL)
2622 {
2623 char *pref;
2624 gboolean temp_enabled;
2625 gboolean temp_mute;
2626
2627 pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/enabled/%s",
2628 pidgin_sound_get_event_option(sound_row_sel));
2629
2630 temp_enabled = purple_prefs_get_bool(pref);
2631 temp_mute = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/sound/mute");
2632
2633 if (!temp_enabled) purple_prefs_set_bool(pref, TRUE);
2634 if (temp_mute) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/sound/mute", FALSE);
2635
2636 purple_sound_play_event(sound_row_sel, NULL);
2637
2638 if (!temp_enabled) purple_prefs_set_bool(pref, FALSE);
2639 if (temp_mute) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/sound/mute", TRUE);
2640
2641 g_free(pref);
2642 }
2643
2644 /*
2645 * Resets a sound file back to default.
2646 */
2647 static void
2648 reset_sound(GtkWidget *button, gpointer data)
2649 {
2650 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
2651 gchar *pref;
2652
2653 pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s",
2654 pidgin_sound_get_event_option(sound_row_sel));
2655 purple_prefs_set_path(pref, "");
2656 g_free(pref);
2657
2658 gtk_entry_set_text(GTK_ENTRY(win->sound.entry), _("(default)"));
2659
2660 pref_sound_generate_markup();
2661 }
2662
2663 static void
2664 sound_chosen_cb(void *user_data, const char *filename)
2665 {
2666 gchar *pref;
2667 int sound;
2668
2669 sound = GPOINTER_TO_INT(user_data);
2670
2671 /* Set it -- and forget it */
2672 pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s",
2673 pidgin_sound_get_event_option(sound));
2674 purple_prefs_set_path(pref, filename);
2675 g_free(pref);
2676
2677 /*
2678 * If the sound we just changed is still the currently selected
2679 * sound, then update the box showing the file name.
2680 */
2681 if (sound == sound_row_sel)
2682 gtk_entry_set_text(GTK_ENTRY(prefs->sound.entry), filename);
2683
2684 pref_sound_generate_markup();
2685 }
2686
2687 static void
2688 select_sound(GtkWidget *button, gpointer being_NULL_is_fun)
2689 {
2690 gchar *pref;
2691 const char *filename;
2692
2693 pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s",
2694 pidgin_sound_get_event_option(sound_row_sel));
2695 filename = purple_prefs_get_path(pref);
2696 g_free(pref);
2697
2698 if (*filename == '\0')
2699 filename = NULL;
2700
2701 purple_request_file(prefs, _("Sound Selection"), filename, FALSE,
2702 G_CALLBACK(sound_chosen_cb), NULL, NULL,
2703 GINT_TO_POINTER(sound_row_sel));
2704 }
2705
2706 static void
2707 prefs_sound_sel(GtkTreeSelection *sel, gpointer data)
2708 {
2709 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
2710 GtkTreeModel *model;
2711 GtkTreeIter iter;
2712 GValue val;
2713 const char *file;
2714 char *pref;
2715
2716 if (! gtk_tree_selection_get_selected (sel, &model, &iter))
2717 return;
2718
2719 val.g_type = 0;
2720 gtk_tree_model_get_value (model, &iter, 3, &val);
2721 sound_row_sel = g_value_get_uint(&val);
2722
2723 pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s",
2724 pidgin_sound_get_event_option(sound_row_sel));
2725 file = purple_prefs_get_path(pref);
2726 g_free(pref);
2727 if (win->sound.entry) {
2728 gtk_entry_set_text(GTK_ENTRY(win->sound.entry),
2729 (file && *file != '\0') ? file
2730 : _("(default)"));
2731 }
2732 g_value_unset (&val);
2733
2734 pref_sound_generate_markup();
2735 }
2736
2737 static void
2738 bind_sound_page(PidginPrefsWindow *win)
2739 {
2740 GtkTreeModel *model;
2741 GtkTreeSelection *sel;
2742 GtkTreePath *path;
2743 int j;
2744 const char *file;
2745 char *pref;
2746 const char *cmd;
2747
2748 win->sound.method.type = PURPLE_PREF_STRING;
2749 win->sound.method.key = PIDGIN_PREFS_ROOT "/sound/method";
2750 pidgin_prefs_bind_dropdown(&win->sound.method);
2751 model = gtk_combo_box_get_model(GTK_COMBO_BOX(win->sound.method.combo));
2752 gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model), sound_method_filter, NULL, NULL);
2753 gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(model));
2754
2755 gtk_widget_set_sensitive(
2756 win->sound.method_vbox,
2757 !purple_strequal(purple_prefs_get_string(PIDGIN_PREFS_ROOT
2758 "/sound/method"),
2759 "none"));
2760 purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/sound/method",
2761 sound_changed2_cb,
2762 win->sound.method_vbox);
2763
2764 gtk_widget_set_sensitive(
2765 win->sound.command_hbox,
2766 purple_strequal(purple_prefs_get_string(PIDGIN_PREFS_ROOT
2767 "/sound/method"),
2768 "custom"));
2769 purple_prefs_connect_callback(prefs, PIDGIN_PREFS_ROOT "/sound/method",
2770 sound_changed1_cb,
2771 win->sound.command_hbox);
2772
2773 cmd = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/sound/command");
2774 if (cmd) {
2775 gtk_entry_set_text(GTK_ENTRY(win->sound.command), cmd);
2776 }
2777
2778 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/sound/mute",
2779 win->sound.mute);
2780
2781 pidgin_prefs_bind_checkbox(PIDGIN_PREFS_ROOT "/sound/conv_focus",
2782 win->sound.conv_focus);
2783
2784 win->sound.while_status.type = PURPLE_PREF_INT;
2785 win->sound.while_status.key = "/purple/sound/while_status";
2786 pidgin_prefs_bind_dropdown(&win->sound.while_status);
2787
2788 /* SOUND SELECTION */
2789 for (j=0; j < PURPLE_NUM_SOUNDS; j++) {
2790 char *pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/enabled/%s",
2791 pidgin_sound_get_event_option(j));
2792 const char *label = pidgin_sound_get_event_label(j);
2793 GtkTreeIter iter;
2794
2795 if (label == NULL) {
2796 g_free(pref);
2797 continue;
2798 }
2799
2800 gtk_list_store_append(win->sound.event.store, &iter);
2801 gtk_list_store_set(win->sound.event.store, &iter,
2802 0, purple_prefs_get_bool(pref),
2803 1, _(label),
2804 2, pref,
2805 3, j,
2806 -1);
2807 g_free(pref);
2808 }
2809
2810 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(win->sound.event.view));
2811 path = gtk_tree_path_new_first();
2812 gtk_tree_selection_select_path(sel, path);
2813 gtk_tree_path_free(path);
2814
2815 pref = g_strdup_printf(PIDGIN_PREFS_ROOT "/sound/file/%s",
2816 pidgin_sound_get_event_option(0));
2817 file = purple_prefs_get_path(pref);
2818 g_free(pref);
2819 gtk_entry_set_text(GTK_ENTRY(win->sound.entry),
2820 (file && *file != '\0') ? file : _("(default)"));
2821 }
2822
2823
2824 static void
2825 set_idle_away(PurpleSavedStatus *status)
2826 {
2827 purple_prefs_set_int("/purple/savedstatus/idleaway", purple_savedstatus_get_creation_time(status));
2828 }
2829
2830 static void
2831 set_startupstatus(PurpleSavedStatus *status)
2832 {
2833 purple_prefs_set_int("/purple/savedstatus/startup", purple_savedstatus_get_creation_time(status));
2834 }
2835
2836 static void
2837 bind_away_page(PidginPrefsWindow *win)
2838 {
2839 GtkWidget *menu;
2840
2841 /* Idle stuff */
2842 win->away.idle_reporting.type = PURPLE_PREF_STRING;
2843 win->away.idle_reporting.key = "/purple/away/idle_reporting";
2844 pidgin_prefs_bind_dropdown(&win->away.idle_reporting);
2845
2846 pidgin_prefs_bind_spin_button("/purple/away/mins_before_away",
2847 win->away.mins_before_away);
2848
2849 pidgin_prefs_bind_checkbox("/purple/away/away_when_idle",
2850 win->away.away_when_idle);
2851
2852 /* TODO: Show something useful if we don't have any saved statuses. */
2853 menu = pidgin_status_menu(purple_savedstatus_get_idleaway(), G_CALLBACK(set_idle_away));
2854 gtk_widget_show_all(menu);
2855 gtk_box_pack_start(GTK_BOX(win->away.idle_hbox), menu, FALSE, FALSE, 0);
2856
2857 g_object_bind_property(win->away.away_when_idle, "active",
2858 menu, "sensitive",
2859 G_BINDING_SYNC_CREATE);
2860
2861 /* Away stuff */
2862 win->away.auto_reply.type = PURPLE_PREF_STRING;
2863 win->away.auto_reply.key = "/purple/away/auto_reply";
2864 pidgin_prefs_bind_dropdown(&win->away.auto_reply);
2865
2866 /* Signon status stuff */
2867 pidgin_prefs_bind_checkbox("/purple/savedstatus/startup_current_status",
2868 win->away.startup_current_status);
2869
2870 /* TODO: Show something useful if we don't have any saved statuses. */
2871 menu = pidgin_status_menu(purple_savedstatus_get_startup(), G_CALLBACK(set_startupstatus));
2872 gtk_widget_show_all(menu);
2873 gtk_box_pack_start(GTK_BOX(win->away.startup_hbox), menu, FALSE, FALSE, 0);
2874 gtk_label_set_mnemonic_widget(GTK_LABEL(win->away.startup_label), menu);
2875 pidgin_set_accessible_label(menu, GTK_LABEL(win->away.startup_label));
2876 g_object_bind_property(win->away.startup_current_status, "active",
2877 win->away.startup_hbox, "sensitive",
2878 G_BINDING_SYNC_CREATE|G_BINDING_INVERT_BOOLEAN);
2879 }
2880
2881 #ifdef USE_VV
2882 static GList *
2883 get_vv_device_menuitems(PurpleMediaElementType type)
2884 {
2885 GList *result = NULL;
2886 GList *i;
2887
2888 i = purple_media_manager_enumerate_elements(purple_media_manager_get(),
2889 type);
2890 for (; i; i = g_list_delete_link(i, i)) {
2891 PurpleMediaElementInfo *info = i->data;
2892
2893 result = g_list_append(result,
2894 purple_media_element_info_get_name(info));
2895 result = g_list_append(result,
2896 purple_media_element_info_get_id(info));
2897 g_object_unref(info);
2898 }
2899
2900 return result;
2901 }
2902
2903 static GstElement *
2904 create_test_element(PurpleMediaElementType type)
2905 {
2906 PurpleMediaElementInfo *element_info;
2907
2908 element_info = purple_media_manager_get_active_element(purple_media_manager_get(), type);
2909
2910 g_return_val_if_fail(element_info, NULL);
2911
2912 return purple_media_element_info_call_create(element_info,
2913 NULL, NULL, NULL);
2914 }
2915
2916 static void
2917 vv_test_switch_page_cb(GtkStack *stack, G_GNUC_UNUSED GParamSpec *pspec,
2918 gpointer data)
2919 {
2920 PidginPrefsWindow *win = data;
2921
2922 if (!g_str_equal(gtk_stack_get_visible_child_name(stack), "vv")) {
2923 /* Disable any running test pipelines. */
2924 gtk_toggle_button_set_active(
2925 GTK_TOGGLE_BUTTON(win->vv.voice.test), FALSE);
2926 gtk_toggle_button_set_active(
2927 GTK_TOGGLE_BUTTON(win->vv.video.test), FALSE);
2928 }
2929 }
2930
2931 static GstElement *
2932 create_voice_pipeline(void)
2933 {
2934 GstElement *pipeline;
2935 GstElement *src, *sink;
2936 GstElement *volume;
2937 GstElement *level;
2938 GstElement *valve;
2939
2940 pipeline = gst_pipeline_new("voicetest");
2941
2942 src = create_test_element(PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SRC);
2943 sink = create_test_element(PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SINK);
2944 volume = gst_element_factory_make("volume", "volume");
2945 level = gst_element_factory_make("level", "level");
2946 valve = gst_element_factory_make("valve", "valve");
2947
2948 gst_bin_add_many(GST_BIN(pipeline), src, volume, level, valve, sink, NULL);
2949 gst_element_link_many(src, volume, level, valve, sink, NULL);
2950
2951 purple_debug_info("gtkprefs", "create_voice_pipeline: setting pipeline "
2952 "state to GST_STATE_PLAYING - it may hang here on win32\n");
2953 gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING);
2954 purple_debug_info("gtkprefs", "create_voice_pipeline: state is set\n");
2955
2956 return pipeline;
2957 }
2958
2959 static void
2960 on_volume_change_cb(GtkWidget *w, gdouble value, gpointer data)
2961 {
2962 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
2963 GstElement *volume;
2964
2965 if (!win->vv.voice.pipeline) {
2966 return;
2967 }
2968
2969 volume = gst_bin_get_by_name(GST_BIN(win->vv.voice.pipeline), "volume");
2970 g_object_set(volume, "volume",
2971 gtk_scale_button_get_value(GTK_SCALE_BUTTON(w)) * 10.0, NULL);
2972 }
2973
2974 static gdouble
2975 gst_msg_db_to_percent(GstMessage *msg, gchar *value_name)
2976 {
2977 const GValue *list;
2978 const GValue *value;
2979 gdouble value_db;
2980 gdouble percent;
2981
2982 list = gst_structure_get_value(gst_message_get_structure(msg), value_name);
2983 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
2984 value = g_value_array_get_nth(g_value_get_boxed(list), 0);
2985 G_GNUC_END_IGNORE_DEPRECATIONS
2986 value_db = g_value_get_double(value);
2987 percent = pow(10, value_db / 20);
2988 return (percent > 1.0) ? 1.0 : percent;
2989 }
2990
2991 static gboolean
2992 gst_bus_cb(GstBus *bus, GstMessage *msg, gpointer data)
2993 {
2994 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
2995
2996 if (GST_MESSAGE_TYPE(msg) == GST_MESSAGE_ELEMENT &&
2997 gst_structure_has_name(gst_message_get_structure(msg), "level")) {
2998
2999 GstElement *src = GST_ELEMENT(GST_MESSAGE_SRC(msg));
3000 gchar *name = gst_element_get_name(src);
3001
3002 if (purple_strequal(name, "level")) {
3003 gdouble percent;
3004 gdouble threshold;
3005 GstElement *valve;
3006
3007 percent = gst_msg_db_to_percent(msg, "rms");
3008 gtk_progress_bar_set_fraction(
3009 GTK_PROGRESS_BAR(win->vv.voice.level), percent);
3010
3011 percent = gst_msg_db_to_percent(msg, "decay");
3012 threshold = gtk_range_get_value(GTK_RANGE(
3013 win->vv.voice.threshold)) /
3014 100.0;
3015 valve = gst_bin_get_by_name(GST_BIN(GST_ELEMENT_PARENT(src)), "valve");
3016 g_object_set(valve, "drop", (percent < threshold), NULL);
3017 g_object_set(win->vv.voice.level, "text",
3018 (percent < threshold) ? _("DROP") : " ",
3019 NULL);
3020 }
3021
3022 g_free(name);
3023 }
3024
3025 return TRUE;
3026 }
3027
3028 static void
3029 voice_test_destroy_cb(GtkWidget *w, gpointer data)
3030 {
3031 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
3032
3033 if (!win->vv.voice.pipeline) {
3034 return;
3035 }
3036
3037 gst_element_set_state(win->vv.voice.pipeline, GST_STATE_NULL);
3038 g_clear_pointer(&win->vv.voice.pipeline, gst_object_unref);
3039 }
3040
3041 static void
3042 enable_voice_test(PidginPrefsWindow *win)
3043 {
3044 GstBus *bus;
3045
3046 win->vv.voice.pipeline = create_voice_pipeline();
3047 bus = gst_pipeline_get_bus(GST_PIPELINE(win->vv.voice.pipeline));
3048 gst_bus_add_signal_watch(bus);
3049 g_signal_connect(bus, "message", G_CALLBACK(gst_bus_cb), win);
3050 gst_object_unref(bus);
3051 }
3052
3053 static void
3054 toggle_voice_test_cb(GtkToggleButton *test, gpointer data)
3055 {
3056 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
3057
3058 if (gtk_toggle_button_get_active(test)) {
3059 gtk_widget_set_sensitive(win->vv.voice.level, TRUE);
3060 enable_voice_test(win);
3061
3062 g_signal_connect(win->vv.voice.volume, "value-changed",
3063 G_CALLBACK(on_volume_change_cb), win);
3064 g_signal_connect(test, "destroy",
3065 G_CALLBACK(voice_test_destroy_cb), win);
3066 } else {
3067 gtk_progress_bar_set_fraction(
3068 GTK_PROGRESS_BAR(win->vv.voice.level), 0.0);
3069 gtk_widget_set_sensitive(win->vv.voice.level, FALSE);
3070 g_object_disconnect(win->vv.voice.volume,
3071 "any-signal::value-changed",
3072 G_CALLBACK(on_volume_change_cb), win, NULL);
3073 g_object_disconnect(test, "any-signal::destroy",
3074 G_CALLBACK(voice_test_destroy_cb), win,
3075 NULL);
3076 voice_test_destroy_cb(NULL, win);
3077 }
3078 }
3079
3080 static void
3081 volume_changed_cb(GtkScaleButton *button, gdouble value, gpointer data)
3082 {
3083 purple_prefs_set_int("/purple/media/audio/volume/input", value * 100);
3084 }
3085
3086 static void
3087 threshold_value_changed_cb(GtkScale *scale, GtkWidget *label)
3088 {
3089 int value;
3090 char *tmp;
3091
3092 value = (int)gtk_range_get_value(GTK_RANGE(scale));
3093 tmp = g_strdup_printf(_("Silence threshold: %d%%"), value);
3094 gtk_label_set_label(GTK_LABEL(label), tmp);
3095 g_free(tmp);
3096
3097 purple_prefs_set_int("/purple/media/audio/silence_threshold", value);
3098 }
3099
3100 static void
3101 bind_voice_test(PidginPrefsWindow *win, GtkBuilder *builder)
3102 {
3103 GObject *test;
3104 GObject *label;
3105 GObject *volume;
3106 GObject *threshold;
3107 char *tmp;
3108
3109 volume = gtk_builder_get_object(builder, "vv.voice.volume");
3110 win->vv.voice.volume = GTK_WIDGET(volume);
3111 gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume),
3112 purple_prefs_get_int("/purple/media/audio/volume/input") / 100.0);
3113 g_signal_connect(volume, "value-changed",
3114 G_CALLBACK(volume_changed_cb), NULL);
3115
3116 label = gtk_builder_get_object(builder, "vv.voice.threshold_label");
3117 tmp = g_strdup_printf(_("Silence threshold: %d%%"),
3118 purple_prefs_get_int("/purple/media/audio/silence_threshold"));
3119 gtk_label_set_text(GTK_LABEL(label), tmp);
3120 g_free(tmp);
3121
3122 threshold = gtk_builder_get_object(builder, "vv.voice.threshold");
3123 win->vv.voice.threshold = GTK_WIDGET(threshold);
3124 gtk_range_set_value(GTK_RANGE(threshold),
3125 purple_prefs_get_int("/purple/media/audio/silence_threshold"));
3126 g_signal_connect(threshold, "value-changed",
3127 G_CALLBACK(threshold_value_changed_cb), label);
3128
3129 win->vv.voice.level =
3130 GTK_WIDGET(gtk_builder_get_object(builder, "vv.voice.level"));
3131
3132 test = gtk_builder_get_object(builder, "vv.voice.test");
3133 g_signal_connect(test, "toggled",
3134 G_CALLBACK(toggle_voice_test_cb), win);
3135 win->vv.voice.test = GTK_WIDGET(test);
3136 }
3137
3138 static GstElement *
3139 create_video_pipeline(void)
3140 {
3141 GstElement *pipeline;
3142 GstElement *src, *sink;
3143 GstElement *videoconvert;
3144 GstElement *videoscale;
3145
3146 pipeline = gst_pipeline_new("videotest");
3147 src = create_test_element(PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC);
3148 sink = create_test_element(PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK);
3149 videoconvert = gst_element_factory_make("videoconvert", NULL);
3150 videoscale = gst_element_factory_make("videoscale", NULL);
3151
3152 g_object_set_data(G_OBJECT(pipeline), "sink", sink);
3153
3154 gst_bin_add_many(GST_BIN(pipeline), src, videoconvert, videoscale, sink,
3155 NULL);
3156 gst_element_link_many(src, videoconvert, videoscale, sink, NULL);
3157
3158 return pipeline;
3159 }
3160
3161 static void
3162 video_test_destroy_cb(GtkWidget *w, gpointer data)
3163 {
3164 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
3165
3166 if (!win->vv.video.pipeline) {
3167 return;
3168 }
3169
3170 gst_element_set_state(win->vv.video.pipeline, GST_STATE_NULL);
3171 g_clear_pointer(&win->vv.video.pipeline, gst_object_unref);
3172 }
3173
3174 static void
3175 window_id_cb(GstBus *bus, GstMessage *msg, gulong window_id)
3176 {
3177 if (GST_MESSAGE_TYPE(msg) != GST_MESSAGE_ELEMENT ||
3178 !gst_is_video_overlay_prepare_window_handle_message(msg)) {
3179 return;
3180 }
3181
3182 g_signal_handlers_disconnect_matched(bus,
3183 G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA,
3184 0, 0, NULL, window_id_cb,
3185 (gpointer)window_id);
3186
3187 gst_video_overlay_set_window_handle(GST_VIDEO_OVERLAY(GST_MESSAGE_SRC(msg)),
3188 window_id);
3189 }
3190
3191 static void
3192 enable_video_test(PidginPrefsWindow *win)
3193 {
3194 GstBus *bus;
3195 GdkWindow *window = gtk_widget_get_window(win->vv.video.drawing_area);
3196 gulong window_id = 0;
3197
3198 #ifdef GDK_WINDOWING_WIN32
3199 if (GDK_IS_WIN32_WINDOW(window))
3200 window_id = GPOINTER_TO_UINT(GDK_WINDOW_HWND(window));
3201 else
3202 #endif
3203 #ifdef GDK_WINDOWING_X11
3204 if (GDK_IS_X11_WINDOW(window))
3205 window_id = gdk_x11_window_get_xid(window);
3206 else
3207 #endif
3208 #ifdef GDK_WINDOWING_QUARTZ
3209 if (GDK_IS_QUARTZ_WINDOW(window))
3210 window_id = (gulong)gdk_quartz_window_get_nsview(window);
3211 else
3212 #endif
3213 g_warning("Unsupported GDK backend");
3214 #if !(defined(GDK_WINDOWING_WIN32) \
3215 || defined(GDK_WINDOWING_X11) \
3216 || defined(GDK_WINDOWING_QUARTZ))
3217 # error "Unsupported GDK windowing system"
3218 #endif
3219
3220 win->vv.video.pipeline = create_video_pipeline();
3221 bus = gst_pipeline_get_bus(GST_PIPELINE(win->vv.video.pipeline));
3222 gst_bus_set_sync_handler(bus, gst_bus_sync_signal_handler, NULL, NULL);
3223 g_signal_connect(bus, "sync-message::element",
3224 G_CALLBACK(window_id_cb), (gpointer)window_id);
3225 gst_object_unref(bus);
3226
3227 gst_element_set_state(GST_ELEMENT(win->vv.video.pipeline),
3228 GST_STATE_PLAYING);
3229 }
3230
3231 static void
3232 toggle_video_test_cb(GtkToggleButton *test, gpointer data)
3233 {
3234 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
3235
3236 if (gtk_toggle_button_get_active(test)) {
3237 enable_video_test(win);
3238 g_signal_connect(test, "destroy",
3239 G_CALLBACK(video_test_destroy_cb), win);
3240 } else {
3241 g_object_disconnect(test, "any-signal::destroy",
3242 G_CALLBACK(video_test_destroy_cb), win,
3243 NULL);
3244 video_test_destroy_cb(NULL, win);
3245 }
3246 }
3247
3248 static void
3249 bind_video_test(PidginPrefsWindow *win, GtkBuilder *builder)
3250 {
3251 GtkWidget *video;
3252 GObject *test;
3253 GdkRGBA color = {0.0, 0.0, 0.0, 1.0};
3254
3255 win->vv.video.drawing_area = video = GTK_WIDGET(
3256 gtk_builder_get_object(builder, "vv.video.test_area"));
3257 gtk_widget_override_background_color(video, GTK_STATE_FLAG_NORMAL,
3258 &color);
3259
3260 /* In order to enable client shadow decorations, GtkDialog from GTK+ 3.0
3261 * uses ARGB visual which by default gets inherited by its child
3262 * widgets. XVideo adaptors on the other hand often support just depth
3263 * 24 and rendering video through xvimagesink onto a widget inside a
3264 * GtkDialog then results in no visible output.
3265 *
3266 * This ensures the default system visual of the drawing area doesn't
3267 * get overridden by the widget's parent.
3268 */
3269 gtk_widget_set_visual(video, gdk_screen_get_system_visual(
3270 gtk_widget_get_screen(video)));
3271
3272 test = gtk_builder_get_object(builder, "vv.video.test");
3273 g_signal_connect(test, "toggled",
3274 G_CALLBACK(toggle_video_test_cb), win);
3275 win->vv.video.test = GTK_WIDGET(test);
3276 }
3277
3278 static void
3279 vv_device_changed_cb(const gchar *name, PurplePrefType type,
3280 gconstpointer value, gpointer data)
3281 {
3282 PidginPrefsWindow *win = PIDGIN_PREFS_WINDOW(data);
3283
3284 PurpleMediaManager *manager;
3285 PurpleMediaElementInfo *info;
3286
3287 manager = purple_media_manager_get();
3288 info = purple_media_manager_get_element_info(manager, value);
3289 purple_media_manager_set_active_element(manager, info);
3290
3291 /* Refresh test viewers */
3292 if (strstr(name, "audio") && win->vv.voice.pipeline) {
3293 voice_test_destroy_cb(NULL, win);
3294 enable_voice_test(win);
3295 } else if (strstr(name, "video") && win->vv.video.pipeline) {
3296 video_test_destroy_cb(NULL, win);
3297 enable_video_test(win);
3298 }
3299 }
3300
3301 static const char *
3302 purple_media_type_to_preference_key(PurpleMediaElementType type)
3303 {
3304 if (type & PURPLE_MEDIA_ELEMENT_AUDIO) {
3305 if (type & PURPLE_MEDIA_ELEMENT_SRC) {
3306 return PIDGIN_PREFS_ROOT "/vvconfig/audio/src/device";
3307 } else if (type & PURPLE_MEDIA_ELEMENT_SINK) {
3308 return PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/device";
3309 }
3310 } else if (type & PURPLE_MEDIA_ELEMENT_VIDEO) {
3311 if (type & PURPLE_MEDIA_ELEMENT_SRC) {
3312 return PIDGIN_PREFS_ROOT "/vvconfig/video/src/device";
3313 } else if (type & PURPLE_MEDIA_ELEMENT_SINK) {
3314 return PIDGIN_PREFS_ROOT "/vvconfig/video/sink/device";
3315 }
3316 }
3317
3318 return NULL;
3319 }
3320
3321 static void
3322 bind_vv_dropdown(PidginPrefCombo *combo, PurpleMediaElementType element_type)
3323 {
3324 const gchar *preference_key;
3325 GList *devices;
3326
3327 preference_key = purple_media_type_to_preference_key(element_type);
3328 devices = get_vv_device_menuitems(element_type);
3329
3330 if (g_list_find_custom(devices, purple_prefs_get_string(preference_key),
3331 (GCompareFunc)strcmp) == NULL)
3332 {
3333 GList *next = g_list_next(devices);
3334 if (next)
3335 purple_prefs_set_string(preference_key, next->data);
3336 }
3337
3338 combo->type = PURPLE_PREF_STRING;
3339 combo->key = preference_key;
3340 pidgin_prefs_bind_dropdown_from_list(combo, devices);
3341 g_list_free_full(devices, g_free);
3342 }
3343
3344 static void
3345 bind_vv_frame(PidginPrefsWindow *win, PidginPrefCombo *combo,
3346 PurpleMediaElementType type)
3347 {
3348 bind_vv_dropdown(combo, type);
3349
3350 purple_prefs_connect_callback(combo->combo,
3351 purple_media_type_to_preference_key(type),
3352 vv_device_changed_cb, win);
3353 g_signal_connect_swapped(combo->combo, "destroy",
3354 G_CALLBACK(purple_prefs_disconnect_by_handle),
3355 combo->combo);
3356
3357 g_object_set_data(G_OBJECT(combo->combo), "vv_media_type",
3358 (gpointer)type);
3359 g_object_set_data(G_OBJECT(combo->combo), "vv_combo", combo);
3360 }
3361
3362 static void
3363 device_list_changed_cb(PurpleMediaManager *manager, GtkWidget *widget)
3364 {
3365 PidginPrefCombo *combo;
3366 PurpleMediaElementType media_type;
3367 GtkTreeModel *model;
3368
3369 combo = g_object_get_data(G_OBJECT(widget), "vv_combo");
3370 media_type = (PurpleMediaElementType)g_object_get_data(G_OBJECT(widget),
3371 "vv_media_type");
3372
3373 /* Unbind original connections so we can repopulate the combo box. */
3374 g_object_disconnect(combo->combo, "any-signal::changed",
3375 G_CALLBACK(bind_dropdown_set), combo, NULL);
3376 model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo->combo));
3377 gtk_list_store_clear(GTK_LIST_STORE(model));
3378
3379 bind_vv_dropdown(combo, media_type);
3380 }
3381
3382 static GtkWidget *
3383 vv_page(PidginPrefsWindow *win)
3384 {
3385 GtkBuilder *builder;
3386 GtkWidget *ret;
3387 PurpleMediaManager *manager;
3388
3389 builder = gtk_builder_new_from_resource("/im/pidgin/Pidgin/Prefs/vv.ui");
3390 gtk_builder_set_translation_domain(builder, PACKAGE);
3391
3392 ret = GTK_WIDGET(gtk_builder_get_object(builder, "vv.page"));
3393
3394 manager = purple_media_manager_get();
3395
3396 win->vv.voice.input.combo = GTK_WIDGET(
3397 gtk_builder_get_object(builder, "vv.voice.input.combo"));
3398 bind_vv_frame(win, &win->vv.voice.input,
3399 PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SRC);
3400 g_signal_connect_object(manager, "elements-changed::audiosrc",
3401 G_CALLBACK(device_list_changed_cb),
3402 win->vv.voice.input.combo, 0);
3403
3404 win->vv.voice.output.combo = GTK_WIDGET(
3405 gtk_builder_get_object(builder, "vv.voice.output.combo"));
3406 bind_vv_frame(win, &win->vv.voice.output,
3407 PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SINK);
3408 g_signal_connect_object(manager, "elements-changed::audiosink",
3409 G_CALLBACK(device_list_changed_cb),
3410 win->vv.voice.output.combo, 0);
3411
3412 bind_voice_test(win, builder);
3413
3414 win->vv.video.input.combo = GTK_WIDGET(
3415 gtk_builder_get_object(builder, "vv.video.input.combo"));
3416 bind_vv_frame(win, &win->vv.video.input,
3417 PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC);
3418 g_signal_connect_object(manager, "elements-changed::videosrc",
3419 G_CALLBACK(device_list_changed_cb),
3420 win->vv.video.input.combo, 0);
3421
3422 win->vv.video.output.combo = GTK_WIDGET(
3423 gtk_builder_get_object(builder, "vv.video.output.combo"));
3424 bind_vv_frame(win, &win->vv.video.output,
3425 PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK);
3426 g_signal_connect_object(manager, "elements-changed::videosink",
3427 G_CALLBACK(device_list_changed_cb),
3428 win->vv.video.output.combo, 0);
3429
3430 bind_video_test(win, builder);
3431
3432 g_signal_connect(win->stack, "notify::visible-child",
3433 G_CALLBACK(vv_test_switch_page_cb), win);
3434
3435 g_object_ref(ret);
3436 g_object_unref(builder);
3437
3438 return ret;
3439 }
3440 #endif
3441
3442 static void
3443 prefs_stack_init(PidginPrefsWindow *win)
3444 {
3445 #ifdef USE_VV
3446 GtkStack *stack = GTK_STACK(win->stack);
3447 GtkWidget *vv;
3448 #endif
3449
3450 bind_interface_page(win);
3451 bind_browser_page(win);
3452 bind_conv_page(win);
3453 bind_logging_page(win);
3454 bind_network_page(win);
3455 bind_proxy_page(win);
3456 bind_keyring_page(win);
3457 bind_sound_page(win);
3458 bind_away_page(win);
3459 bind_theme_page(win);
3460 #ifdef USE_VV
3461 vv = vv_page(win);
3462 gtk_container_add_with_properties(GTK_CONTAINER(stack), vv, "name",
3463 "vv", "title", _("Voice/Video"),
3464 NULL);
3465 g_object_unref(vv);
3466 #endif
3467 }
3468
3469 static void
3470 pidgin_prefs_window_class_init(PidginPrefsWindowClass *klass)
3471 {
3472 GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
3473
3474 gtk_widget_class_set_template_from_resource(
3475 widget_class,
3476 "/im/pidgin/Pidgin/Prefs/prefs.ui"
3477 );
3478
3479 /* Main window */
3480 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3481 stack);
3482 gtk_widget_class_bind_template_callback(widget_class, delete_prefs);
3483
3484 /* Interface page */
3485 gtk_widget_class_bind_template_child(
3486 widget_class, PidginPrefsWindow,
3487 iface.docklet.combo);
3488 gtk_widget_class_bind_template_child(
3489 widget_class, PidginPrefsWindow,
3490 iface.im.hide_new.combo);
3491 gtk_widget_class_bind_template_child(
3492 widget_class, PidginPrefsWindow,
3493 iface.win32.minimize_new_convs);
3494 gtk_widget_class_bind_template_child(
3495 widget_class, PidginPrefsWindow,
3496 iface.conversations.tabs);
3497 gtk_widget_class_bind_template_child(
3498 widget_class, PidginPrefsWindow,
3499 iface.conversations.tabs_vbox);
3500 gtk_widget_class_bind_template_child(
3501 widget_class, PidginPrefsWindow,
3502 iface.conversations.close_on_tabs);
3503 gtk_widget_class_bind_template_child(
3504 widget_class, PidginPrefsWindow,
3505 iface.conversations.tab_side.combo);
3506 gtk_widget_class_bind_template_child(
3507 widget_class, PidginPrefsWindow,
3508 iface.conversations.placement.combo);
3509
3510 /* Browser page */
3511 gtk_widget_class_bind_template_child(
3512 widget_class, PidginPrefsWindow, browser.page);
3513 gtk_widget_class_bind_template_child(
3514 widget_class, PidginPrefsWindow, browser.stack);
3515 gtk_widget_class_bind_template_child(
3516 widget_class, PidginPrefsWindow, browser.gnome_not_found);
3517 gtk_widget_class_bind_template_child(
3518 widget_class, PidginPrefsWindow, browser.gnome_program);
3519 gtk_widget_class_bind_template_child(
3520 widget_class, PidginPrefsWindow, browser.browser.combo);
3521 gtk_widget_class_bind_template_child(
3522 widget_class, PidginPrefsWindow, browser.place_hbox);
3523 gtk_widget_class_bind_template_child(
3524 widget_class, PidginPrefsWindow, browser.place.combo);
3525 gtk_widget_class_bind_template_child(
3526 widget_class, PidginPrefsWindow, browser.manual_command_hbox);
3527 gtk_widget_class_bind_template_child(
3528 widget_class, PidginPrefsWindow, browser.manual_command);
3529 gtk_widget_class_bind_template_callback(widget_class,
3530 browser_button_clicked_cb);
3531 gtk_widget_class_bind_template_callback(widget_class,
3532 manual_browser_set);
3533
3534 /* Conversations page */
3535 gtk_widget_class_bind_template_child(
3536 widget_class, PidginPrefsWindow,
3537 conversations.notification_chat.combo);
3538 gtk_widget_class_bind_template_child(
3539 widget_class, PidginPrefsWindow,
3540 conversations.show_incoming_formatting);
3541 gtk_widget_class_bind_template_child(
3542 widget_class, PidginPrefsWindow,
3543 conversations.im.close_immediately);
3544 gtk_widget_class_bind_template_child(
3545 widget_class, PidginPrefsWindow,
3546 conversations.im.show_buddy_icons);
3547 gtk_widget_class_bind_template_child(
3548 widget_class, PidginPrefsWindow,
3549 conversations.im.animate_buddy_icons);
3550 gtk_widget_class_bind_template_child(
3551 widget_class, PidginPrefsWindow,
3552 conversations.im.send_typing);
3553 gtk_widget_class_bind_template_child(
3554 widget_class, PidginPrefsWindow,
3555 conversations.spellcheck);
3556 gtk_widget_class_bind_template_child(
3557 widget_class, PidginPrefsWindow,
3558 conversations.use_smooth_scrolling);
3559 gtk_widget_class_bind_template_child(
3560 widget_class, PidginPrefsWindow,
3561 conversations.win32.blink_im);
3562 gtk_widget_class_bind_template_child(
3563 widget_class, PidginPrefsWindow,
3564 conversations.resize_custom_smileys);
3565 gtk_widget_class_bind_template_child(
3566 widget_class, PidginPrefsWindow,
3567 conversations.custom_smileys_size);
3568 gtk_widget_class_bind_template_child(
3569 widget_class, PidginPrefsWindow,
3570 conversations.minimum_entry_lines);
3571 gtk_widget_class_bind_template_child(
3572 widget_class, PidginPrefsWindow,
3573 conversations.format_buffer);
3574 gtk_widget_class_bind_template_child(
3575 widget_class, PidginPrefsWindow,
3576 conversations.format_view);
3577 #ifdef WIN32
3578 gtk_widget_class_bind_template_child(
3579 widget_class, PidginPrefsWindow,
3580 conversations.font_frame);
3581 gtk_widget_class_bind_template_child(
3582 widget_class, PidginPrefsWindow,
3583 conversations.use_theme_font);
3584 gtk_widget_class_bind_template_child(
3585 widget_class, PidginPrefsWindow,
3586 conversations.custom_font_hbox);
3587 gtk_widget_class_bind_template_child(
3588 widget_class, PidginPrefsWindow,
3589 conversations.custom_font);
3590 #endif
3591 /* Even though Win32-specific, must be bound to avoid Glade warnings. */
3592 gtk_widget_class_bind_template_callback(widget_class,
3593 apply_custom_font);
3594 gtk_widget_class_bind_template_callback(widget_class,
3595 pidgin_custom_font_set);
3596
3597 /* Logging page */
3598 gtk_widget_class_bind_template_child(
3599 widget_class, PidginPrefsWindow, logging.format.combo);
3600 gtk_widget_class_bind_template_child(
3601 widget_class, PidginPrefsWindow, logging.log_ims);
3602 gtk_widget_class_bind_template_child(
3603 widget_class, PidginPrefsWindow, logging.log_chats);
3604 gtk_widget_class_bind_template_child(
3605 widget_class, PidginPrefsWindow, logging.log_system);
3606
3607 /* Network page */
3608 gtk_widget_class_bind_template_child(
3609 widget_class, PidginPrefsWindow, network.stun_server);
3610 gtk_widget_class_bind_template_child(
3611 widget_class, PidginPrefsWindow, network.auto_ip);
3612 gtk_widget_class_bind_template_child(
3613 widget_class, PidginPrefsWindow, network.public_ip);
3614 gtk_widget_class_bind_template_child(
3615 widget_class, PidginPrefsWindow,
3616 network.public_ip_hbox);
3617 gtk_widget_class_bind_template_child(
3618 widget_class, PidginPrefsWindow, network.map_ports);
3619 gtk_widget_class_bind_template_child(
3620 widget_class, PidginPrefsWindow,
3621 network.ports_range_use);
3622 gtk_widget_class_bind_template_child(
3623 widget_class, PidginPrefsWindow,
3624 network.ports_range_hbox);
3625 gtk_widget_class_bind_template_child(
3626 widget_class, PidginPrefsWindow,
3627 network.ports_range_start);
3628 gtk_widget_class_bind_template_child(
3629 widget_class, PidginPrefsWindow,
3630 network.ports_range_end);
3631 gtk_widget_class_bind_template_child(
3632 widget_class, PidginPrefsWindow, network.turn_server);
3633 gtk_widget_class_bind_template_child(
3634 widget_class, PidginPrefsWindow,
3635 network.turn_port_udp);
3636 gtk_widget_class_bind_template_child(
3637 widget_class, PidginPrefsWindow,
3638 network.turn_port_tcp);
3639 gtk_widget_class_bind_template_child(
3640 widget_class, PidginPrefsWindow,
3641 network.turn_username);
3642 gtk_widget_class_bind_template_child(
3643 widget_class, PidginPrefsWindow,
3644 network.turn_password);
3645 gtk_widget_class_bind_template_callback(widget_class,
3646 network_stun_server_changed_cb);
3647 gtk_widget_class_bind_template_callback(widget_class,
3648 auto_ip_button_clicked_cb);
3649 gtk_widget_class_bind_template_callback(widget_class,
3650 network_ip_changed);
3651 gtk_widget_class_bind_template_callback(widget_class,
3652 network_turn_server_changed_cb);
3653
3654 /* Proxy page */
3655 gtk_widget_class_bind_template_child(
3656 widget_class, PidginPrefsWindow, proxy.stack);
3657 gtk_widget_class_bind_template_child(
3658 widget_class, PidginPrefsWindow, proxy.gnome_not_found);
3659 gtk_widget_class_bind_template_child(
3660 widget_class, PidginPrefsWindow, proxy.gnome_program);
3661 gtk_widget_class_bind_template_child(
3662 widget_class, PidginPrefsWindow,
3663 proxy.socks4_remotedns);
3664 gtk_widget_class_bind_template_child(
3665 widget_class, PidginPrefsWindow, proxy.type.combo);
3666 gtk_widget_class_bind_template_child(
3667 widget_class, PidginPrefsWindow, proxy.options);
3668 gtk_widget_class_bind_template_child(
3669 widget_class, PidginPrefsWindow, proxy.host);
3670 gtk_widget_class_bind_template_child(
3671 widget_class, PidginPrefsWindow, proxy.port);
3672 gtk_widget_class_bind_template_child(
3673 widget_class, PidginPrefsWindow, proxy.username);
3674 gtk_widget_class_bind_template_child(
3675 widget_class, PidginPrefsWindow, proxy.password);
3676 gtk_widget_class_bind_template_callback(widget_class,
3677 proxy_button_clicked_cb);
3678 gtk_widget_class_bind_template_callback(widget_class,
3679 proxy_print_option);
3680
3681 /* Keyrings page */
3682 gtk_widget_class_bind_template_child(
3683 widget_class, PidginPrefsWindow, keyring.active.combo);
3684 gtk_widget_class_bind_template_child(
3685 widget_class, PidginPrefsWindow, keyring.vbox);
3686
3687 /* Sounds page */
3688 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3689 sound.method.combo);
3690 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3691 sound.method_vbox);
3692 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3693 sound.command);
3694 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3695 sound.command_hbox);
3696 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3697 sound.mute);
3698 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3699 sound.conv_focus);
3700 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3701 sound.while_status.combo);
3702 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3703 sound.event.view);
3704 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3705 sound.event.store);
3706 gtk_widget_class_bind_template_child(widget_class, PidginPrefsWindow,
3707 sound.entry);
3708 gtk_widget_class_bind_template_callback(widget_class, sound_cmd_yeah);
3709 gtk_widget_class_bind_template_callback(widget_class, prefs_sound_sel);
3710 gtk_widget_class_bind_template_callback(widget_class, event_toggled);
3711 gtk_widget_class_bind_template_callback(widget_class, select_sound);
3712 gtk_widget_class_bind_template_callback(widget_class, test_sound);
3713 gtk_widget_class_bind_template_callback(widget_class, reset_sound);
3714
3715 /* Away page */
3716 gtk_widget_class_bind_template_child(
3717 widget_class, PidginPrefsWindow,
3718 away.idle_reporting.combo);
3719 gtk_widget_class_bind_template_child(
3720 widget_class, PidginPrefsWindow,
3721 away.mins_before_away);
3722 gtk_widget_class_bind_template_child(
3723 widget_class, PidginPrefsWindow, away.away_when_idle);
3724 gtk_widget_class_bind_template_child(
3725 widget_class, PidginPrefsWindow, away.idle_hbox);
3726 gtk_widget_class_bind_template_child(
3727 widget_class, PidginPrefsWindow,
3728 away.auto_reply.combo);
3729 gtk_widget_class_bind_template_child(
3730 widget_class, PidginPrefsWindow,
3731 away.startup_current_status);
3732 gtk_widget_class_bind_template_child(
3733 widget_class, PidginPrefsWindow, away.startup_hbox);
3734 gtk_widget_class_bind_template_child(
3735 widget_class, PidginPrefsWindow, away.startup_label);
3736
3737 /* Themes page */
3738 gtk_widget_class_bind_template_child(
3739 widget_class, PidginPrefsWindow, theme.blist);
3740 gtk_widget_class_bind_template_child(
3741 widget_class, PidginPrefsWindow, theme.status);
3742 gtk_widget_class_bind_template_child(
3743 widget_class, PidginPrefsWindow, theme.sound);
3744 gtk_widget_class_bind_template_child(
3745 widget_class, PidginPrefsWindow, theme.smiley);
3746 gtk_widget_class_bind_template_callback(widget_class,
3747 prefs_set_blist_theme_cb);
3748 gtk_widget_class_bind_template_callback(widget_class,
3749 prefs_set_status_icon_theme_cb);
3750 gtk_widget_class_bind_template_callback(widget_class,
3751 prefs_set_sound_theme_cb);
3752 gtk_widget_class_bind_template_callback(widget_class,
3753 prefs_set_smiley_theme_cb);
3754 }
3755
3756 static void
3757 pidgin_prefs_window_init(PidginPrefsWindow *win)
3758 {
3759 /* copy the preferences to tmp values...
3760 * I liked "take affect immediately" Oh well :-( */
3761 /* (that should have been "effect," right?) */
3762
3763 /* Back to instant-apply! I win! BU-HAHAHA! */
3764
3765 /* Create the window */
3766 gtk_widget_init_template(GTK_WIDGET(win));
3767
3768 prefs_stack_init(win);
3769
3770 /* Refresh the list of themes before showing the preferences window */
3771 prefs_themes_refresh();
3772 }
3773
3774 void
3775 pidgin_prefs_show(void)
3776 {
3777 if (prefs == NULL) {
3778 prefs = PIDGIN_PREFS_WINDOW(g_object_new(
3779 pidgin_prefs_window_get_type(), NULL));
3780 }
3781
3782 gtk_window_present(GTK_WINDOW(prefs));
3783 }
3784
3785 static void
3786 smiley_theme_pref_cb(const char *name, PurplePrefType type,
3787 gconstpointer value, gpointer data)
3788 {
3789 const gchar *theme_name = value;
3790 GList *themes, *it;
3791
3792 if (purple_strequal(theme_name, "none")) {
3793 purple_smiley_theme_set_current(NULL);
3794 return;
3795 }
3796
3797 /* XXX: could be cached when initializing prefs view */
3798 themes = pidgin_smiley_theme_get_all();
3799
3800 for (it = themes; it; it = g_list_next(it)) {
3801 PidginSmileyTheme *theme = it->data;
3802
3803 if (!purple_strequal(pidgin_smiley_theme_get_name(theme), theme_name))
3804 continue;
3805
3806 purple_smiley_theme_set_current(PURPLE_SMILEY_THEME(theme));
3807 }
3808 }
3809
3810 void
3811 pidgin_prefs_init(void)
3812 {
3813 purple_prefs_add_none(PIDGIN_PREFS_ROOT "");
3814 purple_prefs_add_none("/plugins/gtk");
3815
3816 #ifndef _WIN32
3817 /* Browsers */
3818 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/browsers");
3819 purple_prefs_add_int(PIDGIN_PREFS_ROOT "/browsers/place", PIDGIN_BROWSER_DEFAULT);
3820 purple_prefs_add_string(PIDGIN_PREFS_ROOT "/browsers/manual_command", "");
3821 purple_prefs_add_string(PIDGIN_PREFS_ROOT "/browsers/browser", "xdg-open");
3822 #endif
3823
3824 /* Plugins */
3825 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/plugins");
3826 purple_prefs_add_path_list(PIDGIN_PREFS_ROOT "/plugins/loaded", NULL);
3827
3828 /* File locations */
3829 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/filelocations");
3830 purple_prefs_add_path(PIDGIN_PREFS_ROOT "/filelocations/last_save_folder", "");
3831 purple_prefs_add_path(PIDGIN_PREFS_ROOT "/filelocations/last_open_folder", "");
3832 purple_prefs_add_path(PIDGIN_PREFS_ROOT "/filelocations/last_icon_folder", "");
3833
3834 /* Themes */
3835 prefs_themes_init();
3836
3837 /* Smiley Themes */
3838 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/smileys");
3839 purple_prefs_add_string(PIDGIN_PREFS_ROOT "/smileys/theme", "Default");
3840
3841 /* Smiley Callbacks */
3842 purple_prefs_connect_callback(&prefs, PIDGIN_PREFS_ROOT "/smileys/theme",
3843 smiley_theme_pref_cb, NULL);
3844
3845 #ifdef USE_VV
3846 /* Voice/Video */
3847 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig");
3848 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/audio");
3849 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/audio/src");
3850 purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/src/device", "");
3851 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/audio/sink");
3852 purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/device", "");
3853 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/video");
3854 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/video/src");
3855 purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/video/src/device", "");
3856 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/video");
3857 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/vvconfig/video/sink");
3858 purple_prefs_add_string(PIDGIN_PREFS_ROOT "/vvconfig/video/sink/device", "");
3859 #endif
3860
3861 pidgin_prefs_update_old();
3862 }
3863
3864 void
3865 pidgin_prefs_update_old(void)
3866 {
3867 /* Rename some old prefs */
3868 purple_prefs_rename(PIDGIN_PREFS_ROOT "/logging/log_ims", "/purple/logging/log_ims");
3869 purple_prefs_rename(PIDGIN_PREFS_ROOT "/logging/log_chats", "/purple/logging/log_chats");
3870 purple_prefs_rename("/purple/conversations/placement",
3871 PIDGIN_PREFS_ROOT "/conversations/placement");
3872
3873 purple_prefs_rename(PIDGIN_PREFS_ROOT "/conversations/im/raise_on_events", "/plugins/gtk/X11/notify/method_raise");
3874
3875 purple_prefs_rename_boolean_toggle(PIDGIN_PREFS_ROOT "/conversations/ignore_colors",
3876 PIDGIN_PREFS_ROOT "/conversations/show_incoming_formatting");
3877
3878 /*
3879 * This path pref changed to a string, so migrate. I know this will
3880 * break things for and confuse users that use multiple versions with
3881 * the same config directory, but I'm not inclined to want to deal with
3882 * that at the moment. -- rekkanoryo
3883 */
3884 if (purple_prefs_exists(PIDGIN_PREFS_ROOT "/browsers/command") &&
3885 purple_prefs_get_pref_type(PIDGIN_PREFS_ROOT "/browsers/command") ==
3886 PURPLE_PREF_PATH)
3887 {
3888 const char *str = purple_prefs_get_path(
3889 PIDGIN_PREFS_ROOT "/browsers/command");
3890 purple_prefs_set_string(
3891 PIDGIN_PREFS_ROOT "/browsers/manual_command", str);
3892 purple_prefs_remove(PIDGIN_PREFS_ROOT "/browsers/command");
3893 }
3894
3895 /* Remove some no-longer-used prefs */
3896 purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/auto_expand_contacts");
3897 purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/button_style");
3898 purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/grey_idle_buddies");
3899 purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/raise_on_events");
3900 purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/show_group_count");
3901 purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/show_warning_level");
3902 purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/tooltip_delay");
3903 purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/x");
3904 purple_prefs_remove(PIDGIN_PREFS_ROOT "/blist/y");
3905 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/button_type");
3906 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/ctrl_enter_sends");
3907 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/enter_sends");
3908 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/escape_closes");
3909 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/html_shortcuts");
3910 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/icons_on_tabs");
3911 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/send_formatting");
3912 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/show_smileys");
3913 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/show_urls_as_links");
3914 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/smiley_shortcuts");
3915 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/use_custom_bgcolor");
3916 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/use_custom_fgcolor");
3917 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/use_custom_font");
3918 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/use_custom_size");
3919 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/old_tab_complete");
3920 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/tab_completion");
3921 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/im/hide_on_send");
3922 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/color_nicks");
3923 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/raise_on_events");
3924 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/ignore_fonts");
3925 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/ignore_font_sizes");
3926 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/passthrough_unknown_commands");
3927 purple_prefs_remove(PIDGIN_PREFS_ROOT "/debug/timestamps");
3928 purple_prefs_remove(PIDGIN_PREFS_ROOT "/idle");
3929 purple_prefs_remove(PIDGIN_PREFS_ROOT "/logging/individual_logs");
3930 purple_prefs_remove(PIDGIN_PREFS_ROOT "/sound/signon");
3931 purple_prefs_remove(PIDGIN_PREFS_ROOT "/sound/silent_signon");
3932
3933 /* Convert old queuing prefs to hide_new 3-way pref. */
3934 if (purple_prefs_exists("/plugins/gtk/docklet/queue_messages") &&
3935 purple_prefs_get_bool("/plugins/gtk/docklet/queue_messages"))
3936 {
3937 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/im/hide_new", "always");
3938 }
3939 else if (purple_prefs_exists(PIDGIN_PREFS_ROOT "/away/queue_messages") &&
3940 purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/away/queue_messages"))
3941 {
3942 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/im/hide_new", "away");
3943 }
3944 purple_prefs_remove(PIDGIN_PREFS_ROOT "/away/queue_messages");
3945 purple_prefs_remove(PIDGIN_PREFS_ROOT "/away");
3946 purple_prefs_remove("/plugins/gtk/docklet/queue_messages");
3947
3948 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/default_width");
3949 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/chat/default_height");
3950 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/im/default_width");
3951 purple_prefs_remove(PIDGIN_PREFS_ROOT "/conversations/im/default_height");
3952 purple_prefs_rename(PIDGIN_PREFS_ROOT "/conversations/x",
3953 PIDGIN_PREFS_ROOT "/conversations/im/x");
3954 purple_prefs_rename(PIDGIN_PREFS_ROOT "/conversations/y",
3955 PIDGIN_PREFS_ROOT "/conversations/im/y");
3956
3957 /* Fixup vvconfig plugin prefs */
3958 if (purple_prefs_exists("/plugins/core/vvconfig/audio/src/device")) {
3959 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/src/device",
3960 purple_prefs_get_string("/plugins/core/vvconfig/audio/src/device"));
3961 }
3962 if (purple_prefs_exists("/plugins/core/vvconfig/audio/sink/device")) {
3963 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/device",
3964 purple_prefs_get_string("/plugins/core/vvconfig/audio/sink/device"));
3965 }
3966 if (purple_prefs_exists("/plugins/core/vvconfig/video/src/device")) {
3967 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/video/src/device",
3968 purple_prefs_get_string("/plugins/core/vvconfig/video/src/device"));
3969 }
3970 if (purple_prefs_exists("/plugins/gtk/vvconfig/video/sink/device")) {
3971 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/vvconfig/video/sink/device",
3972 purple_prefs_get_string("/plugins/gtk/vvconfig/video/sink/device"));
3973 }
3974
3975 purple_prefs_remove("/plugins/core/vvconfig");
3976 purple_prefs_remove("/plugins/gtk/vvconfig");
3977
3978 purple_prefs_remove(PIDGIN_PREFS_ROOT "/vvconfig/audio/src/plugin");
3979 purple_prefs_remove(PIDGIN_PREFS_ROOT "/vvconfig/audio/sink/plugin");
3980 purple_prefs_remove(PIDGIN_PREFS_ROOT "/vvconfig/video/src/plugin");
3981 purple_prefs_remove(PIDGIN_PREFS_ROOT "/vvconfig/video/sink/plugin");
3982
3983 #ifndef _WIN32
3984 /* Added in 3.0.0. */
3985 if (purple_prefs_get_int(PIDGIN_PREFS_ROOT "/browsers/place") == 1) {
3986 /* If the "open link in" pref is set to the old value for "existing
3987 window" then change it to "default." */
3988 purple_prefs_set_int(PIDGIN_PREFS_ROOT "/browsers/place",
3989 PIDGIN_BROWSER_DEFAULT);
3990 }
3991
3992 /* Added in 3.0.0. */
3993 if (g_str_equal(
3994 purple_prefs_get_string(PIDGIN_PREFS_ROOT "/browsers/browser"),
3995 "netscape")) {
3996 purple_prefs_set_string(PIDGIN_PREFS_ROOT "/browsers/browser", "xdg-open");
3997 }
3998 #endif /* !_WIN32 */
3999 }
4000
Git mirror of Pidgin's Mercurial repository