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