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