?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix broken `priv != NULL` checks in Pidgin.
[pidgin-git.git] / pidgin / gtkaccount.c
blob702a2412e52dc4e0ba1639895c3f56eb2100fefc
1 /* pidgin
2 *
3 * Pidgin is the legal property of its developers, whose names are too numerous
4 * to list here. Please refer to the COPYRIGHT file distributed with this
5 * source distribution.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
20 */
21
22 #include "internal.h"
23 #include "pidgin.h"
24
25 #include "account.h"
26 #include "accountopt.h"
27 #include "core.h"
28 #include "debug.h"
29 #include "notify.h"
30 #include "plugins.h"
31 #include "prefs.h"
32 #include "protocol.h"
33 #include "request.h"
34 #include "savedstatuses.h"
35 #include "signals.h"
36 #include "util.h"
37
38 #include "gtkaccount.h"
39 #include "gtkblist.h"
40 #include "gtkdialogs.h"
41 #include "gtkutils.h"
42 #include "gtkstatusbox.h"
43 #include "pidginstock.h"
44 #include "minidialog.h"
45
46 #include "gtk3compat.h"
47
48 enum
49 {
50 COLUMN_ICON,
51 COLUMN_BUDDYICON,
52 COLUMN_USERNAME,
53 COLUMN_ENABLED,
54 COLUMN_PROTOCOL,
55 COLUMN_DATA,
56 NUM_COLUMNS
57 };
58
59 typedef struct
60 {
61 PurpleAccount *account;
62 char *username;
63 char *alias;
64
65 } PidginAccountAddUserData;
66
67 typedef struct
68 {
69 GtkWidget *window;
70 GtkWidget *treeview;
71
72 GtkWidget *modify_button;
73 GtkWidget *delete_button;
74 GtkWidget *notebook;
75
76 GtkListStore *model;
77 GtkTreeIter drag_iter;
78
79 GtkTreeViewColumn *username_col;
80
81 } AccountsWindow;
82
83 typedef struct
84 {
85 GtkWidget *widget;
86 gchar *setting;
87 PurplePrefType type;
88 } ProtocolOptEntry;
89
90 typedef struct
91 {
92 PidginAccountDialogType type;
93
94 PurpleAccount *account;
95 char *protocol_id;
96 PurpleProtocol *protocol;
97
98 PurpleProxyType new_proxy_type;
99
100 GList *user_split_entries;
101 GList *protocol_opt_entries;
102
103 GtkSizeGroup *sg;
104 GtkWidget *window;
105
106 GtkWidget *notebook;
107 GtkWidget *top_vbox;
108 GtkWidget *ok_button;
109 GtkWidget *register_button;
110
111 /* Login Options */
112 GtkWidget *login_frame;
113 GtkWidget *protocol_menu;
114 GtkWidget *password_box;
115 gchar *password;
116 GtkWidget *username_entry;
117 GdkRGBA username_entry_hint_color;
118 GtkWidget *password_entry;
119 GtkWidget *alias_entry;
120 GtkWidget *remember_pass_check;
121
122 /* User Options */
123 GtkWidget *user_frame;
124 GtkWidget *new_mail_check;
125 GtkWidget *icon_hbox;
126 GtkWidget *icon_check;
127 GtkWidget *icon_entry;
128 GtkWidget *icon_filesel;
129 GtkWidget *icon_preview;
130 GtkWidget *icon_text;
131 PurpleImage *icon_img;
132
133 /* Protocol Options */
134 GtkWidget *protocol_frame;
135
136 /* Proxy Options */
137 GtkWidget *proxy_frame;
138 GtkWidget *proxy_vbox;
139 GtkWidget *proxy_dropdown;
140 GtkWidget *proxy_host_entry;
141 GtkWidget *proxy_port_entry;
142 GtkWidget *proxy_user_entry;
143 GtkWidget *proxy_pass_entry;
144
145 /* Voice & Video Options*/
146 GtkWidget *voice_frame;
147 GtkWidget *suppression_check;
148
149 } AccountPrefsDialog;
150
151 static AccountsWindow *accounts_window = NULL;
152 static GHashTable *account_pref_wins;
153
154 static void add_account_to_liststore(PurpleAccount *account, gpointer user_data);
155 static void set_account(GtkListStore *store, GtkTreeIter *iter,
156 PurpleAccount *account, GdkPixbuf *global_buddyicon);
157
158 /**************************************************************************
159 * Add/Modify Account dialog
160 **************************************************************************/
161 static void add_login_options(AccountPrefsDialog *dialog, GtkWidget *parent);
162 static void add_user_options(AccountPrefsDialog *dialog, GtkWidget *parent);
163 static void add_account_options(AccountPrefsDialog *dialog);
164 static void add_proxy_options(AccountPrefsDialog *dialog, GtkWidget *parent);
165 static void add_voice_options(AccountPrefsDialog *dialog);
166
167 static GtkWidget *
168 add_pref_box(AccountPrefsDialog *dialog, GtkWidget *parent,
169 const char *text, GtkWidget *widget)
170 {
171 return pidgin_add_widget_to_vbox(GTK_BOX(parent), text, dialog->sg, widget, TRUE, NULL);
172 }
173
174 static void
175 set_dialog_icon(AccountPrefsDialog *dialog, gpointer data, size_t len, gchar *new_icon_path)
176 {
177 GdkPixbuf *pixbuf = NULL;
178 PurpleBuddyIconSpec *icon_spec = NULL;
179
180 if (dialog->icon_img) {
181 g_object_unref(dialog->icon_img);
182 dialog->icon_img = NULL;
183 }
184
185 if (new_icon_path != NULL) {
186 dialog->icon_img = purple_image_new_from_file(new_icon_path, 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 (dialog->protocol != NULL &&
267 (purple_protocol_get_options(dialog->protocol) & 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 dialog->icon_filesel = NULL;
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_widget_show_all(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 if (dialog->icon_filesel)
1262 gtk_widget_destroy(dialog->icon_filesel);
1263
1264 purple_signals_disconnect_by_handle(dialog);
1265
1266 purple_str_wipe(dialog->password);
1267
1268 g_free(dialog);
1269 return FALSE;
1270 }
1271
1272 static void
1273 cancel_account_prefs_cb(GtkWidget *w, AccountPrefsDialog *dialog)
1274 {
1275 account_win_destroy_cb(NULL, NULL, dialog);
1276 }
1277
1278 static void
1279 account_register_cb(PurpleAccount *account, gboolean succeeded, void *user_data)
1280 {
1281 if (succeeded)
1282 {
1283 const PurpleSavedStatus *saved_status = purple_savedstatus_get_current();
1284 purple_signal_emit(pidgin_accounts_get_handle(), "account-modified", account);
1285
1286 if (saved_status != NULL && purple_account_get_remember_password(account)) {
1287 purple_savedstatus_activate_for_account(saved_status, account);
1288 purple_account_set_enabled(account, PIDGIN_UI, TRUE);
1289 }
1290 }
1291 else
1292 purple_accounts_delete(account);
1293 }
1294
1295 static void
1296 ok_account_prefs_cb(GtkWidget *w, AccountPrefsDialog *dialog)
1297 {
1298 PurpleProxyInfo *proxy_info = NULL;
1299 GList *l, *l2;
1300 const char *value;
1301 char *username;
1302 char *tmp;
1303 gboolean new_acct = FALSE, icon_change = FALSE;
1304 PurpleAccount *account;
1305 gboolean remember;
1306 PurpleBuddyIconSpec *icon_spec = NULL;
1307
1308 /* Build the username string. */
1309 username = g_strdup(gtk_entry_get_text(GTK_ENTRY(dialog->username_entry)));
1310
1311 if (dialog->protocol != NULL)
1312 {
1313 for (l = purple_protocol_get_user_splits(dialog->protocol),
1314 l2 = dialog->user_split_entries;
1315 l != NULL && l2 != NULL;
1316 l = l->next, l2 = l2->next)
1317 {
1318 PurpleAccountUserSplit *split = l->data;
1319 GtkEntry *entry = l2->data;
1320 char sep[2] = " ";
1321
1322 value = entry ? gtk_entry_get_text(entry) : "";
1323 if (!value)
1324 value = "";
1325
1326 *sep = purple_account_user_split_get_separator(split);
1327
1328 tmp = g_strconcat(username, sep,
1329 (*value ? value :
1330 purple_account_user_split_get_default_value(split)),
1331 NULL);
1332
1333 g_free(username);
1334 username = tmp;
1335 }
1336 }
1337
1338 if (dialog->account == NULL)
1339 {
1340 if (purple_accounts_find(username, dialog->protocol_id) != NULL) {
1341 purple_debug_warning("gtkaccount", "Trying to add a duplicate %s account (%s).\n",
1342 dialog->protocol_id, username);
1343
1344 purple_notify_error(NULL, NULL, _("Unable to save new account"),
1345 _("An account already exists with the specified criteria."), NULL);
1346
1347 g_free(username);
1348 return;
1349 }
1350
1351 if (purple_accounts_get_all() == NULL) {
1352 /* We're adding our first account. Be polite and show the buddy list */
1353 PidginBuddyList *blist =
1354 pidgin_blist_get_default_gtk_blist();
1355 if (blist != NULL && blist->window != NULL) {
1356 gtk_window_present(GTK_WINDOW(blist->window));
1357 }
1358 }
1359
1360 account = purple_account_new(username, dialog->protocol_id);
1361 new_acct = TRUE;
1362 }
1363 else
1364 {
1365 account = dialog->account;
1366
1367 /* Protocol */
1368 purple_account_set_protocol_id(account, dialog->protocol_id);
1369 }
1370
1371 /* Alias */
1372 value = gtk_entry_get_text(GTK_ENTRY(dialog->alias_entry));
1373
1374 if (*value != '\0')
1375 purple_account_set_private_alias(account, value);
1376 else
1377 purple_account_set_private_alias(account, NULL);
1378
1379 /* Buddy Icon */
1380 if (dialog->protocol != NULL)
1381 icon_spec = purple_protocol_get_icon_spec(dialog->protocol);
1382
1383 if (icon_spec && icon_spec->format != NULL)
1384 {
1385 const char *filename;
1386
1387 if (new_acct || purple_account_get_bool(account, "use-global-buddyicon", TRUE) ==
1388 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)))
1389 {
1390 icon_change = TRUE;
1391 }
1392 purple_account_set_bool(account, "use-global-buddyicon", !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)));
1393
1394 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)))
1395 {
1396 if (dialog->icon_img)
1397 {
1398 size_t len = purple_image_get_data_size(dialog->icon_img);
1399 purple_buddy_icons_set_account_icon(account,
1400 g_memdup(purple_image_get_data(dialog->icon_img), len), len);
1401 purple_account_set_buddy_icon_path(account,
1402 purple_image_get_path(dialog->icon_img));
1403 }
1404 else
1405 {
1406 purple_buddy_icons_set_account_icon(account, NULL, 0);
1407 purple_account_set_buddy_icon_path(account, NULL);
1408 }
1409 }
1410 else if ((filename = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/accounts/buddyicon")) && icon_change)
1411 {
1412 size_t len = 0;
1413 gpointer data = pidgin_convert_buddy_icon(dialog->protocol, filename, &len);
1414 purple_account_set_buddy_icon_path(account, filename);
1415 purple_buddy_icons_set_account_icon(account, data, len);
1416 }
1417 }
1418
1419
1420 /* Remember Password */
1421 remember = gtk_toggle_button_get_active(
1422 GTK_TOGGLE_BUTTON(dialog->remember_pass_check));
1423 if(!remember)
1424 purple_keyring_set_password(account, NULL, NULL, NULL);
1425
1426 purple_account_set_remember_password(account, remember);
1427
1428 /* Check Mail */
1429 if (dialog->protocol && purple_protocol_get_options(dialog->protocol) & OPT_PROTO_MAIL_CHECK)
1430 purple_account_set_check_mail(account,
1431 gtk_toggle_button_get_active(
1432 GTK_TOGGLE_BUTTON(dialog->new_mail_check)));
1433
1434 /* Password */
1435 value = gtk_entry_get_text(GTK_ENTRY(dialog->password_entry));
1436
1437 /*
1438 * We set the password if this is a new account because new accounts
1439 * will be set to online, and if the user has entered a password into
1440 * the account editor (but has not checked the 'save' box), then we
1441 * don't want to prompt them.
1442 */
1443 if ((purple_account_get_remember_password(account) || new_acct) && (*value != '\0'))
1444 purple_account_set_password(account, value, NULL, NULL);
1445 else
1446 purple_account_set_password(account, NULL, NULL, NULL);
1447
1448 purple_account_set_username(account, username);
1449 g_free(username);
1450
1451 /* Add the protocol settings */
1452 if (dialog->protocol) {
1453 ProtocolOptEntry *opt_entry;
1454 GtkTreeIter iter;
1455 char *value2;
1456 int int_value;
1457 gboolean bool_value;
1458
1459 for (l2 = dialog->protocol_opt_entries; l2; l2 = l2->next) {
1460
1461 opt_entry = l2->data;
1462
1463 switch (opt_entry->type) {
1464 case PURPLE_PREF_STRING:
1465 if (GTK_IS_COMBO_BOX(opt_entry->widget))
1466 value = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(opt_entry->widget));
1467 else
1468 value = gtk_entry_get_text(GTK_ENTRY(opt_entry->widget));
1469 purple_account_set_string(account, opt_entry->setting, value);
1470 break;
1471
1472 case PURPLE_PREF_INT:
1473 int_value = atoi(gtk_entry_get_text(GTK_ENTRY(opt_entry->widget)));
1474 purple_account_set_int(account, opt_entry->setting, int_value);
1475 break;
1476
1477 case PURPLE_PREF_BOOLEAN:
1478 bool_value =
1479 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(opt_entry->widget));
1480 purple_account_set_bool(account, opt_entry->setting, bool_value);
1481 break;
1482
1483 case PURPLE_PREF_STRING_LIST:
1484 value2 = NULL;
1485 if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(opt_entry->widget), &iter))
1486 gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(opt_entry->widget)), &iter, 1, &value2, -1);
1487 purple_account_set_string(account, opt_entry->setting, value2);
1488 break;
1489
1490 default:
1491 break;
1492 }
1493 }
1494 }
1495
1496 /* Set the proxy stuff. */
1497 proxy_info = purple_account_get_proxy_info(account);
1498
1499 /* Create the proxy info if it doesn't exist. */
1500 if (proxy_info == NULL) {
1501 proxy_info = purple_proxy_info_new();
1502 purple_account_set_proxy_info(account, proxy_info);
1503 }
1504
1505 /* Set the proxy info type. */
1506 purple_proxy_info_set_proxy_type(proxy_info, dialog->new_proxy_type);
1507
1508 /* Host */
1509 value = gtk_entry_get_text(GTK_ENTRY(dialog->proxy_host_entry));
1510
1511 if (*value != '\0')
1512 purple_proxy_info_set_host(proxy_info, value);
1513 else
1514 purple_proxy_info_set_host(proxy_info, NULL);
1515
1516 /* Port */
1517 value = gtk_entry_get_text(GTK_ENTRY(dialog->proxy_port_entry));
1518
1519 if (*value != '\0')
1520 purple_proxy_info_set_port(proxy_info, atoi(value));
1521 else
1522 purple_proxy_info_set_port(proxy_info, 0);
1523
1524 /* Username */
1525 value = gtk_entry_get_text(GTK_ENTRY(dialog->proxy_user_entry));
1526
1527 if (*value != '\0')
1528 purple_proxy_info_set_username(proxy_info, value);
1529 else
1530 purple_proxy_info_set_username(proxy_info, NULL);
1531
1532 /* Password */
1533 value = gtk_entry_get_text(GTK_ENTRY(dialog->proxy_pass_entry));
1534
1535 if (*value != '\0')
1536 purple_proxy_info_set_password(proxy_info, value);
1537 else
1538 purple_proxy_info_set_password(proxy_info, NULL);
1539
1540 /* If there are no values set then proxy_info NULL */
1541 if ((purple_proxy_info_get_proxy_type(proxy_info) == PURPLE_PROXY_USE_GLOBAL) &&
1542 (purple_proxy_info_get_host(proxy_info) == NULL) &&
1543 (purple_proxy_info_get_port(proxy_info) == 0) &&
1544 (purple_proxy_info_get_username(proxy_info) == NULL) &&
1545 (purple_proxy_info_get_password(proxy_info) == NULL))
1546 {
1547 purple_account_set_proxy_info(account, NULL);
1548 proxy_info = NULL;
1549 }
1550
1551 /* Voice and Video settings */
1552 if (dialog->voice_frame) {
1553 purple_account_set_silence_suppression(account,
1554 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->suppression_check)));
1555 }
1556
1557 /* If this is a new account, add it to our list */
1558 if (new_acct)
1559 purple_accounts_add(account);
1560 else
1561 purple_signal_emit(pidgin_accounts_get_handle(), "account-modified", account);
1562
1563 /* If this is a new account, then sign on! */
1564 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->register_button))) {
1565 purple_account_set_register_callback(account, account_register_cb, NULL);
1566 purple_account_register(account);
1567 } else if (new_acct) {
1568 const PurpleSavedStatus *saved_status;
1569
1570 saved_status = purple_savedstatus_get_current();
1571 if (saved_status != NULL) {
1572 purple_savedstatus_activate_for_account(saved_status, account);
1573 purple_account_set_enabled(account, PIDGIN_UI, TRUE);
1574 }
1575 }
1576
1577 /* We no longer need the data from the dialog window */
1578 account_win_destroy_cb(NULL, NULL, dialog);
1579
1580 }
1581
1582 static const GtkTargetEntry dnd_targets[] = {
1583 {"text/plain", 0, 0},
1584 {"text/uri-list", 0, 1},
1585 {"STRING", 0, 2}
1586 };
1587
1588 static void
1589 pidgin_account_dialog_show_continue(PurpleAccount *account,
1590 const gchar *password, GError *error, gpointer _type)
1591 {
1592 PidginAccountDialogType type = GPOINTER_TO_INT(_type);
1593 AccountPrefsDialog *dialog;
1594 GtkWidget *win;
1595 GtkWidget *main_vbox;
1596 GtkWidget *vbox;
1597 GtkWidget *dbox;
1598 GtkWidget *notebook;
1599 GtkWidget *button;
1600
1601 if (accounts_window != NULL && account != NULL &&
1602 (dialog = g_hash_table_lookup(account_pref_wins, account)) != NULL)
1603 {
1604 gtk_window_present(GTK_WINDOW(dialog->window));
1605 return;
1606 }
1607
1608 dialog = g_new0(AccountPrefsDialog, 1);
1609
1610 if (account == NULL) {
1611 /* Select the first protocol in the list*/
1612 GList *protocol_list = purple_protocols_get_all();
1613 if (protocol_list != NULL) {
1614 dialog->protocol_id = g_strdup(purple_protocol_get_id(PURPLE_PROTOCOL(protocol_list->data)));
1615 g_list_free(protocol_list);
1616 }
1617 }
1618 else
1619 {
1620 dialog->protocol_id =
1621 g_strdup(purple_account_get_protocol_id(account));
1622 }
1623
1624 /* TODO if no protocols are loaded, this should inform the user that
1625 protocols need to be loaded instead of just doing nothing */
1626 if (!dialog->protocol_id) {
1627 g_free(dialog);
1628 return;
1629 }
1630
1631 if (accounts_window != NULL && account != NULL)
1632 {
1633 g_hash_table_insert(account_pref_wins, account, dialog);
1634 }
1635
1636 dialog->account = account;
1637 dialog->password = g_strdup(password);
1638 dialog->type = type;
1639 dialog->sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1640 dialog->protocol = purple_protocols_find(dialog->protocol_id);
1641
1642 dialog->window = win = pidgin_create_dialog((type == PIDGIN_ADD_ACCOUNT_DIALOG) ? _("Add Account") : _("Modify Account"),
1643 PIDGIN_HIG_BOX_SPACE, "account", FALSE);
1644
1645 g_signal_connect(G_OBJECT(win), "delete_event",
1646 G_CALLBACK(account_win_destroy_cb), dialog);
1647
1648 /* Setup the vbox */
1649 main_vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(win), FALSE, PIDGIN_HIG_BOX_SPACE);
1650
1651 dialog->notebook = notebook = gtk_notebook_new();
1652 gtk_box_pack_start(GTK_BOX(main_vbox), notebook, FALSE, FALSE, 0);
1653 gtk_widget_show(GTK_WIDGET(notebook));
1654
1655 /* Setup the inner vbox */
1656 dialog->top_vbox = vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
1657 gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BORDER);
1658 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
1659 gtk_label_new_with_mnemonic(_("_Basic")));
1660 gtk_widget_show(vbox);
1661
1662 /* Setup the top frames. */
1663 add_login_options(dialog, vbox);
1664 add_user_options(dialog, vbox);
1665
1666 button = gtk_check_button_new_with_mnemonic(
1667 _("Create _this new account on the server"));
1668 gtk_box_pack_start(GTK_BOX(main_vbox), button, FALSE, FALSE, 0);
1669 gtk_widget_show(button);
1670 dialog->register_button = button;
1671 g_signal_connect(G_OBJECT(dialog->register_button), "toggled", G_CALLBACK(register_button_cb), dialog);
1672 if (dialog->account == NULL)
1673 gtk_widget_set_sensitive(button, FALSE);
1674
1675 if (!dialog->protocol || !PURPLE_PROTOCOL_IMPLEMENTS(dialog->protocol, SERVER, register_user))
1676 gtk_widget_hide(button);
1677
1678 /* Setup the page with 'Advanced' (protocol options). */
1679 add_account_options(dialog);
1680
1681 /* Setup the page with 'Proxy'. */
1682 dbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PIDGIN_HIG_BORDER);
1683 gtk_container_set_border_width(GTK_CONTAINER(dbox), PIDGIN_HIG_BORDER);
1684 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dbox,
1685 gtk_label_new_with_mnemonic(_("P_roxy")));
1686 gtk_widget_show(dbox);
1687 add_proxy_options(dialog, dbox);
1688
1689 add_voice_options(dialog);
1690
1691 /* Cancel button */
1692 pidgin_dialog_add_button(GTK_DIALOG(win), _("_Cancel"),
1693 G_CALLBACK(cancel_account_prefs_cb), dialog);
1694
1695 /* Save button */
1696 button = pidgin_dialog_add_button(GTK_DIALOG(win),
1697 (type == PIDGIN_ADD_ACCOUNT_DIALOG) ? _("_Add") : _("_Save"),
1698 G_CALLBACK(ok_account_prefs_cb),
1699 dialog);
1700 if (dialog->account == NULL)
1701 gtk_widget_set_sensitive(button, FALSE);
1702 dialog->ok_button = button;
1703
1704 /* Set up DND */
1705 gtk_drag_dest_set(dialog->window,
1706 GTK_DEST_DEFAULT_MOTION |
1707 GTK_DEST_DEFAULT_DROP,
1708 dnd_targets,
1709 sizeof(dnd_targets) / sizeof(GtkTargetEntry),
1710 GDK_ACTION_COPY);
1711
1712 g_signal_connect(G_OBJECT(dialog->window), "drag_data_received",
1713 G_CALLBACK(account_dnd_recv), dialog);
1714
1715 /* Show the window. */
1716 gtk_widget_show(win);
1717 if (!account)
1718 gtk_widget_grab_focus(dialog->protocol_menu);
1719 }
1720
1721 void
1722 pidgin_account_dialog_show(PidginAccountDialogType type, PurpleAccount *account)
1723 {
1724 /* this is to make sure the password will be cached */
1725 purple_account_get_password(account,
1726 pidgin_account_dialog_show_continue, GINT_TO_POINTER(type));
1727 }
1728
1729 /**************************************************************************
1730 * Accounts Dialog
1731 **************************************************************************/
1732 static void
1733 signed_on_off_cb(PurpleConnection *gc, gpointer user_data)
1734 {
1735 PurpleAccount *account;
1736 GtkTreeModel *model;
1737 GtkTreeIter iter;
1738 GdkPixbuf *pixbuf;
1739 size_t index;
1740
1741 /* Don't need to do anything if the accounts window is not visible */
1742 if (accounts_window == NULL)
1743 return;
1744
1745 account = purple_connection_get_account(gc);
1746 model = GTK_TREE_MODEL(accounts_window->model);
1747 index = g_list_index(purple_accounts_get_all(), account);
1748
1749 if (gtk_tree_model_iter_nth_child(model, &iter, NULL, index))
1750 {
1751 pixbuf = pidgin_create_protocol_icon(account, PIDGIN_PROTOCOL_ICON_MEDIUM);
1752 if ((pixbuf != NULL) && purple_account_is_disconnected(account))
1753 gdk_pixbuf_saturate_and_pixelate(pixbuf, pixbuf, 0.0, FALSE);
1754
1755 gtk_list_store_set(accounts_window->model, &iter,
1756 COLUMN_ICON, pixbuf,
1757 -1);
1758
1759 if (pixbuf != NULL)
1760 g_object_unref(G_OBJECT(pixbuf));
1761 }
1762 }
1763
1764 /*
1765 * Get the GtkTreeIter of the specified account in the
1766 * GtkListStore
1767 */
1768 static gboolean
1769 accounts_window_find_account_in_treemodel(GtkTreeIter *iter, PurpleAccount *account)
1770 {
1771 GtkTreeModel *model;
1772 PurpleAccount *cur;
1773
1774 g_return_val_if_fail(account != NULL, FALSE);
1775 g_return_val_if_fail(accounts_window != NULL, FALSE);
1776
1777 model = GTK_TREE_MODEL(accounts_window->model);
1778
1779 if (!gtk_tree_model_get_iter_first(model, iter))
1780 return FALSE;
1781
1782 gtk_tree_model_get(model, iter, COLUMN_DATA, &cur, -1);
1783 if (cur == account)
1784 return TRUE;
1785
1786 while (gtk_tree_model_iter_next(model, iter))
1787 {
1788 gtk_tree_model_get(model, iter, COLUMN_DATA, &cur, -1);
1789 if (cur == account)
1790 return TRUE;
1791 }
1792
1793 return FALSE;
1794 }
1795
1796 static void
1797 account_removed_cb(PurpleAccount *account, gpointer user_data)
1798 {
1799 AccountPrefsDialog *dialog;
1800 GtkTreeIter iter;
1801
1802 /* If the account was being modified, close the edit window */
1803 if ((dialog = g_hash_table_lookup(account_pref_wins, account)) != NULL)
1804 account_win_destroy_cb(NULL, NULL, dialog);
1805
1806 if (accounts_window == NULL)
1807 return;
1808
1809 /* Remove the account from the GtkListStore */
1810 if (accounts_window_find_account_in_treemodel(&iter, account))
1811 gtk_list_store_remove(accounts_window->model, &iter);
1812
1813 if (purple_accounts_get_all() == NULL)
1814 gtk_notebook_set_current_page(GTK_NOTEBOOK(accounts_window->notebook), 0);
1815 }
1816
1817 static void
1818 account_abled_cb(PurpleAccount *account, gpointer user_data)
1819 {
1820 GtkTreeIter iter;
1821
1822 if (accounts_window == NULL)
1823 return;
1824
1825 /* update the account in the GtkListStore */
1826 if (accounts_window_find_account_in_treemodel(&iter, account))
1827 gtk_list_store_set(accounts_window->model, &iter,
1828 COLUMN_ENABLED, GPOINTER_TO_INT(user_data),
1829 -1);
1830 }
1831
1832 static void
1833 drag_data_get_cb(GtkWidget *widget, GdkDragContext *ctx,
1834 GtkSelectionData *data, guint info, guint time,
1835 AccountsWindow *dialog)
1836 {
1837 GdkAtom target = gtk_selection_data_get_target(data);
1838
1839 if (target == gdk_atom_intern("PURPLE_ACCOUNT", FALSE)) {
1840 GtkTreeRowReference *ref;
1841 GtkTreePath *source_row;
1842 GtkTreeIter iter;
1843 PurpleAccount *account = NULL;
1844 GValue val;
1845
1846 ref = g_object_get_data(G_OBJECT(ctx), "gtk-tree-view-source-row");
1847 source_row = gtk_tree_row_reference_get_path(ref);
1848
1849 if (source_row == NULL)
1850 return;
1851
1852 gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter,
1853 source_row);
1854 val.g_type = 0;
1855 gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model), &iter,
1856 COLUMN_DATA, &val);
1857
1858 dialog->drag_iter = iter;
1859
1860 account = g_value_get_pointer(&val);
1861
1862 gtk_selection_data_set(data, gdk_atom_intern("PURPLE_ACCOUNT", FALSE),
1863 8, (void *)&account, sizeof(account));
1864
1865 gtk_tree_path_free(source_row);
1866 }
1867 }
1868
1869 static void
1870 move_account_after(GtkListStore *store, GtkTreeIter *iter,
1871 GtkTreeIter *position)
1872 {
1873 GtkTreeIter new_iter;
1874 PurpleAccount *account;
1875
1876 gtk_tree_model_get(GTK_TREE_MODEL(store), iter,
1877 COLUMN_DATA, &account,
1878 -1);
1879
1880 gtk_list_store_insert_after(store, &new_iter, position);
1881
1882 set_account(store, &new_iter, account, NULL);
1883
1884 gtk_list_store_remove(store, iter);
1885 }
1886
1887 static void
1888 move_account_before(GtkListStore *store, GtkTreeIter *iter,
1889 GtkTreeIter *position)
1890 {
1891 GtkTreeIter new_iter;
1892 PurpleAccount *account;
1893
1894 gtk_tree_model_get(GTK_TREE_MODEL(store), iter,
1895 COLUMN_DATA, &account,
1896 -1);
1897
1898 gtk_list_store_insert_before(store, &new_iter, position);
1899
1900 set_account(store, &new_iter, account, NULL);
1901
1902 gtk_list_store_remove(store, iter);
1903 }
1904
1905 static void
1906 drag_data_received_cb(GtkWidget *widget, GdkDragContext *ctx,
1907 guint x, guint y, GtkSelectionData *sd,
1908 guint info, guint t, AccountsWindow *dialog)
1909 {
1910 GdkAtom target = gtk_selection_data_get_target(sd);
1911 const guchar *data = gtk_selection_data_get_data(sd);
1912
1913 if (target == gdk_atom_intern("PURPLE_ACCOUNT", FALSE) && data) {
1914 gint dest_index;
1915 PurpleAccount *a = NULL;
1916 GtkTreePath *path = NULL;
1917 GtkTreeViewDropPosition position;
1918
1919 memcpy(&a, data, sizeof(a));
1920
1921 if (gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y,
1922 &path, &position)) {
1923
1924 GtkTreeIter iter;
1925 PurpleAccount *account;
1926 GValue val;
1927
1928 gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, path);
1929 val.g_type = 0;
1930 gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model), &iter,
1931 COLUMN_DATA, &val);
1932
1933 account = g_value_get_pointer(&val);
1934
1935 switch (position) {
1936 case GTK_TREE_VIEW_DROP_AFTER:
1937 case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
1938 move_account_after(dialog->model, &dialog->drag_iter,
1939 &iter);
1940 dest_index = g_list_index(purple_accounts_get_all(),
1941 account) + 1;
1942 break;
1943
1944 case GTK_TREE_VIEW_DROP_BEFORE:
1945 case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
1946 dest_index = g_list_index(purple_accounts_get_all(),
1947 account);
1948
1949 move_account_before(dialog->model, &dialog->drag_iter,
1950 &iter);
1951 break;
1952
1953 default:
1954 return;
1955 }
1956
1957 if (dest_index >= 0)
1958 purple_accounts_reorder(a, dest_index);
1959 }
1960 }
1961 }
1962
1963 static gboolean
1964 accedit_win_destroy_cb(GtkWidget *w, GdkEvent *event, AccountsWindow *dialog)
1965 {
1966 dialog->window = NULL;
1967
1968 pidgin_accounts_window_hide();
1969
1970 return FALSE;
1971 }
1972
1973 static void
1974 add_account_cb(GtkWidget *w, AccountsWindow *dialog)
1975 {
1976 pidgin_account_dialog_show(PIDGIN_ADD_ACCOUNT_DIALOG, NULL);
1977 }
1978
1979 static void
1980 modify_account_sel(GtkTreeModel *model, GtkTreePath *path,
1981 GtkTreeIter *iter, gpointer data)
1982 {
1983 PurpleAccount *account;
1984
1985 gtk_tree_model_get(model, iter, COLUMN_DATA, &account, -1);
1986
1987 if (account != NULL)
1988 pidgin_account_dialog_show(PIDGIN_MODIFY_ACCOUNT_DIALOG, account);
1989 }
1990
1991 static void
1992 modify_account_cb(GtkWidget *w, AccountsWindow *dialog)
1993 {
1994 GtkTreeSelection *selection;
1995
1996 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview));
1997
1998 gtk_tree_selection_selected_foreach(selection, modify_account_sel, dialog);
1999 }
2000
2001 static void
2002 delete_account_cb(PurpleAccount *account)
2003 {
2004 purple_accounts_delete(account);
2005 }
2006
2007 static void
2008 ask_delete_account_sel(GtkTreeModel *model, GtkTreePath *path,
2009 GtkTreeIter *iter, gpointer data)
2010 {
2011 PurpleAccount *account;
2012
2013 gtk_tree_model_get(model, iter, COLUMN_DATA, &account, -1);
2014
2015 if (account != NULL) {
2016 char *buf;
2017
2018 buf = g_strdup_printf(_("Are you sure you want to delete %s?"),
2019 purple_account_get_username(account));
2020
2021 purple_request_close_with_handle(account);
2022 purple_request_action(account, NULL, buf, NULL,
2023 PURPLE_DEFAULT_ACTION_NONE,
2024 purple_request_cpar_from_account(account), account, 2,
2025 _("Delete"), delete_account_cb, _("Cancel"), NULL);
2026 g_free(buf);
2027 }
2028 }
2029
2030 static void
2031 ask_delete_account_cb(GtkWidget *w, AccountsWindow *dialog)
2032 {
2033 GtkTreeSelection *selection;
2034
2035 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview));
2036
2037 gtk_tree_selection_selected_foreach(selection, ask_delete_account_sel,
2038 dialog);
2039 }
2040
2041 static void
2042 close_accounts_cb(GtkWidget *w, AccountsWindow *dialog)
2043 {
2044 pidgin_accounts_window_hide();
2045 }
2046
2047
2048 static void
2049 enabled_cb(GtkCellRendererToggle *renderer, gchar *path_str,
2050 gpointer data)
2051 {
2052 AccountsWindow *dialog = (AccountsWindow *)data;
2053 PurpleAccount *account;
2054 GtkTreeModel *model = GTK_TREE_MODEL(dialog->model);
2055 GtkTreeIter iter;
2056 gboolean enabled;
2057 const PurpleSavedStatus *saved_status;
2058
2059 gtk_tree_model_get_iter_from_string(model, &iter, path_str);
2060 gtk_tree_model_get(model, &iter,
2061 COLUMN_DATA, &account,
2062 COLUMN_ENABLED, &enabled,
2063 -1);
2064
2065 /*
2066 * If we just enabled the account, then set the statuses
2067 * to the current status.
2068 */
2069 if (!enabled)
2070 {
2071 saved_status = purple_savedstatus_get_current();
2072 purple_savedstatus_activate_for_account(saved_status, account);
2073 }
2074
2075 purple_account_set_enabled(account, PIDGIN_UI, !enabled);
2076 }
2077
2078 static void
2079 add_columns(GtkWidget *treeview, AccountsWindow *dialog)
2080 {
2081 GtkCellRenderer *renderer;
2082 GtkTreeViewColumn *column;
2083
2084 /* Enabled */
2085 renderer = gtk_cell_renderer_toggle_new();
2086
2087 g_signal_connect(G_OBJECT(renderer), "toggled",
2088 G_CALLBACK(enabled_cb), dialog);
2089
2090 column = gtk_tree_view_column_new_with_attributes(_("Enabled"),
2091 renderer, "active", COLUMN_ENABLED, NULL);
2092
2093 gtk_tree_view_column_set_resizable(column, FALSE);
2094 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
2095
2096 /* Username column */
2097 column = gtk_tree_view_column_new();
2098 gtk_tree_view_column_set_title(column, _("Username"));
2099 gtk_tree_view_column_set_resizable(column, TRUE);
2100 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
2101
2102 /* Buddy Icon */
2103 renderer = gtk_cell_renderer_pixbuf_new();
2104 gtk_tree_view_column_pack_start(column, renderer, FALSE);
2105 gtk_tree_view_column_add_attribute(column, renderer,
2106 "pixbuf", COLUMN_BUDDYICON);
2107
2108 /* Username */
2109 renderer = gtk_cell_renderer_text_new();
2110 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2111 gtk_tree_view_column_add_attribute(column, renderer,
2112 "text", COLUMN_USERNAME);
2113 dialog->username_col = column;
2114
2115
2116 /* Protocol name */
2117 column = gtk_tree_view_column_new();
2118 gtk_tree_view_column_set_title(column, _("Protocol"));
2119 gtk_tree_view_column_set_resizable(column, FALSE);
2120 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
2121
2122 /* Icon */
2123 renderer = gtk_cell_renderer_pixbuf_new();
2124 gtk_tree_view_column_pack_start(column, renderer, FALSE);
2125 gtk_tree_view_column_add_attribute(column, renderer,
2126 "pixbuf", COLUMN_ICON);
2127
2128 renderer = gtk_cell_renderer_text_new();
2129 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2130 gtk_tree_view_column_add_attribute(column, renderer,
2131 "text", COLUMN_PROTOCOL);
2132 }
2133
2134 static void
2135 set_account(GtkListStore *store, GtkTreeIter *iter, PurpleAccount *account, GdkPixbuf *global_buddyicon)
2136 {
2137 GdkPixbuf *pixbuf, *buddyicon = NULL;
2138 PurpleImage *img = NULL;
2139 PurpleProtocol *protocol = NULL;
2140 PurpleBuddyIconSpec *icon_spec = NULL;
2141
2142 pixbuf = pidgin_create_protocol_icon(account, PIDGIN_PROTOCOL_ICON_MEDIUM);
2143 if ((pixbuf != NULL) && purple_account_is_disconnected(account))
2144 gdk_pixbuf_saturate_and_pixelate(pixbuf, pixbuf, 0.0, FALSE);
2145
2146 protocol = purple_protocols_find(purple_account_get_protocol_id(account));
2147 if (protocol != NULL)
2148 icon_spec = purple_protocol_get_icon_spec(protocol);
2149
2150 if (icon_spec != NULL && icon_spec->format != NULL) {
2151 if (purple_account_get_bool(account, "use-global-buddyicon", TRUE)) {
2152 if (global_buddyicon != NULL)
2153 buddyicon = GDK_PIXBUF(g_object_ref(G_OBJECT(global_buddyicon)));
2154 else {
2155 /* This is for when set_account() is called for a single account */
2156 const char *path;
2157 path = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/accounts/buddyicon");
2158 if ((path != NULL) && (*path != '\0')) {
2159 img = purple_image_new_from_file(path, NULL);
2160 }
2161 }
2162 } else {
2163 img = purple_buddy_icons_find_account_icon(account);
2164 }
2165 }
2166
2167 if (img != NULL) {
2168 GdkPixbuf *buddyicon_pixbuf;
2169 buddyicon_pixbuf = pidgin_pixbuf_from_image(img);
2170 g_object_unref(img);
2171
2172 if (buddyicon_pixbuf != NULL) {
2173 buddyicon = gdk_pixbuf_scale_simple(buddyicon_pixbuf, 22, 22, GDK_INTERP_HYPER);
2174 g_object_unref(G_OBJECT(buddyicon_pixbuf));
2175 }
2176 }
2177
2178 gtk_list_store_set(store, iter,
2179 COLUMN_ICON, pixbuf,
2180 COLUMN_BUDDYICON, buddyicon,
2181 COLUMN_USERNAME, purple_account_get_username(account),
2182 COLUMN_ENABLED, purple_account_get_enabled(account, PIDGIN_UI),
2183 COLUMN_PROTOCOL, purple_account_get_protocol_name(account),
2184 COLUMN_DATA, account,
2185 -1);
2186
2187 if (pixbuf != NULL)
2188 g_object_unref(G_OBJECT(pixbuf));
2189 if (buddyicon != NULL)
2190 g_object_unref(G_OBJECT(buddyicon));
2191 }
2192
2193 static void
2194 add_account_to_liststore(PurpleAccount *account, gpointer user_data)
2195 {
2196 GtkTreeIter iter;
2197 GdkPixbuf *global_buddyicon = user_data;
2198
2199 if (accounts_window == NULL)
2200 return;
2201
2202 gtk_list_store_append(accounts_window->model, &iter);
2203 gtk_notebook_set_current_page(GTK_NOTEBOOK(accounts_window->notebook),1);
2204
2205 set_account(accounts_window->model, &iter, account, global_buddyicon);
2206 }
2207
2208 static gboolean
2209 populate_accounts_list(AccountsWindow *dialog)
2210 {
2211 GList *l;
2212 gboolean ret = FALSE;
2213 GdkPixbuf *global_buddyicon = NULL;
2214 const char *path;
2215
2216 gtk_list_store_clear(dialog->model);
2217
2218 if ((path = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/accounts/buddyicon")) != NULL) {
2219 GdkPixbuf *pixbuf = pidgin_pixbuf_new_from_file(path);
2220 if (pixbuf != NULL) {
2221 global_buddyicon = gdk_pixbuf_scale_simple(pixbuf, 22, 22, GDK_INTERP_HYPER);
2222 g_object_unref(G_OBJECT(pixbuf));
2223 }
2224 }
2225
2226 for (l = purple_accounts_get_all(); l != NULL; l = l->next) {
2227 ret = TRUE;
2228 add_account_to_liststore((PurpleAccount *)l->data, global_buddyicon);
2229 }
2230
2231 if (global_buddyicon != NULL)
2232 g_object_unref(G_OBJECT(global_buddyicon));
2233
2234 return ret;
2235 }
2236
2237 static void
2238 account_selected_cb(GtkTreeSelection *sel, AccountsWindow *dialog)
2239 {
2240 gboolean selected = FALSE;
2241
2242 selected = (gtk_tree_selection_count_selected_rows(sel) > 0);
2243
2244 gtk_widget_set_sensitive(dialog->modify_button, selected);
2245 gtk_widget_set_sensitive(dialog->delete_button, selected);
2246 }
2247
2248 static gboolean
2249 account_treeview_double_click_cb(GtkTreeView *treeview, GdkEventButton *event, gpointer user_data)
2250 {
2251 AccountsWindow *dialog;
2252 GtkTreePath *path;
2253 GtkTreeViewColumn *column;
2254 GtkTreeIter iter;
2255 PurpleAccount *account;
2256
2257 dialog = (AccountsWindow *)user_data;
2258
2259 if (event->window != gtk_tree_view_get_bin_window(treeview))
2260 return FALSE;
2261
2262 /* Figure out which node was clicked */
2263 if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(dialog->treeview), event->x, event->y, &path, &column, NULL, NULL))
2264 return FALSE;
2265 if (column == gtk_tree_view_get_column(treeview, 0)) {
2266 gtk_tree_path_free(path);
2267 return FALSE;
2268 }
2269
2270 gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, path);
2271 gtk_tree_path_free(path);
2272 gtk_tree_model_get(GTK_TREE_MODEL(dialog->model), &iter, COLUMN_DATA, &account, -1);
2273
2274 if ((account != NULL) && (event->button == GDK_BUTTON_PRIMARY) &&
2275 (event->type == GDK_2BUTTON_PRESS))
2276 {
2277 pidgin_account_dialog_show(PIDGIN_MODIFY_ACCOUNT_DIALOG, account);
2278 return TRUE;
2279 }
2280
2281 return FALSE;
2282 }
2283
2284 static GtkWidget *
2285 create_accounts_list(AccountsWindow *dialog)
2286 {
2287 GtkWidget *frame;
2288 GtkWidget *label;
2289 GtkWidget *treeview;
2290 GtkTreeSelection *sel;
2291 GtkTargetEntry gte[] = {{"PURPLE_ACCOUNT", GTK_TARGET_SAME_APP, 0}};
2292 gchar *text;
2293
2294 frame = gtk_frame_new(NULL);
2295 gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
2296
2297 accounts_window->notebook = gtk_notebook_new();
2298 gtk_notebook_set_show_tabs(GTK_NOTEBOOK(accounts_window->notebook), FALSE);
2299 gtk_notebook_set_show_border(GTK_NOTEBOOK(accounts_window->notebook), FALSE);
2300 gtk_container_add(GTK_CONTAINER(frame), accounts_window->notebook);
2301
2302 /* Create a helpful first-time-use label */
2303 label = gtk_label_new(NULL);
2304 /* Translators: Please maintain the use of ⇦ or ⇨ to represent the menu hierarchy */
2305 text = g_strdup_printf(_(
2306 "<span size='larger' weight='bold'>Welcome to %s!</span>\n\n"
2307
2308 "You have no IM accounts configured. To start connecting with %s "
2309 "press the <b>Add...</b> button below and configure your first "
2310 "account. If you want %s to connect to multiple IM accounts, "
2311 "press <b>Add...</b> again to configure them all.\n\n"
2312
2313 "You can come back to this window to add, edit, or remove "
2314 "accounts from <b>Accounts⇨Manage Accounts</b> in the Buddy "
2315 "List window"), PIDGIN_NAME, PIDGIN_NAME, PIDGIN_NAME);
2316 gtk_label_set_markup(GTK_LABEL(label), text);
2317 g_free(text);
2318
2319 gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
2320 gtk_widget_show(label);
2321
2322 gtk_notebook_append_page(GTK_NOTEBOOK(accounts_window->notebook), label, NULL);
2323
2324 /* Create the list model. */
2325 dialog->model = gtk_list_store_new(NUM_COLUMNS,
2326 GDK_TYPE_PIXBUF, /* COLUMN_ICON */
2327 GDK_TYPE_PIXBUF, /* COLUMN_BUDDYICON */
2328 G_TYPE_STRING, /* COLUMN_USERNAME */
2329 G_TYPE_BOOLEAN, /* COLUMN_ENABLED */
2330 G_TYPE_STRING, /* COLUMN_PROTOCOL */
2331 G_TYPE_POINTER /* COLUMN_DATA */
2332 );
2333
2334 /* And now the actual treeview */
2335 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dialog->model));
2336 dialog->treeview = treeview;
2337 g_object_unref(G_OBJECT(dialog->model));
2338
2339 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
2340 gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
2341 g_signal_connect(G_OBJECT(sel), "changed",
2342 G_CALLBACK(account_selected_cb), dialog);
2343
2344 /* Handle double-clicking */
2345 g_signal_connect(G_OBJECT(treeview), "button_press_event",
2346 G_CALLBACK(account_treeview_double_click_cb), dialog);
2347
2348 gtk_notebook_append_page(GTK_NOTEBOOK(accounts_window->notebook),
2349 pidgin_make_scrollable(treeview, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_NONE, -1, -1),
2350 NULL);
2351
2352 add_columns(treeview, dialog);
2353 gtk_tree_view_columns_autosize(GTK_TREE_VIEW(treeview));
2354
2355 if (populate_accounts_list(dialog))
2356 gtk_notebook_set_current_page(GTK_NOTEBOOK(accounts_window->notebook), 1);
2357 else
2358 gtk_notebook_set_current_page(GTK_NOTEBOOK(accounts_window->notebook), 0);
2359
2360 /* Setup DND. I wanna be an orc! */
2361 gtk_tree_view_enable_model_drag_source(
2362 GTK_TREE_VIEW(treeview), GDK_BUTTON1_MASK, gte,
2363 1, GDK_ACTION_COPY);
2364 gtk_tree_view_enable_model_drag_dest(
2365 GTK_TREE_VIEW(treeview), gte, 1,
2366 GDK_ACTION_COPY | GDK_ACTION_MOVE);
2367
2368 g_signal_connect(G_OBJECT(treeview), "drag-data-received",
2369 G_CALLBACK(drag_data_received_cb), dialog);
2370 g_signal_connect(G_OBJECT(treeview), "drag-data-get",
2371 G_CALLBACK(drag_data_get_cb), dialog);
2372
2373 gtk_widget_show_all(frame);
2374 return frame;
2375 }
2376
2377 static void
2378 account_modified_cb(PurpleAccount *account, AccountsWindow *window)
2379 {
2380 GtkTreeIter iter;
2381
2382 if (!accounts_window_find_account_in_treemodel(&iter, account))
2383 return;
2384
2385 set_account(window->model, &iter, account, NULL);
2386 }
2387
2388 static void
2389 global_buddyicon_changed(const char *name, PurplePrefType type,
2390 gconstpointer value, gpointer window)
2391 {
2392 GList *list;
2393 for (list = purple_accounts_get_all(); list; list = list->next) {
2394 account_modified_cb(list->data, window);
2395 }
2396 }
2397
2398 void
2399 pidgin_accounts_window_show(void)
2400 {
2401 AccountsWindow *dialog;
2402 GtkWidget *win;
2403 GtkWidget *vbox;
2404 GtkWidget *sw;
2405 GtkWidget *button;
2406 int width, height;
2407
2408 if (accounts_window != NULL) {
2409 gtk_window_present(GTK_WINDOW(accounts_window->window));
2410 return;
2411 }
2412
2413 accounts_window = dialog = g_new0(AccountsWindow, 1);
2414
2415 width = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/accounts/dialog/width");
2416 height = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/accounts/dialog/height");
2417
2418 dialog->window = win = pidgin_create_dialog(_("Accounts"), 0, "accounts", TRUE);
2419 gtk_window_set_default_size(GTK_WINDOW(win), width, height);
2420
2421 g_signal_connect(G_OBJECT(win), "delete_event",
2422 G_CALLBACK(accedit_win_destroy_cb), accounts_window);
2423
2424 /* Setup the vbox */
2425 vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(win), FALSE, PIDGIN_HIG_BORDER);
2426
2427 /* Setup the scrolled window that will contain the list of accounts. */
2428 sw = create_accounts_list(dialog);
2429 gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
2430 gtk_widget_show(sw);
2431
2432 /* Add button */
2433 pidgin_dialog_add_button(GTK_DIALOG(win), _("_Add..."),
2434 G_CALLBACK(add_account_cb), dialog);
2435
2436 /* Modify button */
2437 button = pidgin_dialog_add_button(GTK_DIALOG(win), _("_Modify..."),
2438 G_CALLBACK(modify_account_cb), dialog);
2439 dialog->modify_button = button;
2440 gtk_widget_set_sensitive(button, FALSE);
2441
2442 /* Delete button */
2443 button = pidgin_dialog_add_button(GTK_DIALOG(win), _("_Delete"),
2444 G_CALLBACK(ask_delete_account_cb), dialog);
2445 dialog->delete_button = button;
2446 gtk_widget_set_sensitive(button, FALSE);
2447
2448 /* Close button */
2449 pidgin_dialog_add_button(GTK_DIALOG(win), _("_Close"),
2450 G_CALLBACK(close_accounts_cb), dialog);
2451
2452 purple_signal_connect(pidgin_accounts_get_handle(), "account-modified",
2453 accounts_window,
2454 PURPLE_CALLBACK(account_modified_cb), accounts_window);
2455 purple_prefs_connect_callback(accounts_window,
2456 PIDGIN_PREFS_ROOT "/accounts/buddyicon",
2457 global_buddyicon_changed, accounts_window);
2458
2459 gtk_widget_show(win);
2460 }
2461
2462 void
2463 pidgin_accounts_window_hide(void)
2464 {
2465 if (accounts_window == NULL)
2466 return;
2467
2468 if (accounts_window->window != NULL)
2469 gtk_widget_destroy(accounts_window->window);
2470
2471 purple_signals_disconnect_by_handle(accounts_window);
2472 purple_prefs_disconnect_by_handle(accounts_window);
2473
2474 g_free(accounts_window);
2475 accounts_window = NULL;
2476 }
2477
2478 static void
2479 free_add_user_data(PidginAccountAddUserData *data)
2480 {
2481 g_free(data->username);
2482 g_free(data->alias);
2483 g_free(data);
2484 }
2485
2486 static void
2487 add_user_cb(PidginAccountAddUserData *data)
2488 {
2489 PurpleConnection *gc = purple_account_get_connection(data->account);
2490
2491 if (g_list_find(purple_connections_get_all(), gc))
2492 {
2493 purple_blist_request_add_buddy(data->account, data->username,
2494 NULL, data->alias);
2495 }
2496
2497 free_add_user_data(data);
2498 }
2499
2500 static char *
2501 make_info(PurpleAccount *account, PurpleConnection *gc, const char *remote_user,
2502 const char *id, const char *alias, const char *msg)
2503 {
2504 if (msg != NULL && *msg == '\0')
2505 msg = NULL;
2506
2507 return g_strdup_printf(_("%s%s%s%s has made %s his or her buddy%s%s"),
2508 remote_user,
2509 (alias != NULL ? " (" : ""),
2510 (alias != NULL ? alias : ""),
2511 (alias != NULL ? ")" : ""),
2512 (id != NULL
2513 ? id
2514 : (purple_connection_get_display_name(gc) != NULL
2515 ? purple_connection_get_display_name(gc)
2516 : purple_account_get_username(account))),
2517 (msg != NULL ? ": " : "."),
2518 (msg != NULL ? msg : ""));
2519 }
2520
2521 static void
2522 pidgin_accounts_notify_added(PurpleAccount *account, const char *remote_user,
2523 const char *id, const char *alias,
2524 const char *msg)
2525 {
2526 char *buffer;
2527 PurpleConnection *gc;
2528 GtkWidget *alert;
2529
2530 gc = purple_account_get_connection(account);
2531
2532 buffer = make_info(account, gc, remote_user, id, alias, msg);
2533 alert = pidgin_make_mini_dialog(gc, "dialog-information", buffer,
2534 NULL, NULL, _("Close"), NULL, NULL);
2535 pidgin_blist_add_alert(alert);
2536
2537 g_free(buffer);
2538 }
2539
2540 static void
2541 pidgin_accounts_request_add(PurpleAccount *account, const char *remote_user,
2542 const char *id, const char *alias,
2543 const char *msg)
2544 {
2545 char *buffer;
2546 PurpleConnection *gc;
2547 PidginAccountAddUserData *data;
2548 GtkWidget *alert;
2549
2550 gc = purple_account_get_connection(account);
2551
2552 data = g_new0(PidginAccountAddUserData, 1);
2553 data->account = account;
2554 data->username = g_strdup(remote_user);
2555 data->alias = g_strdup(alias);
2556
2557 buffer = make_info(account, gc, remote_user, id, alias, msg);
2558 alert = pidgin_make_mini_dialog(gc, "dialog-question",
2559 _("Add buddy to your list?"), buffer, data,
2560 _("Add"), G_CALLBACK(add_user_cb),
2561 _("Cancel"), G_CALLBACK(free_add_user_data), NULL);
2562 pidgin_blist_add_alert(alert);
2563
2564 g_free(buffer);
2565 }
2566
2567 struct auth_request
2568 {
2569 PurpleAccountRequestAuthorizationCb auth_cb;
2570 PurpleAccountRequestAuthorizationCb deny_cb;
2571 void *data;
2572 char *username;
2573 char *alias;
2574 PurpleAccount *account;
2575 gboolean add_buddy_after_auth;
2576 };
2577
2578 static void
2579 free_auth_request(struct auth_request *ar)
2580 {
2581 g_free(ar->username);
2582 g_free(ar->alias);
2583 g_free(ar);
2584 }
2585
2586 static void
2587 authorize_and_add_cb(struct auth_request *ar, const char *message)
2588 {
2589 ar->auth_cb(message, ar->data);
2590 if (ar->add_buddy_after_auth) {
2591 purple_blist_request_add_buddy(ar->account, ar->username, NULL, ar->alias);
2592 }
2593 }
2594
2595 static void
2596 authorize_noreason_cb(struct auth_request *ar)
2597 {
2598 authorize_and_add_cb(ar, NULL);
2599 }
2600
2601 static void
2602 authorize_reason_cb(struct auth_request *ar)
2603 {
2604 const char *protocol_id;
2605 PurpleProtocol *protocol = NULL;
2606
2607 protocol_id = purple_account_get_protocol_id(ar->account);
2608 protocol = purple_protocols_find(protocol_id);
2609
2610 if (protocol && (purple_protocol_get_options(protocol) & OPT_PROTO_AUTHORIZATION_GRANTED_MESSAGE)) {
2611 /* Duplicate information because ar is freed by closing minidialog */
2612 struct auth_request *aa = g_new0(struct auth_request, 1);
2613 aa->auth_cb = ar->auth_cb;
2614 aa->deny_cb = ar->deny_cb;
2615 aa->data = ar->data;
2616 aa->account = ar->account;
2617 aa->username = g_strdup(ar->username);
2618 aa->alias = g_strdup(ar->alias);
2619 aa->add_buddy_after_auth = ar->add_buddy_after_auth;
2620 purple_request_input(ar->account, NULL, _("Authorization acceptance message:"),
2621 NULL, _("No reason given."), TRUE, FALSE, NULL,
2622 _("OK"), G_CALLBACK(authorize_and_add_cb),
2623 _("Cancel"), G_CALLBACK(authorize_noreason_cb),
2624 purple_request_cpar_from_account(ar->account),
2625 aa);
2626 /* FIXME: aa is going to leak now. */
2627 } else {
2628 authorize_noreason_cb(ar);
2629 }
2630 }
2631
2632 static void
2633 deny_no_add_cb(struct auth_request *ar, const char *message)
2634 {
2635 ar->deny_cb(message, ar->data);
2636 }
2637
2638 static void
2639 deny_noreason_cb(struct auth_request *ar)
2640 {
2641 ar->deny_cb(NULL, ar->data);
2642 }
2643
2644 static void
2645 deny_reason_cb(struct auth_request *ar)
2646 {
2647 const char *protocol_id;
2648 PurpleProtocol *protocol = NULL;
2649
2650 protocol_id = purple_account_get_protocol_id(ar->account);
2651 protocol = purple_protocols_find(protocol_id);
2652
2653 if (protocol && (purple_protocol_get_options(protocol) & OPT_PROTO_AUTHORIZATION_DENIED_MESSAGE)) {
2654 /* Duplicate information because ar is freed by closing minidialog */
2655 struct auth_request *aa = g_new0(struct auth_request, 1);
2656 aa->auth_cb = ar->auth_cb;
2657 aa->deny_cb = ar->deny_cb;
2658 aa->data = ar->data;
2659 aa->add_buddy_after_auth = ar->add_buddy_after_auth;
2660 purple_request_input(ar->account, NULL, _("Authorization denied message:"),
2661 NULL, _("No reason given."), TRUE, FALSE, NULL,
2662 _("OK"), G_CALLBACK(deny_no_add_cb),
2663 _("Cancel"), G_CALLBACK(deny_noreason_cb),
2664 purple_request_cpar_from_account(ar->account),
2665 aa);
2666 /* FIXME: aa is going to leak now. */
2667 } else {
2668 deny_noreason_cb(ar);
2669 }
2670 }
2671
2672 static gboolean
2673 get_user_info_cb(GtkWidget *label,
2674 const gchar *uri,
2675 gpointer data)
2676 {
2677 struct auth_request *ar = data;
2678 if (purple_strequal(uri, "viewinfo")) {
2679 pidgin_retrieve_user_info(purple_account_get_connection(ar->account), ar->username);
2680 return TRUE;
2681 }
2682 return FALSE;
2683 }
2684
2685 static void
2686 send_im_cb(PidginMiniDialog *mini_dialog,
2687 GtkButton *button,
2688 gpointer data)
2689 {
2690 struct auth_request *ar = data;
2691 pidgin_dialogs_im_with_user(ar->account, ar->username);
2692 }
2693
2694 static void *
2695 pidgin_accounts_request_authorization(PurpleAccount *account,
2696 const char *remote_user,
2697 const char *id,
2698 const char *alias,
2699 const char *message,
2700 gboolean on_list,
2701 PurpleAccountRequestAuthorizationCb auth_cb,
2702 PurpleAccountRequestAuthorizationCb deny_cb,
2703 void *user_data)
2704 {
2705 char *buffer;
2706 PurpleConnection *gc;
2707 GtkWidget *alert;
2708 PidginMiniDialog *dialog;
2709 GdkPixbuf *protocol_icon;
2710 struct auth_request *aa;
2711 const char *our_name;
2712 gboolean have_valid_alias;
2713 char *escaped_remote_user;
2714 char *escaped_alias;
2715 char *escaped_our_name;
2716 char *escaped_message;
2717
2718 gc = purple_account_get_connection(account);
2719 if (message != NULL && *message != '\0')
2720 escaped_message = g_markup_escape_text(message, -1);
2721 else
2722 escaped_message = g_strdup("");
2723
2724 our_name = (id != NULL) ? id :
2725 (purple_connection_get_display_name(gc) != NULL) ? purple_connection_get_display_name(gc) :
2726 purple_account_get_username(account);
2727 escaped_our_name = g_markup_escape_text(our_name, -1);
2728
2729 escaped_remote_user = g_markup_escape_text(remote_user, -1);
2730
2731 have_valid_alias = alias && *alias;
2732 escaped_alias = have_valid_alias ? g_markup_escape_text(alias, -1) : g_strdup("");
2733
2734 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"),
2735 escaped_remote_user,
2736 (have_valid_alias ? " (" : ""),
2737 escaped_alias,
2738 (have_valid_alias ? ")" : ""),
2739 escaped_our_name,
2740 (*escaped_message ? ": " : "."),
2741 escaped_message);
2742
2743 g_free(escaped_remote_user);
2744 g_free(escaped_alias);
2745 g_free(escaped_our_name);
2746 g_free(escaped_message);
2747
2748 protocol_icon = pidgin_create_protocol_icon(account, PIDGIN_PROTOCOL_ICON_SMALL);
2749
2750 aa = g_new0(struct auth_request, 1);
2751 aa->auth_cb = auth_cb;
2752 aa->deny_cb = deny_cb;
2753 aa->data = user_data;
2754 aa->username = g_strdup(remote_user);
2755 aa->alias = g_strdup(alias);
2756 aa->account = account;
2757 aa->add_buddy_after_auth = !on_list;
2758
2759 alert = pidgin_make_mini_dialog_with_custom_icon(
2760 gc, protocol_icon,
2761 _("Authorize buddy?"), NULL, aa,
2762 _("Authorize"), authorize_reason_cb,
2763 _("Deny"), deny_reason_cb,
2764 NULL);
2765
2766 dialog = PIDGIN_MINI_DIALOG(alert);
2767 pidgin_mini_dialog_enable_description_markup(dialog);
2768 pidgin_mini_dialog_set_link_callback(dialog, G_CALLBACK(get_user_info_cb), aa);
2769 pidgin_mini_dialog_set_description(dialog, buffer);
2770 pidgin_mini_dialog_add_non_closing_button(dialog, _("Send Instant Message"), send_im_cb, aa);
2771
2772 g_signal_connect_swapped(G_OBJECT(alert), "destroy", G_CALLBACK(free_auth_request), aa);
2773 g_signal_connect(G_OBJECT(alert), "destroy", G_CALLBACK(purple_account_request_close), NULL);
2774 pidgin_blist_add_alert(alert);
2775
2776 g_free(buffer);
2777
2778 return alert;
2779 }
2780
2781 static void
2782 pidgin_accounts_request_close(void *ui_handle)
2783 {
2784 gtk_widget_destroy(GTK_WIDGET(ui_handle));
2785 }
2786
2787 static PurpleAccountUiOps ui_ops =
2788 {
2789 pidgin_accounts_notify_added,
2790 NULL,
2791 pidgin_accounts_request_add,
2792 pidgin_accounts_request_authorization,
2793 pidgin_accounts_request_close,
2794 NULL,
2795 NULL,
2796 NULL,
2797 NULL,
2798 NULL, NULL, NULL, NULL
2799 };
2800
2801 PurpleAccountUiOps *
2802 pidgin_accounts_get_ui_ops(void)
2803 {
2804 return &ui_ops;
2805 }
2806
2807 void *
2808 pidgin_accounts_get_handle(void) {
2809 static int handle;
2810
2811 return &handle;
2812 }
2813
2814 void
2815 pidgin_accounts_init(void)
2816 {
2817 char *default_avatar = NULL;
2818 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/accounts");
2819 purple_prefs_add_none(PIDGIN_PREFS_ROOT "/accounts/dialog");
2820 purple_prefs_add_int(PIDGIN_PREFS_ROOT "/accounts/dialog/width", 520);
2821 purple_prefs_add_int(PIDGIN_PREFS_ROOT "/accounts/dialog/height", 321);
2822 default_avatar = g_build_filename(g_get_home_dir(), ".face.icon", NULL);
2823 if (!g_file_test(default_avatar, G_FILE_TEST_EXISTS)) {
2824 g_free(default_avatar);
2825 default_avatar = g_build_filename(g_get_home_dir(), ".face", NULL);
2826 if (!g_file_test(default_avatar, G_FILE_TEST_EXISTS)) {
2827 g_free(default_avatar);
2828 default_avatar = NULL;
2829 }
2830 }
2831
2832 purple_prefs_add_path(PIDGIN_PREFS_ROOT "/accounts/buddyicon", default_avatar);
2833 g_free(default_avatar);
2834
2835 purple_signal_register(pidgin_accounts_get_handle(), "account-modified",
2836 purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
2837 PURPLE_TYPE_ACCOUNT);
2838
2839 /* Setup some purple signal handlers. */
2840 purple_signal_connect(purple_connections_get_handle(), "signed-on",
2841 pidgin_accounts_get_handle(),
2842 PURPLE_CALLBACK(signed_on_off_cb), NULL);
2843 purple_signal_connect(purple_connections_get_handle(), "signed-off",
2844 pidgin_accounts_get_handle(),
2845 PURPLE_CALLBACK(signed_on_off_cb), NULL);
2846 purple_signal_connect(purple_accounts_get_handle(), "account-added",
2847 pidgin_accounts_get_handle(),
2848 PURPLE_CALLBACK(add_account_to_liststore), NULL);
2849 purple_signal_connect(purple_accounts_get_handle(), "account-removed",
2850 pidgin_accounts_get_handle(),
2851 PURPLE_CALLBACK(account_removed_cb), NULL);
2852 purple_signal_connect(purple_accounts_get_handle(), "account-disabled",
2853 pidgin_accounts_get_handle(),
2854 PURPLE_CALLBACK(account_abled_cb), GINT_TO_POINTER(FALSE));
2855 purple_signal_connect(purple_accounts_get_handle(), "account-enabled",
2856 pidgin_accounts_get_handle(),
2857 PURPLE_CALLBACK(account_abled_cb), GINT_TO_POINTER(TRUE));
2858
2859 account_pref_wins =
2860 g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
2861 }
2862
2863 void
2864 pidgin_accounts_uninit(void)
2865 {
2866 /*
2867 * TODO: Need to free all the dialogs in here. Could probably create
2868 * a callback function to use for the free-some-data-function
2869 * parameter of g_hash_table_new_full, above.
2870 */
2871 g_hash_table_destroy(account_pref_wins);
2872
2873 purple_signals_disconnect_by_handle(pidgin_accounts_get_handle());
2874 purple_signals_unregister_by_instance(pidgin_accounts_get_handle());
2875 }
2876
Git mirror of Pidgin's Mercurial repository