?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merged pidgin/main into default
[pidgin-git.git] / pidgin / gtkaccount.c
blobca8df0a96c3e914dec79547af0729ad10fe81183
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 "internal.h"
23 #include "pidgin.h"
24
25 #include "account.h"
26 #include "accountopt.h"
27 #include "core.h"
28 #include "debug.h"
29 #include "notify.h"
30 #include "plugins.h"
31 #include "prefs.h"
32 #include "protocol.h"
33 #include "request.h"
34 #include "savedstatuses.h"
35 #include "signals.h"
36 #include "util.h"
37
38 #include "gtkaccount.h"
39 #include "gtkblist.h"
40 #include "gtkdialogs.h"
41 #include "gtkutils.h"
42 #include "gtkstatusbox.h"
43 #include "pidginstock.h"
44 #include "minidialog.h"
45
46 #include "gtk3compat.h"
47
48 enum
49 {
50 COLUMN_ICON,
51 COLUMN_BUDDYICON,
52 COLUMN_USERNAME,
53 COLUMN_ENABLED,
54 COLUMN_PROTOCOL,
55 COLUMN_DATA,
56 NUM_COLUMNS
57 };
58
59 typedef struct
60 {
61 PurpleAccount *account;
62 char *username;
63 char *alias;
64
65 } PidginAccountAddUserData;
66
67 typedef struct
68 {
69 GtkWidget *window;
70 GtkWidget *treeview;
71
72 GtkWidget *modify_button;
73 GtkWidget *delete_button;
74 GtkWidget *notebook;
75
76 GtkListStore *model;
77 GtkTreeIter drag_iter;
78
79 GtkTreeViewColumn *username_col;
80
81 } AccountsWindow;
82
83 typedef struct
84 {
85 GtkWidget *widget;
86 gchar *setting;
87 PurplePrefType type;
88 } ProtocolOptEntry;
89
90 typedef struct
91 {
92 PidginAccountDialogType type;
93
94 PurpleAccount *account;
95 char *protocol_id;
96 PurpleProtocol *protocol;
97
98 PurpleProxyType new_proxy_type;
99
100 GList *user_split_entries;
101 GList *protocol_opt_entries;
102
103 GtkSizeGroup *sg;
104 GtkWidget *window;
105
106 GtkWidget *notebook;
107 GtkWidget *top_vbox;
108 GtkWidget *ok_button;
109 GtkWidget *register_button;
110
111 /* Login Options */
112 GtkWidget *login_frame;
113 GtkWidget *protocol_menu;
114 GtkWidget *password_box;
115 gchar *password;
116 GtkWidget *username_entry;
117 GdkRGBA username_entry_hint_color;
118 GtkWidget *password_entry;
119 GtkWidget *alias_entry;
120 GtkWidget *remember_pass_check;
121
122 /* User Options */
123 GtkWidget *user_frame;
124 GtkWidget *new_mail_check;
125 GtkWidget *icon_hbox;
126 GtkWidget *icon_check;
127 GtkWidget *icon_entry;
128 GtkWidget *icon_filesel;
129 GtkWidget *icon_preview;
130 GtkWidget *icon_text;
131 PurpleImage *icon_img;
132
133 /* Protocol Options */
134 GtkWidget *protocol_frame;
135
136 /* Proxy Options */
137 GtkWidget *proxy_frame;
138 GtkWidget *proxy_vbox;
139 GtkWidget *proxy_dropdown;
140 GtkWidget *proxy_host_entry;
141 GtkWidget *proxy_port_entry;
142 GtkWidget *proxy_user_entry;
143 GtkWidget *proxy_pass_entry;
144
145 /* Voice & Video Options*/
146 GtkWidget *voice_frame;
147 GtkWidget *suppression_check;
148
149 } AccountPrefsDialog;
150
151 static AccountsWindow *accounts_window = NULL;
152 static GHashTable *account_pref_wins;
153
154 static void add_account_to_liststore(PurpleAccount *account, gpointer user_data);
155 static void set_account(GtkListStore *store, GtkTreeIter *iter,
156 PurpleAccount *account, GdkPixbuf *global_buddyicon);
157
158 /**************************************************************************
159 * Add/Modify Account dialog
160 **************************************************************************/
161 static void add_login_options(AccountPrefsDialog *dialog, GtkWidget *parent);
162 static void add_user_options(AccountPrefsDialog *dialog, GtkWidget *parent);
163 static void add_account_options(AccountPrefsDialog *dialog);
164 static void add_proxy_options(AccountPrefsDialog *dialog, GtkWidget *parent);
165 static void add_voice_options(AccountPrefsDialog *dialog);
166
167 static GtkWidget *
168 add_pref_box(AccountPrefsDialog *dialog, GtkWidget *parent,
169 const char *text, GtkWidget *widget)
170 {
171 return pidgin_add_widget_to_vbox(GTK_BOX(parent), text, dialog->sg, widget, TRUE, NULL);
172 }
173
174 static void
175 set_dialog_icon(AccountPrefsDialog *dialog, gpointer data, size_t len, gchar *new_icon_path)
176 {
177 GdkPixbuf *pixbuf = NULL;
178 PurpleBuddyIconSpec *icon_spec = NULL;
179
180 if (dialog->icon_img) {
181 g_object_unref(dialog->icon_img);
182 dialog->icon_img = NULL;
183 }
184
185 if (new_icon_path != NULL) {
186 dialog->icon_img = purple_image_new_from_file(new_icon_path, TRUE);
187 purple_debug_warning("gtkaccount", "data was not necessary");
188 g_free(data);
189 } else if (data != NULL) {
190 if (len > 0)
191 dialog->icon_img = purple_image_new_from_data(data, len);
192 else
193 g_free(data);
194 }
195
196 if (dialog->icon_img != NULL) {
197 pixbuf = pidgin_pixbuf_from_image(dialog->icon_img);
198 }
199
200 if (dialog->protocol)
201 icon_spec = purple_protocol_get_icon_spec(dialog->protocol);
202
203 if (pixbuf && icon_spec && (icon_spec->scale_rules & PURPLE_ICON_SCALE_DISPLAY))
204 {
205 /* Scale the icon to something reasonable */
206 int width, height;
207 GdkPixbuf *scale;
208
209 pidgin_buddy_icon_get_scale_size(pixbuf, icon_spec,
210 PURPLE_ICON_SCALE_DISPLAY, &width, &height);
211 scale = gdk_pixbuf_scale_simple(pixbuf, width, height, GDK_INTERP_BILINEAR);
212
213 g_object_unref(G_OBJECT(pixbuf));
214 pixbuf = scale;
215 }
216
217 if (pixbuf == NULL)
218 {
219 /* Show a placeholder icon */
220 GtkIconSize icon_size = gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL);
221 pixbuf = gtk_widget_render_icon(dialog->window, PIDGIN_STOCK_TOOLBAR_SELECT_AVATAR,
222 icon_size, "PidginAccount");
223 }
224
225 gtk_image_set_from_pixbuf(GTK_IMAGE(dialog->icon_entry), pixbuf);
226 if (pixbuf != NULL)
227 g_object_unref(G_OBJECT(pixbuf));
228 }
229
230 static void
231 set_account_protocol_cb(GtkWidget *widget, const char *id,
232 AccountPrefsDialog *dialog)
233 {
234 PurpleProtocol *new_protocol;
235
236 new_protocol = purple_protocols_find(id);
237
238 dialog->protocol = new_protocol;
239
240 if (dialog->protocol != NULL)
241 {
242 PurpleProtocol *old_protocol = NULL;
243
244 if (dialog->protocol_id)
245 old_protocol = purple_protocols_find(dialog->protocol_id);
246
247 if (old_protocol != new_protocol) {
248 g_free(dialog->protocol_id);
249 dialog->protocol_id = g_strdup(purple_protocol_get_id(dialog->protocol));
250 }
251 }
252
253 if (dialog->account != NULL)
254 purple_account_clear_settings(dialog->account);
255
256 add_login_options(dialog, dialog->top_vbox);
257 add_user_options(dialog, dialog->top_vbox);
258 add_account_options(dialog);
259 add_voice_options(dialog);
260
261 gtk_widget_grab_focus(dialog->protocol_menu);
262
263 if (!dialog->protocol || !PURPLE_PROTOCOL_IMPLEMENTS(dialog->protocol, SERVER_IFACE, register_user)) {
264 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(
265 dialog->register_button), FALSE);
266 gtk_widget_hide(dialog->register_button);
267 } else {
268 if (dialog->protocol != NULL &&
269 (purple_protocol_get_options(dialog->protocol) & OPT_PROTO_REGISTER_NOSCREENNAME)) {
270 gtk_widget_set_sensitive(dialog->register_button, TRUE);
271 } else {
272 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(
273 dialog->register_button), FALSE);
274 gtk_widget_set_sensitive(dialog->register_button, FALSE);
275 }
276 gtk_widget_show(dialog->register_button);
277 }
278 }
279
280 static void
281 username_changed_cb(GtkEntry *entry, AccountPrefsDialog *dialog)
282 {
283 gboolean opt_noscreenname = (dialog->protocol != NULL &&
284 (purple_protocol_get_options(dialog->protocol) & OPT_PROTO_REGISTER_NOSCREENNAME));
285 gboolean username_valid = purple_validate(dialog->protocol,
286 gtk_entry_get_text(entry));
287
288 if (dialog->ok_button) {
289 if (opt_noscreenname && dialog->register_button &&
290 gtk_toggle_button_get_active(
291 GTK_TOGGLE_BUTTON(dialog->register_button)))
292 gtk_widget_set_sensitive(dialog->ok_button, TRUE);
293 else
294 gtk_widget_set_sensitive(dialog->ok_button,
295 username_valid);
296 }
297
298 if (dialog->register_button) {
299 if (opt_noscreenname)
300 gtk_widget_set_sensitive(dialog->register_button, TRUE);
301 else
302 gtk_widget_set_sensitive(dialog->register_button,
303 username_valid);
304 }
305 }
306
307 static void
308 register_button_cb(GtkWidget *checkbox, AccountPrefsDialog *dialog)
309 {
310 int register_checked = gtk_toggle_button_get_active(
311 GTK_TOGGLE_BUTTON(dialog->register_button));
312 int opt_noscreenname = (dialog->protocol != NULL &&
313 (purple_protocol_get_options(dialog->protocol) & OPT_PROTO_REGISTER_NOSCREENNAME));
314 int register_noscreenname = (opt_noscreenname && register_checked);
315
316 if (register_noscreenname) {
317 gtk_entry_set_text(GTK_ENTRY(dialog->username_entry), "");
318 gtk_entry_set_text(GTK_ENTRY(dialog->password_entry), "");
319 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->remember_pass_check), FALSE);
320 }
321 gtk_widget_set_sensitive(dialog->username_entry, !register_noscreenname);
322 gtk_widget_set_sensitive(dialog->password_entry, !register_noscreenname);
323 gtk_widget_set_sensitive(dialog->remember_pass_check, !register_noscreenname);
324
325 if (dialog->ok_button) {
326 gtk_widget_set_sensitive(dialog->ok_button,
327 (opt_noscreenname && register_checked) ||
328 *gtk_entry_get_text(GTK_ENTRY(dialog->username_entry))
329 != '\0');
330 }
331 }
332
333 static void
334 icon_filesel_choose_cb(const char *filename, gpointer data)
335 {
336 AccountPrefsDialog *dialog = data;
337
338 if (filename != NULL)
339 {
340 size_t len = 0;
341 gpointer data = pidgin_convert_buddy_icon(dialog->protocol, filename, &len);
342 set_dialog_icon(dialog, data, len, g_strdup(filename));
343 }
344
345 dialog->icon_filesel = NULL;
346 }
347
348 static void
349 icon_select_cb(GtkWidget *button, AccountPrefsDialog *dialog)
350 {
351 dialog->icon_filesel = pidgin_buddy_icon_chooser_new(GTK_WINDOW(dialog->window), icon_filesel_choose_cb, dialog);
352 gtk_widget_show_all(dialog->icon_filesel);
353 }
354
355 static void
356 icon_reset_cb(GtkWidget *button, AccountPrefsDialog *dialog)
357 {
358 set_dialog_icon(dialog, NULL, 0, NULL);
359 }
360
361 static void
362 account_dnd_recv(GtkWidget *widget, GdkDragContext *dc, gint x, gint y,
363 GtkSelectionData *sd, guint info, guint t, AccountPrefsDialog *dialog)
364 {
365 const gchar *name = (gchar *)gtk_selection_data_get_data(sd);
366 gint length = gtk_selection_data_get_length(sd);
367 gint format = gtk_selection_data_get_format(sd);
368
369 if ((length >= 0) && (format == 8)) {
370 /* Well, it looks like the drag event was cool.
371 * Let's do something with it */
372 if (!g_ascii_strncasecmp(name, "file://", 7)) {
373 GError *converr = NULL;
374 gchar *tmp, *rtmp;
375 gpointer data;
376 size_t len = 0;
377
378 /* It looks like we're dealing with a local file. */
379 if(!(tmp = g_filename_from_uri(name, NULL, &converr))) {
380 purple_debug(PURPLE_DEBUG_ERROR, "buddyicon", "%s\n",
381 (converr ? converr->message :
382 "g_filename_from_uri error"));
383 return;
384 }
385 if ((rtmp = strchr(tmp, '\r')) || (rtmp = strchr(tmp, '\n')))
386 *rtmp = '\0';
387
388 data = pidgin_convert_buddy_icon(dialog->protocol, tmp, &len);
389 /* This takes ownership of tmp */
390 set_dialog_icon(dialog, data, len, tmp);
391 }
392 gtk_drag_finish(dc, TRUE, FALSE, t);
393 }
394 gtk_drag_finish(dc, FALSE, FALSE, t);
395 }
396
397 static void
398 update_editable(PurpleConnection *gc, AccountPrefsDialog *dialog)
399 {
400 GtkStyleContext *style;
401 GdkRGBA color;
402 gboolean set;
403 GList *l;
404
405 if (dialog->account == NULL)
406 return;
407
408 if (gc != NULL && dialog->account != purple_connection_get_account(gc))
409 return;
410
411 set = !(purple_account_is_connected(dialog->account) || purple_account_is_connecting(dialog->account));
412 gtk_widget_set_sensitive(dialog->protocol_menu, set);
413 gtk_editable_set_editable(GTK_EDITABLE(dialog->username_entry), set);
414 style = set ? NULL : gtk_widget_get_style_context(dialog->username_entry);
415 if (style) {
416 gtk_style_context_get_background_color(style, GTK_STATE_FLAG_INSENSITIVE, &color);
417 gtk_widget_override_background_color(dialog->username_entry, GTK_STATE_FLAG_NORMAL, &color);
418 } else {
419 gtk_widget_override_background_color(dialog->username_entry, GTK_STATE_FLAG_NORMAL, NULL);
420 }
421
422 for (l = dialog->user_split_entries ; l != NULL ; l = l->next) {
423 if (l->data == NULL)
424 continue;
425 if (GTK_IS_EDITABLE(l->data)) {
426 gtk_editable_set_editable(GTK_EDITABLE(l->data), set);
427 style = set ? NULL : gtk_widget_get_style_context(GTK_WIDGET(l->data));
428 if (style) {
429 gtk_style_context_get_background_color(style, GTK_STATE_FLAG_INSENSITIVE, &color);
430 gtk_widget_override_background_color(GTK_WIDGET(l->data), GTK_STATE_FLAG_NORMAL, &color);
431 } else {
432 gtk_widget_override_background_color(GTK_WIDGET(l->data), GTK_STATE_FLAG_NORMAL, NULL);
433 }
434 } else {
435 gtk_widget_set_sensitive(GTK_WIDGET(l->data), set);
436 }
437 }
438 }
439
440 static void
441 add_login_options(AccountPrefsDialog *dialog, GtkWidget *parent)
442 {
443 GtkWidget *frame;
444 GtkWidget *hbox;
445 GtkWidget *vbox;
446 GtkWidget *entry;
447 GList *user_splits;
448 GList *l, *l2;
449 char *username = NULL;
450
451 if (dialog->protocol_menu != NULL)
452 {
453 g_object_ref(G_OBJECT(dialog->protocol_menu));
454 hbox = g_object_get_data(G_OBJECT(dialog->protocol_menu), "container");
455 gtk_container_remove(GTK_CONTAINER(hbox), dialog->protocol_menu);
456 }
457
458 if (dialog->login_frame != NULL)
459 gtk_widget_destroy(dialog->login_frame);
460
461 /* Build the login options frame. */
462 frame = pidgin_make_frame(parent, _("Login Options"));
463
464 /* cringe */
465 dialog->login_frame = gtk_widget_get_parent(gtk_widget_get_parent(frame));
466
467 gtk_box_reorder_child(GTK_BOX(parent), dialog->login_frame, 0);
468 gtk_widget_show(dialog->login_frame);
469
470 /* Main vbox */
471 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
472 gtk_container_add(GTK_CONTAINER(frame), vbox);
473 gtk_widget_show(vbox);
474
475 /* Protocol */
476 if (dialog->protocol_menu == NULL)
477 {
478 dialog->protocol_menu = pidgin_protocol_option_menu_new(
479 dialog->protocol_id, G_CALLBACK(set_account_protocol_cb), dialog);
480 g_object_ref(G_OBJECT(dialog->protocol_menu));
481 }
482
483 hbox = add_pref_box(dialog, vbox, _("Pro_tocol:"), dialog->protocol_menu);
484 g_object_set_data(G_OBJECT(dialog->protocol_menu), "container", hbox);
485
486 g_object_unref(G_OBJECT(dialog->protocol_menu));
487
488 /* Username */
489 dialog->username_entry = gtk_entry_new();
490 g_object_set(G_OBJECT(dialog->username_entry), "truncate-multiline", TRUE, NULL);
491
492 add_pref_box(dialog, vbox, _("_Username:"), dialog->username_entry);
493
494 if (dialog->account != NULL)
495 username = g_strdup(purple_account_get_username(dialog->account));
496
497 if (!username && dialog->protocol
498 && PURPLE_PROTOCOL_IMPLEMENTS(dialog->protocol, CLIENT_IFACE, get_account_text_table)) {
499 GHashTable *table;
500 const char *label;
501 table = purple_protocol_client_iface_get_account_text_table(dialog->protocol, NULL);
502 label = g_hash_table_lookup(table, "login_label");
503
504 gtk_entry_set_placeholder_text(GTK_ENTRY(dialog->username_entry), label);
505
506 g_hash_table_destroy(table);
507 }
508
509 g_signal_connect(G_OBJECT(dialog->username_entry), "changed",
510 G_CALLBACK(username_changed_cb), dialog);
511
512 /* Do the user split thang */
513 if (dialog->protocol == NULL)
514 user_splits = NULL;
515 else
516 user_splits = purple_protocol_get_user_splits(dialog->protocol);
517
518 if (dialog->user_split_entries != NULL) {
519 g_list_free(dialog->user_split_entries);
520 dialog->user_split_entries = NULL;
521 }
522
523 for (l = user_splits; l != NULL; l = l->next) {
524 PurpleAccountUserSplit *split = l->data;
525 char *buf;
526
527 if (purple_account_user_split_is_constant(split))
528 entry = NULL;
529 else {
530 buf = g_strdup_printf("_%s:", purple_account_user_split_get_text(split));
531 entry = gtk_entry_new();
532 add_pref_box(dialog, vbox, buf, entry);
533 g_free(buf);
534 }
535
536 dialog->user_split_entries =
537 g_list_append(dialog->user_split_entries, entry);
538 }
539
540 for (l = g_list_last(dialog->user_split_entries),
541 l2 = g_list_last(user_splits);
542 l != NULL && l2 != NULL;
543 l = l->prev, l2 = l2->prev) {
544
545 GtkWidget *entry = l->data;
546 PurpleAccountUserSplit *split = l2->data;
547 const char *value = NULL;
548 char *c;
549
550 if (dialog->account != NULL && username != NULL) {
551 if(purple_account_user_split_get_reverse(split))
552 c = strrchr(username,
553 purple_account_user_split_get_separator(split));
554 else
555 c = strchr(username,
556 purple_account_user_split_get_separator(split));
557
558 if (c != NULL) {
559 *c = '\0';
560 c++;
561
562 value = c;
563 }
564 }
565 if (value == NULL)
566 value = purple_account_user_split_get_default_value(split);
567
568 if (value != NULL && entry != NULL)
569 gtk_entry_set_text(GTK_ENTRY(entry), value);
570 }
571
572 if (username != NULL)
573 gtk_entry_set_text(GTK_ENTRY(dialog->username_entry), username);
574
575 g_free(username);
576
577
578 /* Password */
579 dialog->password_entry = gtk_entry_new();
580 gtk_entry_set_visibility(GTK_ENTRY(dialog->password_entry), FALSE);
581 dialog->password_box = add_pref_box(dialog, vbox, _("_Password:"),
582 dialog->password_entry);
583
584 /* Remember Password */
585 dialog->remember_pass_check =
586 gtk_check_button_new_with_mnemonic(_("Remember pass_word"));
587 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->remember_pass_check),
588 FALSE);
589 gtk_box_pack_start(GTK_BOX(vbox), dialog->remember_pass_check,
590 FALSE, FALSE, 0);
591 gtk_widget_show(dialog->remember_pass_check);
592
593 /* Set the fields. */
594 if (dialog->account != NULL) {
595 if (dialog->password && purple_account_get_remember_password(
596 dialog->account)) {
597 gtk_entry_set_text(GTK_ENTRY(dialog->password_entry),
598 dialog->password);
599 }
600
601 gtk_toggle_button_set_active(
602 GTK_TOGGLE_BUTTON(dialog->remember_pass_check),
603 purple_account_get_remember_password(dialog->account));
604 }
605
606 if (dialog->protocol != NULL &&
607 (purple_protocol_get_options(dialog->protocol) & OPT_PROTO_NO_PASSWORD)) {
608
609 gtk_widget_hide(dialog->password_box);
610 gtk_widget_hide(dialog->remember_pass_check);
611 }
612
613 /* Do not let the user change the protocol/username while connected. */
614 update_editable(NULL, dialog);
615 purple_signal_connect(purple_connections_get_handle(), "signing-on", dialog,
616 G_CALLBACK(update_editable), dialog);
617 purple_signal_connect(purple_connections_get_handle(), "signed-off", dialog,
618 G_CALLBACK(update_editable), dialog);
619 }
620
621 static void
622 icon_check_cb(GtkWidget *checkbox, AccountPrefsDialog *dialog)
623 {
624 gtk_widget_set_sensitive(dialog->icon_hbox, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)));
625 }
626
627 static void
628 add_user_options(AccountPrefsDialog *dialog, GtkWidget *parent)
629 {
630 GtkWidget *frame;
631 GtkWidget *vbox;
632 GtkWidget *vbox2;
633 GtkWidget *hbox;
634 GtkWidget *hbox2;
635 GtkWidget *button;
636 GtkWidget *label;
637
638 if (dialog->user_frame != NULL)
639 gtk_widget_destroy(dialog->user_frame);
640
641 /* Build the user options frame. */
642 frame = pidgin_make_frame(parent, _("User Options"));
643 dialog->user_frame = gtk_widget_get_parent(gtk_widget_get_parent(frame));
644
645 gtk_box_reorder_child(GTK_BOX(parent), dialog->user_frame, 1);
646 gtk_widget_show(dialog->user_frame);
647
648 /* Main vbox */
649 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
650 gtk_container_add(GTK_CONTAINER(frame), vbox);
651 gtk_widget_show(vbox);
652
653 /* Alias */
654 dialog->alias_entry = gtk_entry_new();
655 add_pref_box(dialog, vbox, _("_Local alias:"), dialog->alias_entry);
656
657 /* New mail notifications */
658 dialog->new_mail_check =
659 gtk_check_button_new_with_mnemonic(_("New _mail notifications"));
660 gtk_box_pack_start(GTK_BOX(vbox), dialog->new_mail_check, FALSE, FALSE, 0);
661 gtk_widget_show(dialog->new_mail_check);
662
663 /* Buddy icon */
664 dialog->icon_check = gtk_check_button_new_with_mnemonic(_("Use this buddy _icon for this account:"));
665 g_signal_connect(G_OBJECT(dialog->icon_check), "toggled", G_CALLBACK(icon_check_cb), dialog);
666 gtk_widget_show(dialog->icon_check);
667 gtk_box_pack_start(GTK_BOX(vbox), dialog->icon_check, FALSE, FALSE, 0);
668
669 dialog->icon_hbox = hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
670 gtk_widget_set_sensitive(hbox, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)));
671 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
672 gtk_widget_show(hbox);
673
674 label = gtk_label_new(" ");
675 gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
676 gtk_widget_show(label);
677
678 button = gtk_button_new();
679 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
680 gtk_widget_show(button);
681 g_signal_connect(G_OBJECT(button), "clicked",
682 G_CALLBACK(icon_select_cb), dialog);
683
684 dialog->icon_entry = gtk_image_new();
685 gtk_container_add(GTK_CONTAINER(button), dialog->icon_entry);
686 gtk_widget_show(dialog->icon_entry);
687 /* TODO: Uh, isn't this next line pretty useless? */
688 pidgin_set_accessible_label(dialog->icon_entry, GTK_LABEL(label));
689 if (dialog->icon_img) {
690 g_object_unref(dialog->icon_img);
691 dialog->icon_img = NULL;
692 }
693
694 vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
695 gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 0);
696 gtk_widget_show(vbox2);
697
698 hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PIDGIN_HIG_BOX_SPACE);
699 gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, PIDGIN_HIG_BORDER);
700 gtk_widget_show(hbox2);
701
702 button = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
703 g_signal_connect(G_OBJECT(button), "clicked",
704 G_CALLBACK(icon_reset_cb), dialog);
705 gtk_box_pack_start(GTK_BOX(hbox2), button, FALSE, FALSE, 0);
706 gtk_widget_show(button);
707
708 if (dialog->protocol != NULL) {
709 PurpleBuddyIconSpec *icon_spec = purple_protocol_get_icon_spec(dialog->protocol);
710 if (!(purple_protocol_get_options(dialog->protocol) & OPT_PROTO_MAIL_CHECK))
711 gtk_widget_hide(dialog->new_mail_check);
712
713 if (!icon_spec || icon_spec->format == NULL) {
714 gtk_widget_hide(dialog->icon_check);
715 gtk_widget_hide(dialog->icon_hbox);
716 }
717 }
718
719 if (dialog->account != NULL) {
720 PurpleImage *img;
721 gpointer data = NULL;
722 size_t len = 0;
723
724 if (purple_account_get_private_alias(dialog->account))
725 gtk_entry_set_text(GTK_ENTRY(dialog->alias_entry),
726 purple_account_get_private_alias(dialog->account));
727
728 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->new_mail_check),
729 purple_account_get_check_mail(dialog->account));
730
731 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->icon_check),
732 !purple_account_get_bool(dialog->account, "use-global-buddyicon",
733 TRUE));
734
735 img = purple_buddy_icons_find_account_icon(dialog->account);
736 if (img)
737 {
738 len = purple_image_get_size(img);
739 data = g_memdup(purple_image_get_data(img), len);
740 }
741 set_dialog_icon(dialog, data, len,
742 g_strdup(purple_account_get_buddy_icon_path(dialog->account)));
743 } else {
744 set_dialog_icon(dialog, NULL, 0, NULL);
745 }
746
747 #if 0
748 if (!dialog->protocol ||
749 (!(purple_protocol_get_options(dialog->protocol) & OPT_PROTO_MAIL_CHECK) &&
750 (purple_protocol_get_icon_spec(dialog->protocol).format == NULL))) {
751
752 /* Nothing to see :( aww. */
753 gtk_widget_hide(dialog->user_frame);
754 }
755 #endif
756 }
757
758 static void
759 add_account_options(AccountPrefsDialog *dialog)
760 {
761 PurpleAccountOption *option;
762 PurpleAccount *account;
763 GtkWidget *vbox, *check, *entry, *combo;
764 GList *list, *node;
765 gint i, idx, int_value;
766 GtkListStore *model;
767 GtkTreeIter iter;
768 GtkCellRenderer *renderer;
769 PurpleKeyValuePair *kvp;
770 GList *l;
771 char buf[1024];
772 char *title, *tmp;
773 const char *str_value;
774 gboolean bool_value;
775 ProtocolOptEntry *opt_entry;
776 const GSList *str_hints;
777
778 if (dialog->protocol_frame != NULL) {
779 gtk_notebook_remove_page (GTK_NOTEBOOK(dialog->notebook), 1);
780 dialog->protocol_frame = NULL;
781 }
782
783 while (dialog->protocol_opt_entries != NULL) {
784 ProtocolOptEntry *opt_entry = dialog->protocol_opt_entries->data;
785 g_free(opt_entry->setting);
786 g_free(opt_entry);
787 dialog->protocol_opt_entries = g_list_delete_link(dialog->protocol_opt_entries, dialog->protocol_opt_entries);
788 }
789
790 if (dialog->protocol == NULL ||
791 purple_protocol_get_account_options(dialog->protocol) == NULL)
792 return;
793
794 account = dialog->account;
795
796 /* Main vbox */
797 dialog->protocol_frame = vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
798 gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BORDER);
799 gtk_notebook_insert_page(GTK_NOTEBOOK(dialog->notebook), vbox,
800 gtk_label_new_with_mnemonic(_("Ad_vanced")), 1);
801 gtk_widget_show(vbox);
802
803 for (l = purple_protocol_get_account_options(dialog->protocol); l != NULL; l = l->next)
804 {
805 option = (PurpleAccountOption *)l->data;
806
807 opt_entry = g_new0(ProtocolOptEntry, 1);
808 opt_entry->type = purple_account_option_get_pref_type(option);
809 opt_entry->setting = g_strdup(purple_account_option_get_setting(option));
810
811 switch (opt_entry->type)
812 {
813 case PURPLE_PREF_BOOLEAN:
814 if (account == NULL ||
815 strcmp(purple_account_get_protocol_id(account),
816 dialog->protocol_id))
817 {
818 bool_value = purple_account_option_get_default_bool(option);
819 }
820 else
821 {
822 bool_value = purple_account_get_bool(account,
823 purple_account_option_get_setting(option),
824 purple_account_option_get_default_bool(option));
825 }
826
827 tmp = g_strconcat("_", purple_account_option_get_text(option), NULL);
828 opt_entry->widget = check = gtk_check_button_new_with_mnemonic(tmp);
829 g_free(tmp);
830
831 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),
832 bool_value);
833
834 gtk_box_pack_start(GTK_BOX(vbox), check, FALSE, FALSE, 0);
835 gtk_widget_show(check);
836 break;
837
838 case PURPLE_PREF_INT:
839 if (account == NULL ||
840 strcmp(purple_account_get_protocol_id(account),
841 dialog->protocol_id))
842 {
843 int_value = purple_account_option_get_default_int(option);
844 }
845 else
846 {
847 int_value = purple_account_get_int(account,
848 purple_account_option_get_setting(option),
849 purple_account_option_get_default_int(option));
850 }
851
852 g_snprintf(buf, sizeof(buf), "%d", int_value);
853
854 opt_entry->widget = entry = gtk_entry_new();
855 gtk_entry_set_text(GTK_ENTRY(entry), buf);
856
857 title = g_strdup_printf("_%s:",
858 purple_account_option_get_text(option));
859 add_pref_box(dialog, vbox, title, entry);
860 g_free(title);
861 break;
862
863 case PURPLE_PREF_STRING:
864 if (account == NULL ||
865 strcmp(purple_account_get_protocol_id(account),
866 dialog->protocol_id))
867 {
868 str_value = purple_account_option_get_default_string(option);
869 }
870 else
871 {
872 str_value = purple_account_get_string(account,
873 purple_account_option_get_setting(option),
874 purple_account_option_get_default_string(option));
875 }
876
877 str_hints = purple_account_option_string_get_hints(option);
878 if (str_hints)
879 {
880 const GSList *hint_it = str_hints;
881 entry = gtk_combo_box_text_new_with_entry();
882 while (hint_it)
883 {
884 const gchar *hint = hint_it->data;
885 hint_it = g_slist_next(hint_it);
886 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(entry),
887 hint);
888 }
889 }
890 else
891 entry = gtk_entry_new();
892
893 opt_entry->widget = entry;
894 if (purple_account_option_string_get_masked(option) && str_hints)
895 g_warn_if_reached();
896 else if (purple_account_option_string_get_masked(option))
897 {
898 gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
899 }
900
901 if (str_value != NULL && str_hints)
902 gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(entry))),
903 str_value);
904 else
905 gtk_entry_set_text(GTK_ENTRY(entry), str_value ? str_value : "");
906
907 title = g_strdup_printf("_%s:",
908 purple_account_option_get_text(option));
909 add_pref_box(dialog, vbox, title, entry);
910 g_free(title);
911 break;
912
913 case PURPLE_PREF_STRING_LIST:
914 i = 0;
915 idx = 0;
916
917 if (account == NULL ||
918 strcmp(purple_account_get_protocol_id(account),
919 dialog->protocol_id))
920 {
921 str_value = purple_account_option_get_default_list_value(option);
922 }
923 else
924 {
925 str_value = purple_account_get_string(account,
926 purple_account_option_get_setting(option),
927 purple_account_option_get_default_list_value(option));
928 }
929
930 list = purple_account_option_get_list(option);
931 model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
932 opt_entry->widget = combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
933
934 /* Loop through list of PurpleKeyValuePair items */
935 for (node = list; node != NULL; node = node->next) {
936 if (node->data != NULL) {
937 kvp = (PurpleKeyValuePair *) node->data;
938 if ((kvp->value != NULL) && (str_value != NULL) &&
939 !g_utf8_collate(kvp->value, str_value))
940 idx = i;
941
942 gtk_list_store_append(model, &iter);
943 gtk_list_store_set(model, &iter,
944 0, kvp->key,
945 1, kvp->value,
946 -1);
947 }
948
949 i++;
950 }
951
952 /* Set default */
953 gtk_combo_box_set_active(GTK_COMBO_BOX(combo), idx);
954
955 /* Define renderer */
956 renderer = gtk_cell_renderer_text_new();
957 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer,
958 TRUE);
959 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo),
960 renderer, "text", 0, NULL);
961
962 title = g_strdup_printf("_%s:",
963 purple_account_option_get_text(option));
964 add_pref_box(dialog, vbox, title, combo);
965 g_free(title);
966 break;
967
968 default:
969 purple_debug_error("gtkaccount", "Invalid Account Option pref type (%d)\n",
970 opt_entry->type);
971 g_free(opt_entry->setting);
972 g_free(opt_entry);
973 continue;
974 }
975
976 dialog->protocol_opt_entries =
977 g_list_append(dialog->protocol_opt_entries, opt_entry);
978
979 }
980 }
981
982 static GtkWidget *
983 make_proxy_dropdown(void)
984 {
985 GtkWidget *dropdown;
986 GtkListStore *model;
987 GtkTreeIter iter;
988 GtkCellRenderer *renderer;
989
990 model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
991 dropdown = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
992
993 gtk_list_store_append(model, &iter);
994 gtk_list_store_set(model, &iter,
995 0, purple_running_gnome() ? _("Use GNOME Proxy Settings")
996 :_("Use Global Proxy Settings"),
997 1, PURPLE_PROXY_USE_GLOBAL,
998 -1);
999
1000 gtk_list_store_append(model, &iter);
1001 gtk_list_store_set(model, &iter,
1002 0, _("No Proxy"),
1003 1, PURPLE_PROXY_NONE,
1004 -1);
1005
1006 gtk_list_store_append(model, &iter);
1007 gtk_list_store_set(model, &iter,
1008 0, _("SOCKS 4"),
1009 1, PURPLE_PROXY_SOCKS4,
1010 -1);
1011
1012 gtk_list_store_append(model, &iter);
1013 gtk_list_store_set(model, &iter,
1014 0, _("SOCKS 5"),
1015 1, PURPLE_PROXY_SOCKS5,
1016 -1);
1017
1018 gtk_list_store_append(model, &iter);
1019 gtk_list_store_set(model, &iter,
1020 0, _("Tor/Privacy (SOCKS5)"),
1021 1, PURPLE_PROXY_TOR,
1022 -1);
1023
1024 gtk_list_store_append(model, &iter);
1025 gtk_list_store_set(model, &iter,
1026 0, _("HTTP"),
1027 1, PURPLE_PROXY_HTTP,
1028 -1);
1029
1030 gtk_list_store_append(model, &iter);
1031 gtk_list_store_set(model, &iter,
1032 0, _("Use Environmental Settings"),
1033 1, PURPLE_PROXY_USE_ENVVAR,
1034 -1);
1035
1036 renderer = gtk_cell_renderer_text_new();
1037 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dropdown), renderer, TRUE);
1038 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(dropdown), renderer,
1039 "text", 0, NULL);
1040
1041 return dropdown;
1042 }
1043
1044 static void
1045 proxy_type_changed_cb(GtkWidget *menu, AccountPrefsDialog *dialog)
1046 {
1047 GtkTreeIter iter;
1048
1049 if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(menu), &iter)) {
1050 int int_value;
1051 gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(menu)), &iter,
1052 1, &int_value, -1);
1053 dialog->new_proxy_type = int_value;
1054 }
1055
1056 if (dialog->new_proxy_type == PURPLE_PROXY_USE_GLOBAL ||
1057 dialog->new_proxy_type == PURPLE_PROXY_NONE ||
1058 dialog->new_proxy_type == PURPLE_PROXY_USE_ENVVAR) {
1059
1060 gtk_widget_hide(dialog->proxy_vbox);
1061 }
1062 else
1063 gtk_widget_show_all(dialog->proxy_vbox);
1064 }
1065
1066 static void
1067 port_popup_cb(GtkWidget *w, GtkMenu *menu, gpointer data)
1068 {
1069 GtkWidget *item1;
1070 GtkWidget *item2;
1071
1072 /* This is an easter egg.
1073 It means one of two things, both intended as humourus:
1074 A) your network is really slow and you have nothing better to do than
1075 look at butterflies.
1076 B)You are looking really closely at something that shouldn't matter. */
1077 item1 = gtk_menu_item_new_with_label(_("If you look real closely"));
1078
1079 /* This is an easter egg. See the comment on the previous line in the source. */
1080 item2 = gtk_menu_item_new_with_label(_("you can see the butterflies mating"));
1081
1082 gtk_widget_show(item1);
1083 gtk_widget_show(item2);
1084
1085 /* Prepend these in reverse order so they appear correctly. */
1086 gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), item2);
1087 gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), item1);
1088 }
1089
1090 static void
1091 add_proxy_options(AccountPrefsDialog *dialog, GtkWidget *parent)
1092 {
1093 PurpleProxyInfo *proxy_info;
1094 GtkWidget *vbox;
1095 GtkWidget *vbox2;
1096 GtkTreeIter iter;
1097 GtkTreeModel *proxy_model;
1098
1099 if (dialog->proxy_frame != NULL)
1100 gtk_widget_destroy(dialog->proxy_frame);
1101
1102 /* Main vbox */
1103 dialog->proxy_frame = vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
1104 gtk_container_add(GTK_CONTAINER(parent), vbox);
1105 gtk_widget_show(vbox);
1106
1107 /* Proxy Type drop-down. */
1108 dialog->proxy_dropdown = make_proxy_dropdown();
1109
1110 add_pref_box(dialog, vbox, _("Proxy _type:"), dialog->proxy_dropdown);
1111
1112 /* Setup the second vbox, which may be hidden at times. */
1113 dialog->proxy_vbox = vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BOX_SPACE);
1114 gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, FALSE, PIDGIN_HIG_BORDER);
1115 gtk_widget_show(vbox2);
1116
1117 /* Host */
1118 dialog->proxy_host_entry = gtk_entry_new();
1119 add_pref_box(dialog, vbox2, _("_Host:"), dialog->proxy_host_entry);
1120
1121 /* Port */
1122 dialog->proxy_port_entry = gtk_entry_new();
1123 add_pref_box(dialog, vbox2, _("_Port:"), dialog->proxy_port_entry);
1124
1125 g_signal_connect(G_OBJECT(dialog->proxy_port_entry), "populate-popup",
1126 G_CALLBACK(port_popup_cb), NULL);
1127
1128 /* User */
1129 dialog->proxy_user_entry = gtk_entry_new();
1130
1131 add_pref_box(dialog, vbox2, _("_Username:"), dialog->proxy_user_entry);
1132
1133 /* Password */
1134 dialog->proxy_pass_entry = gtk_entry_new();
1135 gtk_entry_set_visibility(GTK_ENTRY(dialog->proxy_pass_entry), FALSE);
1136 add_pref_box(dialog, vbox2, _("Pa_ssword:"), dialog->proxy_pass_entry);
1137
1138 if (dialog->account != NULL &&
1139 (proxy_info = purple_account_get_proxy_info(dialog->account)) != NULL) {
1140 const char *value;
1141 int int_val;
1142
1143 dialog->new_proxy_type = purple_proxy_info_get_proxy_type(proxy_info);
1144
1145 if ((value = purple_proxy_info_get_host(proxy_info)) != NULL)
1146 gtk_entry_set_text(GTK_ENTRY(dialog->proxy_host_entry), value);
1147
1148 if ((int_val = purple_proxy_info_get_port(proxy_info)) != 0) {
1149 char buf[11];
1150
1151 g_snprintf(buf, sizeof(buf), "%d", int_val);
1152
1153 gtk_entry_set_text(GTK_ENTRY(dialog->proxy_port_entry), buf);
1154 }
1155
1156 if ((value = purple_proxy_info_get_username(proxy_info)) != NULL)
1157 gtk_entry_set_text(GTK_ENTRY(dialog->proxy_user_entry), value);
1158
1159 if ((value = purple_proxy_info_get_password(proxy_info)) != NULL)
1160 gtk_entry_set_text(GTK_ENTRY(dialog->proxy_pass_entry), value);
1161
1162 } else
1163 dialog->new_proxy_type = PURPLE_PROXY_USE_GLOBAL;
1164
1165 proxy_model = gtk_combo_box_get_model(
1166 GTK_COMBO_BOX(dialog->proxy_dropdown));
1167 if (gtk_tree_model_get_iter_first(proxy_model, &iter)) {
1168 int int_val;
1169 do {
1170 gtk_tree_model_get(proxy_model, &iter, 1, &int_val, -1);
1171 if (int_val == dialog->new_proxy_type) {
1172 gtk_combo_box_set_active_iter(
1173 GTK_COMBO_BOX(dialog->proxy_dropdown), &iter);
1174 break;
1175 }
1176 } while(gtk_tree_model_iter_next(proxy_model, &iter));
1177 }
1178
1179 proxy_type_changed_cb(dialog->proxy_dropdown, dialog);
1180
1181 /* Connect signals. */
1182 g_signal_connect(G_OBJECT(dialog->proxy_dropdown), "changed",
1183 G_CALLBACK(proxy_type_changed_cb), dialog);
1184 }
1185
1186 static void
1187 add_voice_options(AccountPrefsDialog *dialog)
1188 {
1189 #ifdef USE_VV
1190 if (!dialog->protocol || !PURPLE_PROTOCOL_IMPLEMENTS(dialog->protocol, MEDIA_IFACE, initiate_session)) {
1191 if (dialog->voice_frame) {
1192 gtk_widget_destroy(dialog->voice_frame);
1193 dialog->voice_frame = NULL;
1194 dialog->suppression_check = NULL;
1195 }
1196 return;
1197 }
1198
1199 if (!dialog->voice_frame) {
1200 dialog->voice_frame = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
1201 gtk_container_set_border_width(GTK_CONTAINER(dialog->voice_frame),
1202 PIDGIN_HIG_BORDER);
1203
1204 dialog->suppression_check =
1205 gtk_check_button_new_with_mnemonic(_("Use _silence suppression"));
1206 gtk_box_pack_start(GTK_BOX(dialog->voice_frame), dialog->suppression_check,
1207 FALSE, FALSE, 0);
1208
1209 gtk_notebook_append_page(GTK_NOTEBOOK(dialog->notebook),
1210 dialog->voice_frame, gtk_label_new_with_mnemonic(_("_Voice and Video")));
1211 gtk_widget_show_all(dialog->voice_frame);
1212 }
1213
1214 if (dialog->account) {
1215 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->suppression_check),
1216 purple_account_get_silence_suppression(dialog->account));
1217 } else {
1218 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->suppression_check), FALSE);
1219 }
1220 #endif
1221 }
1222
1223 static gboolean
1224 account_win_destroy_cb(GtkWidget *w, GdkEvent *event,
1225 AccountPrefsDialog *dialog)
1226 {
1227 g_hash_table_remove(account_pref_wins, dialog->account);
1228
1229 gtk_widget_destroy(dialog->window);
1230
1231 g_list_free(dialog->user_split_entries);
1232 while (dialog->protocol_opt_entries != NULL) {
1233 ProtocolOptEntry *opt_entry = dialog->protocol_opt_entries->data;
1234 g_free(opt_entry->setting);
1235 g_free(opt_entry);
1236 dialog->protocol_opt_entries = g_list_delete_link(dialog->protocol_opt_entries, dialog->protocol_opt_entries);
1237 }
1238 g_free(dialog->protocol_id);
1239 g_object_unref(dialog->sg);
1240
1241 if (dialog->icon_img)
1242 g_object_unref(dialog->icon_img);
1243
1244 if (dialog->icon_filesel)
1245 gtk_widget_destroy(dialog->icon_filesel);
1246
1247 purple_signals_disconnect_by_handle(dialog);
1248
1249 purple_str_wipe(dialog->password);
1250
1251 g_free(dialog);
1252 return FALSE;
1253 }
1254
1255 static void
1256 cancel_account_prefs_cb(GtkWidget *w, AccountPrefsDialog *dialog)
1257 {
1258 account_win_destroy_cb(NULL, NULL, dialog);
1259 }
1260
1261 static void
1262 account_register_cb(PurpleAccount *account, gboolean succeeded, void *user_data)
1263 {
1264 if (succeeded)
1265 {
1266 const PurpleSavedStatus *saved_status = purple_savedstatus_get_current();
1267 purple_signal_emit(pidgin_accounts_get_handle(), "account-modified", account);
1268
1269 if (saved_status != NULL && purple_account_get_remember_password(account)) {
1270 purple_savedstatus_activate_for_account(saved_status, account);
1271 purple_account_set_enabled(account, PIDGIN_UI, TRUE);
1272 }
1273 }
1274 else
1275 purple_accounts_delete(account);
1276 }
1277
1278 static void
1279 ok_account_prefs_cb(GtkWidget *w, AccountPrefsDialog *dialog)
1280 {
1281 PurpleProxyInfo *proxy_info = NULL;
1282 GList *l, *l2;
1283 const char *value;
1284 char *username;
1285 char *tmp;
1286 gboolean new_acct = FALSE, icon_change = FALSE;
1287 PurpleAccount *account;
1288 gboolean remember;
1289 PurpleBuddyIconSpec *icon_spec = NULL;
1290
1291 /* Build the username string. */
1292 username = g_strdup(gtk_entry_get_text(GTK_ENTRY(dialog->username_entry)));
1293
1294 if (dialog->protocol != NULL)
1295 {
1296 for (l = purple_protocol_get_user_splits(dialog->protocol),
1297 l2 = dialog->user_split_entries;
1298 l != NULL && l2 != NULL;
1299 l = l->next, l2 = l2->next)
1300 {
1301 PurpleAccountUserSplit *split = l->data;
1302 GtkEntry *entry = l2->data;
1303 char sep[2] = " ";
1304
1305 value = entry ? gtk_entry_get_text(entry) : "";
1306 if (!value)
1307 value = "";
1308
1309 *sep = purple_account_user_split_get_separator(split);
1310
1311 tmp = g_strconcat(username, sep,
1312 (*value ? value :
1313 purple_account_user_split_get_default_value(split)),
1314 NULL);
1315
1316 g_free(username);
1317 username = tmp;
1318 }
1319 }
1320
1321 if (dialog->account == NULL)
1322 {
1323 if (purple_accounts_find(username, dialog->protocol_id) != NULL) {
1324 purple_debug_warning("gtkaccount", "Trying to add a duplicate %s account (%s).\n",
1325 dialog->protocol_id, username);
1326
1327 purple_notify_error(NULL, NULL, _("Unable to save new account"),
1328 _("An account already exists with the specified criteria."), NULL);
1329
1330 g_free(username);
1331 return;
1332 }
1333
1334 if (purple_accounts_get_all() == NULL) {
1335 /* We're adding our first account. Be polite and show the buddy list */
1336 purple_blist_set_visible(TRUE);
1337 }
1338
1339 account = purple_account_new(username, dialog->protocol_id);
1340 new_acct = TRUE;
1341 }
1342 else
1343 {
1344 account = dialog->account;
1345
1346 /* Protocol */
1347 purple_account_set_protocol_id(account, dialog->protocol_id);
1348 }
1349
1350 /* Alias */
1351 value = gtk_entry_get_text(GTK_ENTRY(dialog->alias_entry));
1352
1353 if (*value != '\0')
1354 purple_account_set_private_alias(account, value);
1355 else
1356 purple_account_set_private_alias(account, NULL);
1357
1358 /* Buddy Icon */
1359 if (dialog->protocol != NULL)
1360 icon_spec = purple_protocol_get_icon_spec(dialog->protocol);
1361
1362 if (icon_spec && icon_spec->format != NULL)
1363 {
1364 const char *filename;
1365
1366 if (new_acct || purple_account_get_bool(account, "use-global-buddyicon", TRUE) ==
1367 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)))
1368 {
1369 icon_change = TRUE;
1370 }
1371 purple_account_set_bool(account, "use-global-buddyicon", !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)));
1372
1373 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)))
1374 {
1375 if (dialog->icon_img)
1376 {
1377 size_t len = purple_image_get_size(dialog->icon_img);
1378 purple_buddy_icons_set_account_icon(account,
1379 g_memdup(purple_image_get_data(dialog->icon_img), len), len);
1380 purple_account_set_buddy_icon_path(account,
1381 purple_image_get_path(dialog->icon_img));
1382 }
1383 else
1384 {
1385 purple_buddy_icons_set_account_icon(account, NULL, 0);
1386 purple_account_set_buddy_icon_path(account, NULL);
1387 }
1388 }
1389 else if ((filename = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/accounts/buddyicon")) && icon_change)
1390 {
1391 size_t len = 0;
1392 gpointer data = pidgin_convert_buddy_icon(dialog->protocol, filename, &len);
1393 purple_account_set_buddy_icon_path(account, filename);
1394 purple_buddy_icons_set_account_icon(account, data, len);
1395 }
1396 }
1397
1398
1399 /* Remember Password */
1400 remember = gtk_toggle_button_get_active(
1401 GTK_TOGGLE_BUTTON(dialog->remember_pass_check));
1402 if(!remember)
1403 purple_keyring_set_password(account, NULL, NULL, NULL);
1404
1405 purple_account_set_remember_password(account, remember);
1406
1407 /* Check Mail */
1408 if (dialog->protocol && purple_protocol_get_options(dialog->protocol) & OPT_PROTO_MAIL_CHECK)
1409 purple_account_set_check_mail(account,
1410 gtk_toggle_button_get_active(
1411 GTK_TOGGLE_BUTTON(dialog->new_mail_check)));
1412
1413 /* Password */
1414 value = gtk_entry_get_text(GTK_ENTRY(dialog->password_entry));
1415
1416 /*
1417 * We set the password if this is a new account because new accounts
1418 * will be set to online, and if the user has entered a password into
1419 * the account editor (but has not checked the 'save' box), then we
1420 * don't want to prompt them.
1421 */
1422 if ((purple_account_get_remember_password(account) || new_acct) && (*value != '\0'))
1423 purple_account_set_password(account, value, NULL, NULL);
1424 else
1425 purple_account_set_password(account, NULL, NULL, NULL);
1426
1427 purple_account_set_username(account, username);
1428 g_free(username);
1429
1430 /* Add the protocol settings */
1431 if (dialog->protocol) {
1432 ProtocolOptEntry *opt_entry;
1433 GtkTreeIter iter;
1434 char *value2;
1435 int int_value;
1436 gboolean bool_value;
1437
1438 for (l2 = dialog->protocol_opt_entries; l2; l2 = l2->next) {
1439
1440 opt_entry = l2->data;
1441
1442 switch (opt_entry->type) {
1443 case PURPLE_PREF_STRING:
1444 if (GTK_IS_COMBO_BOX(opt_entry->widget))
1445 value = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(opt_entry->widget));
1446 else
1447 value = gtk_entry_get_text(GTK_ENTRY(opt_entry->widget));
1448 purple_account_set_string(account, opt_entry->setting, value);
1449 break;
1450
1451 case PURPLE_PREF_INT:
1452 int_value = atoi(gtk_entry_get_text(GTK_ENTRY(opt_entry->widget)));
1453 purple_account_set_int(account, opt_entry->setting, int_value);
1454 break;
1455
1456 case PURPLE_PREF_BOOLEAN:
1457 bool_value =
1458 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(opt_entry->widget));
1459 purple_account_set_bool(account, opt_entry->setting, bool_value);
1460 break;
1461
1462 case PURPLE_PREF_STRING_LIST:
1463 value2 = NULL;
1464 if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(opt_entry->widget), &iter))
1465 gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(opt_entry->widget)), &iter, 1, &value2, -1);
1466 purple_account_set_string(account, opt_entry->setting, value2);
1467 break;
1468
1469 default:
1470 break;
1471 }
1472 }
1473 }
1474
1475 /* Set the proxy stuff. */
1476 proxy_info = purple_account_get_proxy_info(account);
1477
1478 /* Create the proxy info if it doesn't exist. */
1479 if (proxy_info == NULL) {
1480 proxy_info = purple_proxy_info_new();
1481 purple_account_set_proxy_info(account, proxy_info);
1482 }
1483
1484 /* Set the proxy info type. */
1485 purple_proxy_info_set_proxy_type(proxy_info, dialog->new_proxy_type);
1486
1487 /* Host */
1488 value = gtk_entry_get_text(GTK_ENTRY(dialog->proxy_host_entry));
1489
1490 if (*value != '\0')
1491 purple_proxy_info_set_host(proxy_info, value);
1492 else
1493 purple_proxy_info_set_host(proxy_info, NULL);
1494
1495 /* Port */
1496 value = gtk_entry_get_text(GTK_ENTRY(dialog->proxy_port_entry));
1497
1498 if (*value != '\0')
1499 purple_proxy_info_set_port(proxy_info, atoi(value));
1500 else
1501 purple_proxy_info_set_port(proxy_info, 0);
1502
1503 /* Username */
1504 value = gtk_entry_get_text(GTK_ENTRY(dialog->proxy_user_entry));
1505
1506 if (*value != '\0')
1507 purple_proxy_info_set_username(proxy_info, value);
1508 else
1509 purple_proxy_info_set_username(proxy_info, NULL);
1510
1511 /* Password */
1512 value = gtk_entry_get_text(GTK_ENTRY(dialog->proxy_pass_entry));
1513
1514 if (*value != '\0')
1515 purple_proxy_info_set_password(proxy_info, value);
1516 else
1517 purple_proxy_info_set_password(proxy_info, NULL);
1518
1519 /* If there are no values set then proxy_info NULL */
1520 if ((purple_proxy_info_get_proxy_type(proxy_info) == PURPLE_PROXY_USE_GLOBAL) &&
1521 (purple_proxy_info_get_host(proxy_info) == NULL) &&
1522 (purple_proxy_info_get_port(proxy_info) == 0) &&
1523 (purple_proxy_info_get_username(proxy_info) == NULL) &&
1524 (purple_proxy_info_get_password(proxy_info) == NULL))
1525 {
1526 purple_account_set_proxy_info(account, NULL);
1527 proxy_info = NULL;
1528 }
1529
1530 /* Voice and Video settings */
1531 if (dialog->voice_frame) {
1532 purple_account_set_silence_suppression(account,
1533 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->suppression_check)));
1534 }
1535
1536 /* If this is a new account, add it to our list */
1537 if (new_acct)
1538 purple_accounts_add(account);
1539 else
1540 purple_signal_emit(pidgin_accounts_get_handle(), "account-modified", account);
1541
1542 /* If this is a new account, then sign on! */
1543 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->register_button))) {
1544 purple_account_set_register_callback(account, account_register_cb, NULL);
1545 purple_account_register(account);
1546 } else if (new_acct) {
1547 const PurpleSavedStatus *saved_status;
1548
1549 saved_status = purple_savedstatus_get_current();
1550 if (saved_status != NULL) {
1551 purple_savedstatus_activate_for_account(saved_status, account);
1552 purple_account_set_enabled(account, PIDGIN_UI, TRUE);
1553 }
1554 }
1555
1556 /* We no longer need the data from the dialog window */
1557 account_win_destroy_cb(NULL, NULL, dialog);
1558
1559 }
1560
1561 static const GtkTargetEntry dnd_targets[] = {
1562 {"text/plain", 0, 0},
1563 {"text/uri-list", 0, 1},
1564 {"STRING", 0, 2}
1565 };
1566
1567 static void
1568 pidgin_account_dialog_show_continue(PurpleAccount *account,
1569 const gchar *password, GError *error, gpointer _type)
1570 {
1571 PidginAccountDialogType type = GPOINTER_TO_INT(_type);
1572 AccountPrefsDialog *dialog;
1573 GtkWidget *win;
1574 GtkWidget *main_vbox;
1575 GtkWidget *vbox;
1576 GtkWidget *dbox;
1577 GtkWidget *notebook;
1578 GtkWidget *button;
1579
1580 if (accounts_window != NULL && account != NULL &&
1581 (dialog = g_hash_table_lookup(account_pref_wins, account)) != NULL)
1582 {
1583 gtk_window_present(GTK_WINDOW(dialog->window));
1584 return;
1585 }
1586
1587 dialog = g_new0(AccountPrefsDialog, 1);
1588
1589 if (accounts_window != NULL && account != NULL)
1590 {
1591 g_hash_table_insert(account_pref_wins, account, dialog);
1592 }
1593
1594 dialog->account = account;
1595 dialog->password = g_strdup(password);
1596 dialog->type = type;
1597 dialog->sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1598
1599 if (dialog->account == NULL) {
1600 /* Select the first protocol in the list*/
1601 GList *protocol_list = purple_protocols_get_all();
1602 if (protocol_list != NULL) {
1603 dialog->protocol_id = g_strdup(purple_protocol_get_id(PURPLE_PROTOCOL(protocol_list->data)));
1604 g_list_free(protocol_list);
1605 }
1606 }
1607 else
1608 {
1609 dialog->protocol_id =
1610 g_strdup(purple_account_get_protocol_id(dialog->account));
1611 }
1612
1613 /* TODO if no protocols are loaded, this should inform the user that
1614 protocols need to be loaded instead of just doing nothing */
1615 if (!dialog->protocol_id)
1616 return;
1617
1618 dialog->protocol = purple_protocols_find(dialog->protocol_id);
1619
1620 dialog->window = win = pidgin_create_dialog((type == PIDGIN_ADD_ACCOUNT_DIALOG) ? _("Add Account") : _("Modify Account"),
1621 PIDGIN_HIG_BOX_SPACE, "account", FALSE);
1622
1623 g_signal_connect(G_OBJECT(win), "delete_event",
1624 G_CALLBACK(account_win_destroy_cb), dialog);
1625
1626 /* Setup the vbox */
1627 main_vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(win), FALSE, PIDGIN_HIG_BOX_SPACE);
1628
1629 dialog->notebook = notebook = gtk_notebook_new();
1630 gtk_box_pack_start(GTK_BOX(main_vbox), notebook, FALSE, FALSE, 0);
1631 gtk_widget_show(GTK_WIDGET(notebook));
1632
1633 /* Setup the inner vbox */
1634 dialog->top_vbox = vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
1635 gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BORDER);
1636 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
1637 gtk_label_new_with_mnemonic(_("_Basic")));
1638 gtk_widget_show(vbox);
1639
1640 /* Setup the top frames. */
1641 add_login_options(dialog, vbox);
1642 add_user_options(dialog, vbox);
1643
1644 button = gtk_check_button_new_with_mnemonic(
1645 _("Create _this new account on the server"));
1646 gtk_box_pack_start(GTK_BOX(main_vbox), button, FALSE, FALSE, 0);
1647 gtk_widget_show(button);
1648 dialog->register_button = button;
1649 g_signal_connect(G_OBJECT(dialog->register_button), "toggled", G_CALLBACK(register_button_cb), dialog);
1650 if (dialog->account == NULL)
1651 gtk_widget_set_sensitive(button, FALSE);
1652
1653 if (!dialog->protocol || !PURPLE_PROTOCOL_IMPLEMENTS(dialog->protocol, SERVER_IFACE, register_user))
1654 gtk_widget_hide(button);
1655
1656 /* Setup the page with 'Advanced' (protocol options). */
1657 add_account_options(dialog);
1658
1659 /* Setup the page with 'Proxy'. */
1660 dbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
1661 gtk_container_set_border_width(GTK_CONTAINER(dbox), PIDGIN_HIG_BORDER);
1662 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dbox,
1663 gtk_label_new_with_mnemonic(_("P_roxy")));
1664 gtk_widget_show(dbox);
1665 add_proxy_options(dialog, dbox);
1666
1667 add_voice_options(dialog);
1668
1669 /* Cancel button */
1670 pidgin_dialog_add_button(GTK_DIALOG(win), GTK_STOCK_CANCEL, G_CALLBACK(cancel_account_prefs_cb), dialog);
1671
1672 /* Save button */
1673 button = pidgin_dialog_add_button(GTK_DIALOG(win),
1674 (type == PIDGIN_ADD_ACCOUNT_DIALOG) ? GTK_STOCK_ADD : GTK_STOCK_SAVE,
1675 G_CALLBACK(ok_account_prefs_cb),
1676 dialog);
1677 if (dialog->account == NULL)
1678 gtk_widget_set_sensitive(button, FALSE);
1679 dialog->ok_button = button;
1680
1681 /* Set up DND */
1682 gtk_drag_dest_set(dialog->window,
1683 GTK_DEST_DEFAULT_MOTION |
1684 GTK_DEST_DEFAULT_DROP,
1685 dnd_targets,
1686 sizeof(dnd_targets) / sizeof(GtkTargetEntry),
1687 GDK_ACTION_COPY);
1688
1689 g_signal_connect(G_OBJECT(dialog->window), "drag_data_received",
1690 G_CALLBACK(account_dnd_recv), dialog);
1691
1692 /* Show the window. */
1693 gtk_widget_show(win);
1694 if (!account)
1695 gtk_widget_grab_focus(dialog->protocol_menu);
1696 }
1697
1698 void
1699 pidgin_account_dialog_show(PidginAccountDialogType type, PurpleAccount *account)
1700 {
1701 /* this is to make sure the password will be cached */
1702 purple_account_get_password(account,
1703 pidgin_account_dialog_show_continue, GINT_TO_POINTER(type));
1704 }
1705
1706 /**************************************************************************
1707 * Accounts Dialog
1708 **************************************************************************/
1709 static void
1710 signed_on_off_cb(PurpleConnection *gc, gpointer user_data)
1711 {
1712 PurpleAccount *account;
1713 GtkTreeModel *model;
1714 GtkTreeIter iter;
1715 GdkPixbuf *pixbuf;
1716 size_t index;
1717
1718 /* Don't need to do anything if the accounts window is not visible */
1719 if (accounts_window == NULL)
1720 return;
1721
1722 account = purple_connection_get_account(gc);
1723 model = GTK_TREE_MODEL(accounts_window->model);
1724 index = g_list_index(purple_accounts_get_all(), account);
1725
1726 if (gtk_tree_model_iter_nth_child(model, &iter, NULL, index))
1727 {
1728 pixbuf = pidgin_create_protocol_icon(account, PIDGIN_PROTOCOL_ICON_MEDIUM);
1729 if ((pixbuf != NULL) && purple_account_is_disconnected(account))
1730 gdk_pixbuf_saturate_and_pixelate(pixbuf, pixbuf, 0.0, FALSE);
1731
1732 gtk_list_store_set(accounts_window->model, &iter,
1733 COLUMN_ICON, pixbuf,
1734 -1);
1735
1736 if (pixbuf != NULL)
1737 g_object_unref(G_OBJECT(pixbuf));
1738 }
1739 }
1740
1741 /*
1742 * Get the GtkTreeIter of the specified account in the
1743 * GtkListStore
1744 */
1745 static gboolean
1746 accounts_window_find_account_in_treemodel(GtkTreeIter *iter, PurpleAccount *account)
1747 {
1748 GtkTreeModel *model;
1749 PurpleAccount *cur;
1750
1751 g_return_val_if_fail(account != NULL, FALSE);
1752 g_return_val_if_fail(accounts_window != NULL, FALSE);
1753
1754 model = GTK_TREE_MODEL(accounts_window->model);
1755
1756 if (!gtk_tree_model_get_iter_first(model, iter))
1757 return FALSE;
1758
1759 gtk_tree_model_get(model, iter, COLUMN_DATA, &cur, -1);
1760 if (cur == account)
1761 return TRUE;
1762
1763 while (gtk_tree_model_iter_next(model, iter))
1764 {
1765 gtk_tree_model_get(model, iter, COLUMN_DATA, &cur, -1);
1766 if (cur == account)
1767 return TRUE;
1768 }
1769
1770 return FALSE;
1771 }
1772
1773 static void
1774 account_removed_cb(PurpleAccount *account, gpointer user_data)
1775 {
1776 AccountPrefsDialog *dialog;
1777 GtkTreeIter iter;
1778
1779 /* If the account was being modified, close the edit window */
1780 if ((dialog = g_hash_table_lookup(account_pref_wins, account)) != NULL)
1781 account_win_destroy_cb(NULL, NULL, dialog);
1782
1783 if (accounts_window == NULL)
1784 return;
1785
1786 /* Remove the account from the GtkListStore */
1787 if (accounts_window_find_account_in_treemodel(&iter, account))
1788 gtk_list_store_remove(accounts_window->model, &iter);
1789
1790 if (purple_accounts_get_all() == NULL)
1791 gtk_notebook_set_current_page(GTK_NOTEBOOK(accounts_window->notebook), 0);
1792 }
1793
1794 static void
1795 account_abled_cb(PurpleAccount *account, gpointer user_data)
1796 {
1797 GtkTreeIter iter;
1798
1799 if (accounts_window == NULL)
1800 return;
1801
1802 /* update the account in the GtkListStore */
1803 if (accounts_window_find_account_in_treemodel(&iter, account))
1804 gtk_list_store_set(accounts_window->model, &iter,
1805 COLUMN_ENABLED, GPOINTER_TO_INT(user_data),
1806 -1);
1807 }
1808
1809 static void
1810 drag_data_get_cb(GtkWidget *widget, GdkDragContext *ctx,
1811 GtkSelectionData *data, guint info, guint time,
1812 AccountsWindow *dialog)
1813 {
1814 GdkAtom target = gtk_selection_data_get_target(data);
1815
1816 if (target == gdk_atom_intern("PURPLE_ACCOUNT", FALSE)) {
1817 GtkTreeRowReference *ref;
1818 GtkTreePath *source_row;
1819 GtkTreeIter iter;
1820 PurpleAccount *account = NULL;
1821 GValue val;
1822
1823 ref = g_object_get_data(G_OBJECT(ctx), "gtk-tree-view-source-row");
1824 source_row = gtk_tree_row_reference_get_path(ref);
1825
1826 if (source_row == NULL)
1827 return;
1828
1829 gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter,
1830 source_row);
1831 val.g_type = 0;
1832 gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model), &iter,
1833 COLUMN_DATA, &val);
1834
1835 dialog->drag_iter = iter;
1836
1837 account = g_value_get_pointer(&val);
1838
1839 gtk_selection_data_set(data, gdk_atom_intern("PURPLE_ACCOUNT", FALSE),
1840 8, (void *)&account, sizeof(account));
1841
1842 gtk_tree_path_free(source_row);
1843 }
1844 }
1845
1846 static void
1847 move_account_after(GtkListStore *store, GtkTreeIter *iter,
1848 GtkTreeIter *position)
1849 {
1850 GtkTreeIter new_iter;
1851 PurpleAccount *account;
1852
1853 gtk_tree_model_get(GTK_TREE_MODEL(store), iter,
1854 COLUMN_DATA, &account,
1855 -1);
1856
1857 gtk_list_store_insert_after(store, &new_iter, position);
1858
1859 set_account(store, &new_iter, account, NULL);
1860
1861 gtk_list_store_remove(store, iter);
1862 }
1863
1864 static void
1865 move_account_before(GtkListStore *store, GtkTreeIter *iter,
1866 GtkTreeIter *position)
1867 {
1868 GtkTreeIter new_iter;
1869 PurpleAccount *account;
1870
1871 gtk_tree_model_get(GTK_TREE_MODEL(store), iter,
1872 COLUMN_DATA, &account,
1873 -1);
1874
1875 gtk_list_store_insert_before(store, &new_iter, position);
1876
1877 set_account(store, &new_iter, account, NULL);
1878
1879 gtk_list_store_remove(store, iter);
1880 }
1881
1882 static void
1883 drag_data_received_cb(GtkWidget *widget, GdkDragContext *ctx,
1884 guint x, guint y, GtkSelectionData *sd,
1885 guint info, guint t, AccountsWindow *dialog)
1886 {
1887 GdkAtom target = gtk_selection_data_get_target(sd);
1888 const guchar *data = gtk_selection_data_get_data(sd);
1889
1890 if (target == gdk_atom_intern("PURPLE_ACCOUNT", FALSE) && data) {
1891 gint dest_index;
1892 PurpleAccount *a = NULL;
1893 GtkTreePath *path = NULL;
1894 GtkTreeViewDropPosition position;
1895
1896 memcpy(&a, data, sizeof(a));
1897
1898 if (gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y,
1899 &path, &position)) {
1900
1901 GtkTreeIter iter;
1902 PurpleAccount *account;
1903 GValue val;
1904
1905 gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, path);
1906 val.g_type = 0;
1907 gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model), &iter,
1908 COLUMN_DATA, &val);
1909
1910 account = g_value_get_pointer(&val);
1911
1912 switch (position) {
1913 case GTK_TREE_VIEW_DROP_AFTER:
1914 case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
1915 move_account_after(dialog->model, &dialog->drag_iter,
1916 &iter);
1917 dest_index = g_list_index(purple_accounts_get_all(),
1918 account) + 1;
1919 break;
1920
1921 case GTK_TREE_VIEW_DROP_BEFORE:
1922 case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
1923 dest_index = g_list_index(purple_accounts_get_all(),
1924 account);
1925
1926 move_account_before(dialog->model, &dialog->drag_iter,
1927 &iter);
1928 break;
1929
1930 default:
1931 return;
1932 }
1933
1934 if (dest_index >= 0)
1935 purple_accounts_reorder(a, dest_index);
1936 }
1937 }
1938 }
1939
1940 static gboolean
1941 accedit_win_destroy_cb(GtkWidget *w, GdkEvent *event, AccountsWindow *dialog)
1942 {
1943 dialog->window = NULL;
1944
1945 pidgin_accounts_window_hide();
1946
1947 return FALSE;
1948 }
1949
1950 static void
1951 add_account_cb(GtkWidget *w, AccountsWindow *dialog)
1952 {
1953 pidgin_account_dialog_show(PIDGIN_ADD_ACCOUNT_DIALOG, NULL);
1954 }
1955
1956 static void
1957 modify_account_sel(GtkTreeModel *model, GtkTreePath *path,
1958 GtkTreeIter *iter, gpointer data)
1959 {
1960 PurpleAccount *account;
1961
1962 gtk_tree_model_get(model, iter, COLUMN_DATA, &account, -1);
1963
1964 if (account != NULL)
1965 pidgin_account_dialog_show(PIDGIN_MODIFY_ACCOUNT_DIALOG, account);
1966 }
1967
1968 static void
1969 modify_account_cb(GtkWidget *w, AccountsWindow *dialog)
1970 {
1971 GtkTreeSelection *selection;
1972
1973 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview));
1974
1975 gtk_tree_selection_selected_foreach(selection, modify_account_sel, dialog);
1976 }
1977
1978 static void
1979 delete_account_cb(PurpleAccount *account)
1980 {
1981 purple_accounts_delete(account);
1982 }
1983
1984 static void
1985 ask_delete_account_sel(GtkTreeModel *model, GtkTreePath *path,
1986 GtkTreeIter *iter, gpointer data)
1987 {
1988 PurpleAccount *account;
1989
1990 gtk_tree_model_get(model, iter, COLUMN_DATA, &account, -1);
1991
1992 if (account != NULL) {
1993 char *buf;
1994
1995 buf = g_strdup_printf(_("Are you sure you want to delete %s?"),
1996 purple_account_get_username(account));
1997
1998 purple_request_close_with_handle(account);
1999 purple_request_action(account, NULL, buf, NULL,
2000 PURPLE_DEFAULT_ACTION_NONE,
2001 purple_request_cpar_from_account(account), account, 2,
2002 _("Delete"), delete_account_cb, _("Cancel"), NULL);
2003 g_free(buf);
2004 }
2005 }
2006
2007 static void
2008 ask_delete_account_cb(GtkWidget *w, AccountsWindow *dialog)
2009 {
2010 GtkTreeSelection *selection;
2011
2012 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview));
2013
2014 gtk_tree_selection_selected_foreach(selection, ask_delete_account_sel,
2015 dialog);
2016 }
2017
2018 static void
2019 close_accounts_cb(GtkWidget *w, AccountsWindow *dialog)
2020 {
2021 pidgin_accounts_window_hide();
2022 }
2023
2024
2025 static void
2026 enabled_cb(GtkCellRendererToggle *renderer, gchar *path_str,
2027 gpointer data)
2028 {
2029 AccountsWindow *dialog = (AccountsWindow *)data;
2030 PurpleAccount *account;
2031 GtkTreeModel *model = GTK_TREE_MODEL(dialog->model);
2032 GtkTreeIter iter;
2033 gboolean enabled;
2034 const PurpleSavedStatus *saved_status;
2035
2036 gtk_tree_model_get_iter_from_string(model, &iter, path_str);
2037 gtk_tree_model_get(model, &iter,
2038 COLUMN_DATA, &account,
2039 COLUMN_ENABLED, &enabled,
2040 -1);
2041
2042 /*
2043 * If we just enabled the account, then set the statuses
2044 * to the current status.
2045 */
2046 if (!enabled)
2047 {
2048 saved_status = purple_savedstatus_get_current();
2049 purple_savedstatus_activate_for_account(saved_status, account);
2050 }
2051
2052 purple_account_set_enabled(account, PIDGIN_UI, !enabled);
2053 }
2054
2055 static void
2056 add_columns(GtkWidget *treeview, AccountsWindow *dialog)
2057 {
2058 GtkCellRenderer *renderer;
2059 GtkTreeViewColumn *column;
2060
2061 /* Enabled */
2062 renderer = gtk_cell_renderer_toggle_new();
2063
2064 g_signal_connect(G_OBJECT(renderer), "toggled",
2065 G_CALLBACK(enabled_cb), dialog);
2066
2067 column = gtk_tree_view_column_new_with_attributes(_("Enabled"),
2068 renderer, "active", COLUMN_ENABLED, NULL);
2069
2070 gtk_tree_view_column_set_resizable(column, FALSE);
2071 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
2072
2073 /* Username column */
2074 column = gtk_tree_view_column_new();
2075 gtk_tree_view_column_set_title(column, _("Username"));
2076 gtk_tree_view_column_set_resizable(column, TRUE);
2077 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
2078
2079 /* Buddy Icon */
2080 renderer = gtk_cell_renderer_pixbuf_new();
2081 gtk_tree_view_column_pack_start(column, renderer, FALSE);
2082 gtk_tree_view_column_add_attribute(column, renderer,
2083 "pixbuf", COLUMN_BUDDYICON);
2084
2085 /* Username */
2086 renderer = gtk_cell_renderer_text_new();
2087 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2088 gtk_tree_view_column_add_attribute(column, renderer,
2089 "text", COLUMN_USERNAME);
2090 dialog->username_col = column;
2091
2092
2093 /* Protocol name */
2094 column = gtk_tree_view_column_new();
2095 gtk_tree_view_column_set_title(column, _("Protocol"));
2096 gtk_tree_view_column_set_resizable(column, FALSE);
2097 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
2098
2099 /* Icon */
2100 renderer = gtk_cell_renderer_pixbuf_new();
2101 gtk_tree_view_column_pack_start(column, renderer, FALSE);
2102 gtk_tree_view_column_add_attribute(column, renderer,
2103 "pixbuf", COLUMN_ICON);
2104
2105 renderer = gtk_cell_renderer_text_new();
2106 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2107 gtk_tree_view_column_add_attribute(column, renderer,
2108 "text", COLUMN_PROTOCOL);
2109 }
2110
2111 static void
2112 set_account(GtkListStore *store, GtkTreeIter *iter, PurpleAccount *account, GdkPixbuf *global_buddyicon)
2113 {
2114 GdkPixbuf *pixbuf, *buddyicon = NULL;
2115 PurpleImage *img = NULL;
2116 PurpleProtocol *protocol = NULL;
2117 PurpleBuddyIconSpec *icon_spec = NULL;
2118
2119 pixbuf = pidgin_create_protocol_icon(account, PIDGIN_PROTOCOL_ICON_MEDIUM);
2120 if ((pixbuf != NULL) && purple_account_is_disconnected(account))
2121 gdk_pixbuf_saturate_and_pixelate(pixbuf, pixbuf, 0.0, FALSE);
2122
2123 protocol = purple_protocols_find(purple_account_get_protocol_id(account));
2124 if (protocol != NULL)
2125 icon_spec = purple_protocol_get_icon_spec(protocol);
2126
2127 if (icon_spec != NULL && icon_spec->format != NULL) {
2128 if (purple_account_get_bool(account, "use-global-buddyicon", TRUE)) {
2129 if (global_buddyicon != NULL)
2130 buddyicon = g_object_ref(G_OBJECT(global_buddyicon));
2131 else {
2132 /* This is for when set_account() is called for a single account */
2133 const char *path;
2134 path = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/accounts/buddyicon");
2135 if ((path != NULL) && (*path != '\0')) {
2136 img = purple_image_new_from_file(path, TRUE);
2137 }
2138 }
2139 } else {
2140 img = purple_buddy_icons_find_account_icon(account);
2141 }
2142 }
2143
2144 if (img != NULL) {
2145 GdkPixbuf *buddyicon_pixbuf;
2146 buddyicon_pixbuf = pidgin_pixbuf_from_image(img);
2147 g_object_unref(img);
2148
2149 if (buddyicon_pixbuf != NULL) {
2150 buddyicon = gdk_pixbuf_scale_simple(buddyicon_pixbuf, 22, 22, GDK_INTERP_HYPER);
2151 g_object_unref(G_OBJECT(buddyicon_pixbuf));
2152 }
2153 }
2154
2155 gtk_list_store_set(store, iter,
2156 COLUMN_ICON, pixbuf,
2157 COLUMN_BUDDYICON, buddyicon,
2158 COLUMN_USERNAME, purple_account_get_username(account),
2159 COLUMN_ENABLED, purple_account_get_enabled(account, PIDGIN_UI),
2160 COLUMN_PROTOCOL, purple_account_get_protocol_name(account),
2161 COLUMN_DATA, account,
2162 -1);
2163
2164 if (pixbuf != NULL)
2165 g_object_unref(G_OBJECT(pixbuf));
2166 if (buddyicon != NULL)
2167 g_object_unref(G_OBJECT(buddyicon));
2168 }
2169
2170 static void
2171 add_account_to_liststore(PurpleAccount *account, gpointer user_data)
2172 {
2173 GtkTreeIter iter;
2174 GdkPixbuf *global_buddyicon = user_data;
2175
2176 if (accounts_window == NULL)
2177 return;
2178
2179 gtk_list_store_append(accounts_window->model, &iter);
2180 gtk_notebook_set_current_page(GTK_NOTEBOOK(accounts_window->notebook),1);
2181
2182 set_account(accounts_window->model, &iter, account, global_buddyicon);
2183 }
2184
2185 static gboolean
2186 populate_accounts_list(AccountsWindow *dialog)
2187 {
2188 GList *l;
2189 gboolean ret = FALSE;
2190 GdkPixbuf *global_buddyicon = NULL;
2191 const char *path;
2192
2193 gtk_list_store_clear(dialog->model);
2194
2195 if ((path = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/accounts/buddyicon")) != NULL) {
2196 GdkPixbuf *pixbuf = pidgin_pixbuf_new_from_file(path);
2197 if (pixbuf != NULL) {
2198 global_buddyicon = gdk_pixbuf_scale_simple(pixbuf, 22, 22, GDK_INTERP_HYPER);
2199 g_object_unref(G_OBJECT(pixbuf));
2200 }
2201 }
2202
2203 for (l = purple_accounts_get_all(); l != NULL; l = l->next) {
2204 ret = TRUE;
2205 add_account_to_liststore((PurpleAccount *)l->data, global_buddyicon);
2206 }
2207
2208 if (global_buddyicon != NULL)
2209 g_object_unref(G_OBJECT(global_buddyicon));
2210
2211 return ret;
2212 }
2213
2214 static void
2215 account_selected_cb(GtkTreeSelection *sel, AccountsWindow *dialog)
2216 {
2217 gboolean selected = FALSE;
2218
2219 selected = (gtk_tree_selection_count_selected_rows(sel) > 0);
2220
2221 gtk_widget_set_sensitive(dialog->modify_button, selected);
2222 gtk_widget_set_sensitive(dialog->delete_button, selected);
2223 }
2224
2225 static gboolean
2226 account_treeview_double_click_cb(GtkTreeView *treeview, GdkEventButton *event, gpointer user_data)
2227 {
2228 AccountsWindow *dialog;
2229 GtkTreePath *path;
2230 GtkTreeViewColumn *column;
2231 GtkTreeIter iter;
2232 PurpleAccount *account;
2233
2234 dialog = (AccountsWindow *)user_data;
2235
2236 if (event->window != gtk_tree_view_get_bin_window(treeview))
2237 return FALSE;
2238
2239 /* Figure out which node was clicked */
2240 if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(dialog->treeview), event->x, event->y, &path, &column, NULL, NULL))
2241 return FALSE;
2242 if (column == gtk_tree_view_get_column(treeview, 0)) {
2243 gtk_tree_path_free(path);
2244 return FALSE;
2245 }
2246
2247 gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, path);
2248 gtk_tree_path_free(path);
2249 gtk_tree_model_get(GTK_TREE_MODEL(dialog->model), &iter, COLUMN_DATA, &account, -1);
2250
2251 if ((account != NULL) && (event->button == 1) &&
2252 (event->type == GDK_2BUTTON_PRESS))
2253 {
2254 pidgin_account_dialog_show(PIDGIN_MODIFY_ACCOUNT_DIALOG, account);
2255 return TRUE;
2256 }
2257
2258 return FALSE;
2259 }
2260
2261 static GtkWidget *
2262 create_accounts_list(AccountsWindow *dialog)
2263 {
2264 GtkWidget *frame;
2265 GtkWidget *label;
2266 GtkWidget *treeview;
2267 GtkTreeSelection *sel;
2268 GtkTargetEntry gte[] = {{"PURPLE_ACCOUNT", GTK_TARGET_SAME_APP, 0}};
2269 char *pretty, *tmp;
2270
2271 frame = gtk_frame_new(NULL);
2272 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
2273
2274 accounts_window->notebook = gtk_notebook_new();
2275 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(accounts_window->notebook), FALSE);
2276 gtk_notebook_set_show_border(GTK_NOTEBOOK(accounts_window->notebook), FALSE);
2277 gtk_container_add(GTK_CONTAINER(frame), accounts_window->notebook);
2278
2279 /* Create a helpful first-time-use label */
2280 label = gtk_label_new(NULL);
2281 /* Translators: Please maintain the use of -> or <- to represent the menu heirarchy */
2282 tmp = g_strdup_printf(_(
2283 "<span size='larger' weight='bold'>Welcome to %s!</span>\n\n"
2284
2285 "You have no IM accounts configured. To start connecting with %s "
2286 "press the <b>Add...</b> button below and configure your first "
2287 "account. If you want %s to connect to multiple IM accounts, "
2288 "press <b>Add...</b> again to configure them all.\n\n"
2289
2290 "You can come back to this window to add, edit, or remove "
2291 "accounts from <b>Accounts->Manage Accounts</b> in the Buddy "
2292 "List window"), PIDGIN_NAME, PIDGIN_NAME, PIDGIN_NAME);
2293 pretty = pidgin_make_pretty_arrows(tmp);
2294 g_free(tmp);
2295 gtk_label_set_markup(GTK_LABEL(label), pretty);
2296 g_free(pretty);
2297
2298 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
2299 gtk_widget_show(label);
2300
2301 gtk_notebook_append_page(GTK_NOTEBOOK(accounts_window->notebook), label, NULL);
2302
2303 /* Create the list model. */
2304 dialog->model = gtk_list_store_new(NUM_COLUMNS,
2305 GDK_TYPE_PIXBUF, /* COLUMN_ICON */
2306 GDK_TYPE_PIXBUF, /* COLUMN_BUDDYICON */
2307 G_TYPE_STRING, /* COLUMN_USERNAME */
2308 G_TYPE_BOOLEAN, /* COLUMN_ENABLED */
2309 G_TYPE_STRING, /* COLUMN_PROTOCOL */
2310 G_TYPE_POINTER /* COLUMN_DATA */
2311 );
2312
2313 /* And now the actual treeview */
2314 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dialog->model));
2315 dialog->treeview = treeview;
2316 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
2317 g_object_unref(G_OBJECT(dialog->model));
2318
2319 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
2320 gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
2321 g_signal_connect(G_OBJECT(sel), "changed",
2322 G_CALLBACK(account_selected_cb), dialog);
2323
2324 /* Handle double-clicking */
2325 g_signal_connect(G_OBJECT(treeview), "button_press_event",
2326 G_CALLBACK(account_treeview_double_click_cb), dialog);
2327
2328 gtk_notebook_append_page(GTK_NOTEBOOK(accounts_window->notebook),
2329 pidgin_make_scrollable(treeview, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_NONE, -1, -1),
2330 NULL);
2331
2332 add_columns(treeview, dialog);
2333 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(treeview));
2334
2335 if (populate_accounts_list(dialog))
2336 gtk_notebook_set_current_page(GTK_NOTEBOOK(accounts_window->notebook), 1);
2337 else
2338 gtk_notebook_set_current_page(GTK_NOTEBOOK(accounts_window->notebook), 0);
2339
2340 /* Setup DND. I wanna be an orc! */
2341 gtk_tree_view_enable_model_drag_source(
2342 GTK_TREE_VIEW(treeview), GDK_BUTTON1_MASK, gte,
2343 1, GDK_ACTION_COPY);
2344 gtk_tree_view_enable_model_drag_dest(
2345 GTK_TREE_VIEW(treeview), gte, 1,
2346 GDK_ACTION_COPY | GDK_ACTION_MOVE);
2347
2348 g_signal_connect(G_OBJECT(treeview), "drag-data-received",
2349 G_CALLBACK(drag_data_received_cb), dialog);
2350 g_signal_connect(G_OBJECT(treeview), "drag-data-get",
2351 G_CALLBACK(drag_data_get_cb), dialog);
2352
2353 gtk_widget_show_all(frame);
2354 return frame;
2355 }
2356
2357 static void
2358 account_modified_cb(PurpleAccount *account, AccountsWindow *window)
2359 {
2360 GtkTreeIter iter;
2361
2362 if (!accounts_window_find_account_in_treemodel(&iter, account))
2363 return;
2364
2365 set_account(window->model, &iter, account, NULL);
2366 }
2367
2368 static void
2369 global_buddyicon_changed(const char *name, PurplePrefType type,
2370 gconstpointer value, gpointer window)
2371 {
2372 GList *list;
2373 for (list = purple_accounts_get_all(); list; list = list->next) {
2374 account_modified_cb(list->data, window);
2375 }
2376 }
2377
2378 void
2379 pidgin_accounts_window_show(void)
2380 {
2381 AccountsWindow *dialog;
2382 GtkWidget *win;
2383 GtkWidget *vbox;
2384 GtkWidget *sw;
2385 GtkWidget *button;
2386 int width, height;
2387
2388 if (accounts_window != NULL) {
2389 gtk_window_present(GTK_WINDOW(accounts_window->window));
2390 return;
2391 }
2392
2393 accounts_window = dialog = g_new0(AccountsWindow, 1);
2394
2395 width = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/accounts/dialog/width");
2396 height = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/accounts/dialog/height");
2397
2398 dialog->window = win = pidgin_create_dialog(_("Accounts"), 0, "accounts", TRUE);
2399 gtk_window_set_default_size(GTK_WINDOW(win), width, height);
2400
2401 g_signal_connect(G_OBJECT(win), "delete_event",
2402 G_CALLBACK(accedit_win_destroy_cb), accounts_window);
2403
2404 /* Setup the vbox */
2405 vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(win), FALSE, PIDGIN_HIG_BORDER);
2406
2407 /* Setup the scrolled window that will contain the list of accounts. */
2408 sw = create_accounts_list(dialog);
2409 gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
2410 gtk_widget_show(sw);
2411
2412 /* Add button */
2413 pidgin_dialog_add_button(GTK_DIALOG(win), PIDGIN_STOCK_ADD, G_CALLBACK(add_account_cb), dialog);
2414
2415 /* Modify button */
2416 button = pidgin_dialog_add_button(GTK_DIALOG(win), PIDGIN_STOCK_MODIFY, G_CALLBACK(modify_account_cb), dialog);
2417 dialog->modify_button = button;
2418 gtk_widget_set_sensitive(button, FALSE);
2419
2420 /* Delete button */
2421 button = pidgin_dialog_add_button(GTK_DIALOG(win), GTK_STOCK_DELETE, G_CALLBACK(ask_delete_account_cb), dialog);
2422 dialog->delete_button = button;
2423 gtk_widget_set_sensitive(button, FALSE);
2424
2425 /* Close button */
2426 pidgin_dialog_add_button(GTK_DIALOG(win), GTK_STOCK_CLOSE, G_CALLBACK(close_accounts_cb), dialog);
2427
2428 purple_signal_connect(pidgin_accounts_get_handle(), "account-modified",
2429 accounts_window,
2430 PURPLE_CALLBACK(account_modified_cb), accounts_window);
2431 purple_prefs_connect_callback(accounts_window,
2432 PIDGIN_PREFS_ROOT "/accounts/buddyicon",
2433 global_buddyicon_changed, accounts_window);
2434
2435 gtk_widget_show(win);
2436 }
2437
2438 void
2439 pidgin_accounts_window_hide(void)
2440 {
2441 if (accounts_window == NULL)
2442 return;
2443
2444 if (accounts_window->window != NULL)
2445 gtk_widget_destroy(accounts_window->window);
2446
2447 purple_signals_disconnect_by_handle(accounts_window);
2448 purple_prefs_disconnect_by_handle(accounts_window);
2449
2450 g_free(accounts_window);
2451 accounts_window = NULL;
2452 }
2453
2454 static void
2455 free_add_user_data(PidginAccountAddUserData *data)
2456 {
2457 g_free(data->username);
2458 g_free(data->alias);
2459 g_free(data);
2460 }
2461
2462 static void
2463 add_user_cb(PidginAccountAddUserData *data)
2464 {
2465 PurpleConnection *gc = purple_account_get_connection(data->account);
2466
2467 if (g_list_find(purple_connections_get_all(), gc))
2468 {
2469 purple_blist_request_add_buddy(data->account, data->username,
2470 NULL, data->alias);
2471 }
2472
2473 free_add_user_data(data);
2474 }
2475
2476 static char *
2477 make_info(PurpleAccount *account, PurpleConnection *gc, const char *remote_user,
2478 const char *id, const char *alias, const char *msg)
2479 {
2480 if (msg != NULL && *msg == '\0')
2481 msg = NULL;
2482
2483 return g_strdup_printf(_("%s%s%s%s has made %s his or her buddy%s%s"),
2484 remote_user,
2485 (alias != NULL ? " (" : ""),
2486 (alias != NULL ? alias : ""),
2487 (alias != NULL ? ")" : ""),
2488 (id != NULL
2489 ? id
2490 : (purple_connection_get_display_name(gc) != NULL
2491 ? purple_connection_get_display_name(gc)
2492 : purple_account_get_username(account))),
2493 (msg != NULL ? ": " : "."),
2494 (msg != NULL ? msg : ""));
2495 }
2496
2497 static void
2498 pidgin_accounts_notify_added(PurpleAccount *account, const char *remote_user,
2499 const char *id, const char *alias,
2500 const char *msg)
2501 {
2502 char *buffer;
2503 PurpleConnection *gc;
2504 GtkWidget *alert;
2505
2506 gc = purple_account_get_connection(account);
2507
2508 buffer = make_info(account, gc, remote_user, id, alias, msg);
2509 alert = pidgin_make_mini_dialog(gc, PIDGIN_STOCK_DIALOG_INFO, buffer,
2510 NULL, NULL, _("Close"), NULL, NULL);
2511 pidgin_blist_add_alert(alert);
2512
2513 g_free(buffer);
2514 }
2515
2516 static void
2517 pidgin_accounts_request_add(PurpleAccount *account, const char *remote_user,
2518 const char *id, const char *alias,
2519 const char *msg)
2520 {
2521 char *buffer;
2522 PurpleConnection *gc;
2523 PidginAccountAddUserData *data;
2524 GtkWidget *alert;
2525
2526 gc = purple_account_get_connection(account);
2527
2528 data = g_new0(PidginAccountAddUserData, 1);
2529 data->account = account;
2530 data->username = g_strdup(remote_user);
2531 data->alias = g_strdup(alias);
2532
2533 buffer = make_info(account, gc, remote_user, id, alias, msg);
2534 alert = pidgin_make_mini_dialog(gc, PIDGIN_STOCK_DIALOG_QUESTION,
2535 _("Add buddy to your list?"), buffer, data,
2536 _("Add"), G_CALLBACK(add_user_cb),
2537 _("Cancel"), G_CALLBACK(free_add_user_data), NULL);
2538 pidgin_blist_add_alert(alert);
2539
2540 g_free(buffer);
2541 }
2542
2543 struct auth_request
2544 {
2545 PurpleAccountRequestAuthorizationCb auth_cb;
2546 PurpleAccountRequestAuthorizationCb deny_cb;
2547 void *data;
2548 char *username;
2549 char *alias;
2550 PurpleAccount *account;
2551 gboolean add_buddy_after_auth;
2552 };
2553
2554 static void
2555 free_auth_request(struct auth_request *ar)
2556 {
2557 g_free(ar->username);
2558 g_free(ar->alias);
2559 g_free(ar);
2560 }
2561
2562 static void
2563 authorize_and_add_cb(struct auth_request *ar, const char *message)
2564 {
2565 ar->auth_cb(message, ar->data);
2566 if (ar->add_buddy_after_auth) {
2567 purple_blist_request_add_buddy(ar->account, ar->username, NULL, ar->alias);
2568 }
2569 }
2570
2571 static void
2572 authorize_noreason_cb(struct auth_request *ar)
2573 {
2574 authorize_and_add_cb(ar, NULL);
2575 }
2576
2577 static void
2578 authorize_reason_cb(struct auth_request *ar)
2579 {
2580 const char *protocol_id;
2581 PurpleProtocol *protocol = NULL;
2582
2583 protocol_id = purple_account_get_protocol_id(ar->account);
2584 protocol = purple_protocols_find(protocol_id);
2585
2586 if (protocol && (purple_protocol_get_options(protocol) & OPT_PROTO_AUTHORIZATION_GRANTED_MESSAGE)) {
2587 /* Duplicate information because ar is freed by closing minidialog */
2588 struct auth_request *aa = g_new0(struct auth_request, 1);
2589 aa->auth_cb = ar->auth_cb;
2590 aa->deny_cb = ar->deny_cb;
2591 aa->data = ar->data;
2592 aa->account = ar->account;
2593 aa->username = g_strdup(ar->username);
2594 aa->alias = g_strdup(ar->alias);
2595 aa->add_buddy_after_auth = ar->add_buddy_after_auth;
2596 purple_request_input(ar->account, NULL, _("Authorization acceptance message:"),
2597 NULL, _("No reason given."), TRUE, FALSE, NULL,
2598 _("OK"), G_CALLBACK(authorize_and_add_cb),
2599 _("Cancel"), G_CALLBACK(authorize_noreason_cb),
2600 purple_request_cpar_from_account(ar->account),
2601 aa);
2602 /* FIXME: aa is going to leak now. */
2603 } else {
2604 authorize_noreason_cb(ar);
2605 }
2606 }
2607
2608 static void
2609 deny_no_add_cb(struct auth_request *ar, const char *message)
2610 {
2611 ar->deny_cb(message, ar->data);
2612 }
2613
2614 static void
2615 deny_noreason_cb(struct auth_request *ar)
2616 {
2617 ar->deny_cb(NULL, ar->data);
2618 }
2619
2620 static void
2621 deny_reason_cb(struct auth_request *ar)
2622 {
2623 const char *protocol_id;
2624 PurpleProtocol *protocol = NULL;
2625
2626 protocol_id = purple_account_get_protocol_id(ar->account);
2627 protocol = purple_protocols_find(protocol_id);
2628
2629 if (protocol && (purple_protocol_get_options(protocol) & OPT_PROTO_AUTHORIZATION_DENIED_MESSAGE)) {
2630 /* Duplicate information because ar is freed by closing minidialog */
2631 struct auth_request *aa = g_new0(struct auth_request, 1);
2632 aa->auth_cb = ar->auth_cb;
2633 aa->deny_cb = ar->deny_cb;
2634 aa->data = ar->data;
2635 aa->add_buddy_after_auth = ar->add_buddy_after_auth;
2636 purple_request_input(ar->account, NULL, _("Authorization denied message:"),
2637 NULL, _("No reason given."), TRUE, FALSE, NULL,
2638 _("OK"), G_CALLBACK(deny_no_add_cb),
2639 _("Cancel"), G_CALLBACK(deny_noreason_cb),
2640 purple_request_cpar_from_account(ar->account),
2641 aa);
2642 /* FIXME: aa is going to leak now. */
2643 } else {
2644 deny_noreason_cb(ar);
2645 }
2646 }
2647
2648 static gboolean
2649 get_user_info_cb(GtkWidget *label,
2650 const gchar *uri,
2651 gpointer data)
2652 {
2653 struct auth_request *ar = data;
2654 if (!strcmp(uri, "viewinfo")) {
2655 pidgin_retrieve_user_info(purple_account_get_connection(ar->account), ar->username);
2656 return TRUE;
2657 }
2658 return FALSE;
2659 }
2660
2661 static void
2662 send_im_cb(PidginMiniDialog *mini_dialog,
2663 GtkButton *button,
2664 gpointer data)
2665 {
2666 struct auth_request *ar = data;
2667 pidgin_dialogs_im_with_user(ar->account, ar->username);
2668 }
2669
2670 static void *
2671 pidgin_accounts_request_authorization(PurpleAccount *account,
2672 const char *remote_user,
2673 const char *id,
2674 const char *alias,
2675 const char *message,
2676 gboolean on_list,
2677 PurpleAccountRequestAuthorizationCb auth_cb,
2678 PurpleAccountRequestAuthorizationCb deny_cb,
2679 void *user_data)
2680 {
2681 char *buffer;
2682 PurpleConnection *gc;
2683 GtkWidget *alert;
2684 PidginMiniDialog *dialog;
2685 GdkPixbuf *protocol_icon;
2686 struct auth_request *aa;
2687 const char *our_name;
2688 gboolean have_valid_alias;
2689 char *escaped_remote_user;
2690 char *escaped_alias;
2691 char *escaped_our_name;
2692 char *escaped_message;
2693
2694 gc = purple_account_get_connection(account);
2695 if (message != NULL && *message != '\0')
2696 escaped_message = g_markup_escape_text(message, -1);
2697 else
2698 escaped_message = g_strdup("");
2699
2700 our_name = (id != NULL) ? id :
2701 (purple_connection_get_display_name(gc) != NULL) ? purple_connection_get_display_name(gc) :
2702 purple_account_get_username(account);
2703 escaped_our_name = g_markup_escape_text(our_name, -1);
2704
2705 escaped_remote_user = g_markup_escape_text(remote_user, -1);
2706
2707 have_valid_alias = alias && *alias;
2708 escaped_alias = have_valid_alias ? g_markup_escape_text(alias, -1) : g_strdup("");
2709
2710 buffer = g_strdup_printf(_("<a href=\"viewinfo\">%s</a>%s%s%s wants to add you (%s) to his or her buddy list%s%s"),
2711 escaped_remote_user,
2712 (have_valid_alias ? " (" : ""),
2713 escaped_alias,
2714 (have_valid_alias ? ")" : ""),
2715 escaped_our_name,
2716 (*escaped_message ? ": " : "."),
2717 escaped_message);
2718
2719 g_free(escaped_remote_user);
2720 g_free(escaped_alias);
2721 g_free(escaped_our_name);
2722 g_free(escaped_message);
2723
2724 protocol_icon = pidgin_create_protocol_icon(account, PIDGIN_PROTOCOL_ICON_SMALL);
2725
2726 aa = g_new0(struct auth_request, 1);
2727 aa->auth_cb = auth_cb;
2728 aa->deny_cb = deny_cb;
2729 aa->data = user_data;
2730 aa->username = g_strdup(remote_user);
2731 aa->alias = g_strdup(alias);
2732 aa->account = account;
2733 aa->add_buddy_after_auth = !on_list;
2734
2735 alert = pidgin_make_mini_dialog_with_custom_icon(
2736 gc, protocol_icon,
2737 _("Authorize buddy?"), NULL, aa,
2738 _("Authorize"), authorize_reason_cb,
2739 _("Deny"), deny_reason_cb,
2740 NULL);
2741
2742 dialog = PIDGIN_MINI_DIALOG(alert);
2743 pidgin_mini_dialog_enable_description_markup(dialog);
2744 pidgin_mini_dialog_set_link_callback(dialog, G_CALLBACK(get_user_info_cb), aa);
2745 pidgin_mini_dialog_set_description(dialog, buffer);
2746 pidgin_mini_dialog_add_non_closing_button(dialog, _("Send Instant Message"), send_im_cb, aa);
2747
2748 g_signal_connect_swapped(G_OBJECT(alert), "destroy", G_CALLBACK(free_auth_request), aa);
2749 g_signal_connect(G_OBJECT(alert), "destroy", G_CALLBACK(purple_account_request_close), NULL);
2750 pidgin_blist_add_alert(alert);
2751
2752 g_free(buffer);
2753
2754 return alert;
2755 }
2756
2757 static void
2758 pidgin_accounts_request_close(void *ui_handle)
2759 {
2760 gtk_widget_destroy(GTK_WIDGET(ui_handle));
2761 }
2762
2763 static PurpleAccountUiOps ui_ops =
2764 {
2765 pidgin_accounts_notify_added,
2766 NULL,
2767 pidgin_accounts_request_add,
2768 pidgin_accounts_request_authorization,
2769 pidgin_accounts_request_close,
2770 NULL,
2771 NULL,
2772 NULL,
2773 NULL,
2774 NULL, NULL, NULL, NULL
2775 };
2776
2777 PurpleAccountUiOps *
2778 pidgin_accounts_get_ui_ops(void)
2779 {
2780 return &ui_ops;
2781 }
2782
2783 void *
2784 pidgin_accounts_get_handle(void) {
2785 static int handle;
2786
2787 return &handle;
2788 }
2789
2790 void
2791 pidgin_accounts_init(void)
2792 {
2793 char *default_avatar = NULL;
2794 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/accounts");
2795 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/accounts/dialog");
2796 purple_prefs_add_int(PIDGIN_PREFS_ROOT "/accounts/dialog/width", 520);
2797 purple_prefs_add_int(PIDGIN_PREFS_ROOT "/accounts/dialog/height", 321);
2798 default_avatar = g_build_filename(g_get_home_dir(), ".face.icon", NULL);
2799 if (!g_file_test(default_avatar, G_FILE_TEST_EXISTS)) {
2800 g_free(default_avatar);
2801 default_avatar = g_build_filename(g_get_home_dir(), ".face", NULL);
2802 if (!g_file_test(default_avatar, G_FILE_TEST_EXISTS)) {
2803 g_free(default_avatar);
2804 default_avatar = NULL;
2805 }
2806 }
2807
2808 purple_prefs_add_path(PIDGIN_PREFS_ROOT "/accounts/buddyicon", default_avatar);
2809 g_free(default_avatar);
2810
2811 purple_signal_register(pidgin_accounts_get_handle(), "account-modified",
2812 purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
2813 PURPLE_TYPE_ACCOUNT);
2814
2815 /* Setup some purple signal handlers. */
2816 purple_signal_connect(purple_connections_get_handle(), "signed-on",
2817 pidgin_accounts_get_handle(),
2818 PURPLE_CALLBACK(signed_on_off_cb), NULL);
2819 purple_signal_connect(purple_connections_get_handle(), "signed-off",
2820 pidgin_accounts_get_handle(),
2821 PURPLE_CALLBACK(signed_on_off_cb), NULL);
2822 purple_signal_connect(purple_accounts_get_handle(), "account-added",
2823 pidgin_accounts_get_handle(),
2824 PURPLE_CALLBACK(add_account_to_liststore), NULL);
2825 purple_signal_connect(purple_accounts_get_handle(), "account-removed",
2826 pidgin_accounts_get_handle(),
2827 PURPLE_CALLBACK(account_removed_cb), NULL);
2828 purple_signal_connect(purple_accounts_get_handle(), "account-disabled",
2829 pidgin_accounts_get_handle(),
2830 PURPLE_CALLBACK(account_abled_cb), GINT_TO_POINTER(FALSE));
2831 purple_signal_connect(purple_accounts_get_handle(), "account-enabled",
2832 pidgin_accounts_get_handle(),
2833 PURPLE_CALLBACK(account_abled_cb), GINT_TO_POINTER(TRUE));
2834
2835 account_pref_wins =
2836 g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
2837 }
2838
2839 void
2840 pidgin_accounts_uninit(void)
2841 {
2842 /*
2843 * TODO: Need to free all the dialogs in here. Could probably create
2844 * a callback function to use for the free-some-data-function
2845 * parameter of g_hash_table_new_full, above.
2846 */
2847 g_hash_table_destroy(account_pref_wins);
2848
2849 purple_signals_disconnect_by_handle(pidgin_accounts_get_handle());
2850 purple_signals_unregister_by_instance(pidgin_accounts_get_handle());
2851 }
2852
Git mirror of Pidgin's Mercurial repository