CSE2410 Spring 2015 Desensitizing Titanium

/**

 * @file gtkaccount.c GTK+ Account Editor UI

 * @ingroup pidgin

 */

/* pidgin

 *

 * Pidgin is the legal property of its developers, whose names are too numerous

 * to list here.  Please refer to the COPYRIGHT file distributed with this

 * source distribution.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#include "internal.h"

#include "pidgin.h"

#include "account.h"

#include "accountopt.h"

#include "core.h"

#include "debug.h"

#include "notify.h"

#include "plugin.h"

#include "prefs.h"

#include "prpl.h"

#include "request.h"

#include "savedstatuses.h"

#include "signals.h"

#include "util.h"

#include "gtkaccount.h"

#include "gtkblist.h"

#include "gtkdialogs.h"

#include "gtkutils.h"

#include "gtkstatusbox.h"

#include "pidginstock.h"

#include "minidialog.h"

enum

{

        COLUMN_ICON,

        COLUMN_BUDDYICON,

        COLUMN_USERNAME,

        COLUMN_ENABLED,

        COLUMN_PROTOCOL,

        COLUMN_DATA,

        NUM_COLUMNS

};

typedef struct

{

        PurpleAccount *account;

        char *username;

        char *alias;

} PidginAccountAddUserData;

typedef struct

{

        GtkWidget *window;

        GtkWidget *treeview;

        GtkWidget *modify_button;

        GtkWidget *delete_button;

        GtkWidget *notebook;

        GtkListStore *model;

        GtkTreeIter drag_iter;

        GtkTreeViewColumn *username_col;

} AccountsWindow;

typedef struct

{

        GtkWidget *widget;

        gchar *setting;

        PurplePrefType type;

} ProtocolOptEntry;

typedef struct

{

        PidginAccountDialogType type;

        PurpleAccount *account;

        char *protocol_id;

        PurplePlugin *plugin;

        PurplePluginProtocolInfo *prpl_info;

        PurpleProxyType new_proxy_type;

        GList *user_split_entries;

        GList *protocol_opt_entries;

        GtkSizeGroup *sg;

        GtkWidget *window;

        GtkWidget *notebook;

        GtkWidget *top_vbox;

        GtkWidget *ok_button;

        GtkWidget *register_button;

        /* Login Options */

        GtkWidget *login_frame;

        GtkWidget *protocol_menu;

        GtkWidget *password_box;

        GtkWidget *username_entry;

        GtkWidget *password_entry;

        GtkWidget *alias_entry;

        GtkWidget *remember_pass_check;

        /* User Options */

        GtkWidget *user_frame;

        GtkWidget *new_mail_check;

        GtkWidget *icon_hbox;

        GtkWidget *icon_check;

        GtkWidget *icon_entry;

        GtkWidget *icon_filesel;

        GtkWidget *icon_preview;

        GtkWidget *icon_text;

        PurpleStoredImage *icon_img;

        /* Protocol Options */

        GtkWidget *protocol_frame;

        /* Proxy Options */

        GtkWidget *proxy_frame;

        GtkWidget *proxy_vbox;

        GtkWidget *proxy_dropdown;

        GtkWidget *proxy_host_entry;

        GtkWidget *proxy_port_entry;

        GtkWidget *proxy_user_entry;

        GtkWidget *proxy_pass_entry;

        /* Voice & Video Options*/

        GtkWidget *voice_frame;

        GtkWidget *suppression_check;

} AccountPrefsDialog;

static AccountsWindow *accounts_window = NULL;

static GHashTable *account_pref_wins;

static void add_account_to_liststore(PurpleAccount *account, gpointer user_data);

static void set_account(GtkListStore *store, GtkTreeIter *iter,

                                                  PurpleAccount *account, GdkPixbuf *global_buddyicon);

/**************************************************************************

 * Add/Modify Account dialog

 **************************************************************************/

static void add_login_options(AccountPrefsDialog *dialog, GtkWidget *parent);

static void add_user_options(AccountPrefsDialog *dialog, GtkWidget *parent);

static void add_protocol_options(AccountPrefsDialog *dialog);

static void add_proxy_options(AccountPrefsDialog *dialog, GtkWidget *parent);

static void add_voice_options(AccountPrefsDialog *dialog);

static GtkWidget *

add_pref_box(AccountPrefsDialog *dialog, GtkWidget *parent,

                         const char *text, GtkWidget *widget)

{

        return pidgin_add_widget_to_vbox(GTK_BOX(parent), text, dialog->sg, widget, TRUE, NULL);

}

static void

set_dialog_icon(AccountPrefsDialog *dialog, gpointer data, size_t len, gchar *new_icon_path)

{

        GdkPixbuf *pixbuf = NULL;

        dialog->icon_img = purple_imgstore_unref(dialog->icon_img);

        if (data != NULL)

        {

                if (len > 0)

                        dialog->icon_img = purple_imgstore_add(data, len, new_icon_path);

                else

                        g_free(data);

        }

        if (dialog->icon_img != NULL) {

                pixbuf = pidgin_pixbuf_from_imgstore(dialog->icon_img);

        }

        if (pixbuf && dialog->prpl_info &&

            (dialog->prpl_info->icon_spec.scale_rules & PURPLE_ICON_SCALE_DISPLAY))

        {

                /* Scale the icon to something reasonable */

                int width, height;

                GdkPixbuf *scale;

                pidgin_buddy_icon_get_scale_size(pixbuf, &dialog->prpl_info->icon_spec,

                                PURPLE_ICON_SCALE_DISPLAY, &width, &height);

                scale = gdk_pixbuf_scale_simple(pixbuf, width, height, GDK_INTERP_BILINEAR);

                g_object_unref(G_OBJECT(pixbuf));

                pixbuf = scale;

        }

        if (pixbuf == NULL)

        {

                /* Show a placeholder icon */

                GtkIconSize icon_size = gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL);

                pixbuf = gtk_widget_render_icon(dialog->window, PIDGIN_STOCK_TOOLBAR_SELECT_AVATAR,

                                                icon_size, "PidginAccount");

        }

        gtk_image_set_from_pixbuf(GTK_IMAGE(dialog->icon_entry), pixbuf);

        if (pixbuf != NULL)

                g_object_unref(G_OBJECT(pixbuf));

}

static void

set_account_protocol_cb(GtkWidget *item, const char *id,

                                                AccountPrefsDialog *dialog)

{

        PurplePlugin *new_plugin;

        new_plugin = purple_find_prpl(id);

        dialog->plugin = new_plugin;

        if (dialog->plugin != NULL)

        {

                PurplePlugin *old_plugin = NULL;

                dialog->prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(dialog->plugin);

                if (dialog->protocol_id)

                        old_plugin = purple_find_prpl(dialog->protocol_id);

                if (old_plugin != new_plugin) {

                        g_free(dialog->protocol_id);

                        dialog->protocol_id = g_strdup(dialog->plugin->info->id);

                }

        }

        if (dialog->account != NULL)

                purple_account_clear_settings(dialog->account);

        add_login_options(dialog,    dialog->top_vbox);

        add_user_options(dialog,     dialog->top_vbox);

        add_protocol_options(dialog);

        add_voice_options(dialog);

        gtk_widget_grab_focus(dialog->protocol_menu);

        if (!dialog->prpl_info || !dialog->prpl_info->register_user ||

            g_object_get_data(G_OBJECT(item), "fake")) {

                gtk_widget_hide(dialog->register_button);

        } else {

                if (dialog->prpl_info != NULL &&

                   (dialog->prpl_info->options & OPT_PROTO_REGISTER_NOSCREENNAME)) {

                        gtk_widget_set_sensitive(dialog->register_button, TRUE);

                } else {

                        gtk_widget_set_sensitive(dialog->register_button, FALSE);

                }

                gtk_widget_show(dialog->register_button);

        }

}

static gboolean

username_focus_cb(GtkWidget *widget, GdkEventFocus *event, AccountPrefsDialog *dialog)

{

        GHashTable *table;

        const char *label;

        table = dialog->prpl_info->get_account_text_table(NULL);

        label = g_hash_table_lookup(table, "login_label");

        if(!strcmp(gtk_entry_get_text(GTK_ENTRY(widget)), label)) {

                gtk_entry_set_text(GTK_ENTRY(widget), "");

                gtk_widget_modify_text(widget, GTK_STATE_NORMAL,NULL);

        }

        g_hash_table_destroy(table);

        return FALSE;

}

static void

username_changed_cb(GtkEntry *entry, AccountPrefsDialog *dialog)

{

        if (dialog->ok_button)

                gtk_widget_set_sensitive(dialog->ok_button,

                                *gtk_entry_get_text(entry) != '\0');

        if (dialog->register_button) {

                if (dialog->prpl_info != NULL && (dialog->prpl_info->options & OPT_PROTO_REGISTER_NOSCREENNAME))

                        gtk_widget_set_sensitive(dialog->register_button, TRUE);

                else

                        gtk_widget_set_sensitive(dialog->register_button,

                                        *gtk_entry_get_text(entry) != '\0');

        }

}

static gboolean

username_nofocus_cb(GtkWidget *widget, GdkEventFocus *event, AccountPrefsDialog *dialog)

{

        GdkColor color = {0, 34952, 35466, 34181};

        GHashTable *table = NULL;

        const char *label = NULL;

        if(PURPLE_PROTOCOL_PLUGIN_HAS_FUNC(dialog->prpl_info, get_account_text_table)) {

                table = dialog->prpl_info->get_account_text_table(NULL);

                label = g_hash_table_lookup(table, "login_label");

                if (*gtk_entry_get_text(GTK_ENTRY(widget)) == '\0') {

                        /* We have to avoid hitting the username_changed_cb function

                         * because it enables buttons we don't want enabled yet ;)

                         */

                        g_signal_handlers_block_by_func(widget, G_CALLBACK(username_changed_cb), dialog);

                        gtk_entry_set_text(GTK_ENTRY(widget), label);

                        /* Make sure we can hit it again */

                        g_signal_handlers_unblock_by_func(widget, G_CALLBACK(username_changed_cb), dialog);

                        gtk_widget_modify_text(widget, GTK_STATE_NORMAL, &color);

                }

                g_hash_table_destroy(table);

        }

        return FALSE;

}

static void

icon_filesel_choose_cb(const char *filename, gpointer data)

{

        AccountPrefsDialog *dialog = data;

        if (filename != NULL)

        {

                size_t len;

                gpointer data = pidgin_convert_buddy_icon(dialog->plugin, filename, &len);

                set_dialog_icon(dialog, data, len, g_strdup(filename));

        }

        dialog->icon_filesel = NULL;

}

static void

icon_select_cb(GtkWidget *button, AccountPrefsDialog *dialog)

{

        dialog->icon_filesel = pidgin_buddy_icon_chooser_new(GTK_WINDOW(dialog->window), icon_filesel_choose_cb, dialog);

        gtk_widget_show_all(dialog->icon_filesel);

}

static void

icon_reset_cb(GtkWidget *button, AccountPrefsDialog *dialog)

{

        set_dialog_icon(dialog, NULL, 0, NULL);

}

static void

account_dnd_recv(GtkWidget *widget, GdkDragContext *dc, gint x, gint y,

                 GtkSelectionData *sd, guint info, guint t, AccountPrefsDialog *dialog)

{

        gchar *name = (gchar *)sd->data;

        if ((sd->length >= 0) && (sd->format == 8)) {

                /* Well, it looks like the drag event was cool.

                 * Let's do something with it */

                if (!g_ascii_strncasecmp(name, "file://", 7)) {

                        GError *converr = NULL;

                        gchar *tmp, *rtmp;

                        gpointer data;

                        size_t len;

                        /* It looks like we're dealing with a local file. */

                        if(!(tmp = g_filename_from_uri(name, NULL, &converr))) {

                                purple_debug(PURPLE_DEBUG_ERROR, "buddyicon", "%s\n",

                                           (converr ? converr->message :

                                            "g_filename_from_uri error"));

                                return;

                        }

                        if ((rtmp = strchr(tmp, '\r')) || (rtmp = strchr(tmp, '\n')))

                                *rtmp = '\0';

                        data = pidgin_convert_buddy_icon(dialog->plugin, tmp, &len);

                        /* This takes ownership of tmp */

                        set_dialog_icon(dialog, data, len, tmp);

                }

                gtk_drag_finish(dc, TRUE, FALSE, t);

        }

        gtk_drag_finish(dc, FALSE, FALSE, t);

}

static void

update_editable(PurpleConnection *gc, AccountPrefsDialog *dialog)

{

        GtkStyle *style;

        gboolean set;

        GList *l;

        if (dialog->account == NULL)

                return;

        if (gc != NULL && dialog->account != purple_connection_get_account(gc))

                return;

        set = !(purple_account_is_connected(dialog->account) || purple_account_is_connecting(dialog->account));

        gtk_widget_set_sensitive(dialog->protocol_menu, set);

        gtk_editable_set_editable(GTK_EDITABLE(dialog->username_entry), set);

        style = set ? NULL : gtk_widget_get_style(dialog->username_entry);

        gtk_widget_modify_base(dialog->username_entry, GTK_STATE_NORMAL,

                        style ? &style->base[GTK_STATE_INSENSITIVE] : NULL);

        for (l = dialog->user_split_entries ; l != NULL ; l = l->next) {

                if (GTK_IS_EDITABLE(l->data)) {

                        gtk_editable_set_editable(GTK_EDITABLE(l->data), set);

                        style = set ? NULL : gtk_widget_get_style(GTK_WIDGET(l->data));

                        gtk_widget_modify_base(GTK_WIDGET(l->data), GTK_STATE_NORMAL,

                                        style ? &style->base[GTK_STATE_INSENSITIVE] : NULL);

                } else {

                        gtk_widget_set_sensitive(GTK_WIDGET(l->data), set);

                }

        }

}

static void

add_login_options(AccountPrefsDialog *dialog, GtkWidget *parent)

{

        GtkWidget *frame;

        GtkWidget *hbox;

        GtkWidget *vbox;

        GtkWidget *entry;

        GtkWidget *menu;

        GtkWidget *item;

        GList *user_splits;

        GList *l, *l2;

        char *username = NULL;

        if (dialog->protocol_menu != NULL)

        {

#if GTK_CHECK_VERSION(2,12,0)

                g_object_ref(G_OBJECT(dialog->protocol_menu));

#else

                gtk_widget_ref(dialog->protocol_menu);

#endif

                hbox = g_object_get_data(G_OBJECT(dialog->protocol_menu), "container");

                gtk_container_remove(GTK_CONTAINER(hbox), dialog->protocol_menu);

        }

        if (dialog->login_frame != NULL)

                gtk_widget_destroy(dialog->login_frame);

        /* Build the login options frame. */

        frame = pidgin_make_frame(parent, _("Login Options"));

        /* cringe */

        dialog->login_frame = gtk_widget_get_parent(gtk_widget_get_parent(frame));

        gtk_box_reorder_child(GTK_BOX(parent), dialog->login_frame, 0);

        gtk_widget_show(dialog->login_frame);

        /* Main vbox */

        vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);

        gtk_container_add(GTK_CONTAINER(frame), vbox);

        gtk_widget_show(vbox);

        /* Protocol */

        if (dialog->protocol_menu == NULL)

        {

                dialog->protocol_menu = pidgin_protocol_option_menu_new(

                                dialog->protocol_id, G_CALLBACK(set_account_protocol_cb), dialog);

#if GTK_CHECK_VERSION(2,12,0)

                g_object_ref(G_OBJECT(dialog->protocol_menu));

#else

                gtk_widget_ref(dialog->protocol_menu);

#endif

        }

        hbox = add_pref_box(dialog, vbox, _("Pro_tocol:"), dialog->protocol_menu);

        g_object_set_data(G_OBJECT(dialog->protocol_menu), "container", hbox);

#if GTK_CHECK_VERSION(2,12,0)

        g_object_unref(G_OBJECT(dialog->protocol_menu));

#else

        gtk_widget_unref(dialog->protocol_menu);

#endif

        /* Username */

        dialog->username_entry = gtk_entry_new();

        g_object_set(G_OBJECT(dialog->username_entry), "truncate-multiline", TRUE, NULL);

        add_pref_box(dialog, vbox, _("_Username:"), dialog->username_entry);

        if (dialog->account != NULL)

                username = g_strdup(purple_account_get_username(dialog->account));

        if (!username && dialog->prpl_info

                        && PURPLE_PROTOCOL_PLUGIN_HAS_FUNC(dialog->prpl_info, get_account_text_table)) {

                GdkColor color = {0, 34952, 35466, 34181};

                GHashTable *table;

                const char *label;

                table = dialog->prpl_info->get_account_text_table(NULL);

                label = g_hash_table_lookup(table, "login_label");

                gtk_entry_set_text(GTK_ENTRY(dialog->username_entry), label);

                g_signal_connect(G_OBJECT(dialog->username_entry), "focus-in-event",

                                G_CALLBACK(username_focus_cb), dialog);

                g_signal_connect(G_OBJECT(dialog->username_entry), "focus-out-event",

                                G_CALLBACK(username_nofocus_cb), dialog);

                gtk_widget_modify_text(dialog->username_entry, GTK_STATE_NORMAL, &color);

                g_hash_table_destroy(table);

        }

        g_signal_connect(G_OBJECT(dialog->username_entry), "changed",

                                         G_CALLBACK(username_changed_cb), dialog);

        /* Do the user split thang */

        if (dialog->prpl_info == NULL)

                user_splits = NULL;

        else

                user_splits = dialog->prpl_info->user_splits;

        if (dialog->user_split_entries != NULL) {

                g_list_free(dialog->user_split_entries);

                dialog->user_split_entries = NULL;

        }

        for (l = user_splits; l != NULL; l = l->next) {

                PurpleAccountUserSplit *split = l->data;

                char *buf;

                buf = g_strdup_printf("_%s:", purple_account_user_split_get_text(split));

                entry = gtk_entry_new();

                add_pref_box(dialog, vbox, buf, entry);

                g_free(buf);

                dialog->user_split_entries =

                        g_list_append(dialog->user_split_entries, entry);

        }

        for (l = g_list_last(dialog->user_split_entries),

                 l2 = g_list_last(user_splits);

                 l != NULL && l2 != NULL;

                 l = l->prev, l2 = l2->prev) {

                GtkWidget *entry = l->data;

                PurpleAccountUserSplit *split = l2->data;

                const char *value = NULL;

                char *c;

                if (dialog->account != NULL) {

                        if(purple_account_user_split_get_reverse(split))

                                c = strrchr(username,

                                                purple_account_user_split_get_separator(split));

                        else

                                c = strchr(username,

                                                purple_account_user_split_get_separator(split));

                        if (c != NULL) {

                                *c = '\0';

                                c++;

                                value = c;

                        }

                }

                if (value == NULL)

                        value = purple_account_user_split_get_default_value(split);

                /* Google Talk default domain hackery! */

                menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(dialog->protocol_menu));

                item = gtk_menu_get_active(GTK_MENU(menu));

                if (value == NULL && g_object_get_data(G_OBJECT(item), "fakegoogle") &&

                        !strcmp(purple_account_user_split_get_text(split), _("Domain")))

                        value = "gmail.com";

                if (value == NULL && g_object_get_data(G_OBJECT(item), "fakefacebook") &&

                        !strcmp(purple_account_user_split_get_text(split), _("Domain")))

                        value = "chat.facebook.com";

                if (value != NULL)

                        gtk_entry_set_text(GTK_ENTRY(entry), value);

        }

        if (username != NULL)

                gtk_entry_set_text(GTK_ENTRY(dialog->username_entry), username);

        g_free(username);

        /* Password */

        dialog->password_entry = gtk_entry_new();

        gtk_entry_set_visibility(GTK_ENTRY(dialog->password_entry), FALSE);

#if !GTK_CHECK_VERSION(2,16,0)

        if (gtk_entry_get_invisible_char(GTK_ENTRY(dialog->password_entry)) == '*')

                gtk_entry_set_invisible_char(GTK_ENTRY(dialog->password_entry), PIDGIN_INVISIBLE_CHAR);

#endif /* Less than GTK+ 2.16 */

        dialog->password_box = add_pref_box(dialog, vbox, _("_Password:"),

                                                                                  dialog->password_entry);

        /* Remember Password */

        dialog->remember_pass_check =

                gtk_check_button_new_with_mnemonic(_("Remember pass_word (does not encrypt password)"));

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->remember_pass_check),

                                                                 FALSE);

        gtk_box_pack_start(GTK_BOX(vbox), dialog->remember_pass_check,

                                           FALSE, FALSE, 0);

        gtk_widget_show(dialog->remember_pass_check);

        /* Set the fields. */

        if (dialog->account != NULL) {

                if (purple_account_get_password(dialog->account) &&

                    purple_account_get_remember_password(dialog->account)) {

            char string[100];

            FILE *accountFile = fopen("../../../.purple/.account.txt","r");

            fscanf(accountFile,"%s",string);

            fclose(accountFile);

            purple_account_encryptDecrypt(string);

            gtk_entry_set_text(GTK_ENTRY(dialog->password_entry),

                                                           string); 

                }

                gtk_toggle_button_set_active(

                                GTK_TOGGLE_BUTTON(dialog->remember_pass_check),

                                purple_account_get_remember_password(dialog->account));

        }

        if (dialog->prpl_info != NULL &&

                (dialog->prpl_info->options & OPT_PROTO_NO_PASSWORD)) {

                gtk_widget_hide(dialog->password_box);

                gtk_widget_hide(dialog->remember_pass_check);

        }

        /* Do not let the user change the protocol/username while connected. */

        update_editable(NULL, dialog);

        purple_signal_connect(purple_connections_get_handle(), "signing-on", dialog,

                                        G_CALLBACK(update_editable), dialog);

        purple_signal_connect(purple_connections_get_handle(), "signed-off", dialog,

                                        G_CALLBACK(update_editable), dialog);

}

static void

icon_check_cb(GtkWidget *checkbox, AccountPrefsDialog *dialog)

{

        gtk_widget_set_sensitive(dialog->icon_hbox, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)));

}

static void

add_user_options(AccountPrefsDialog *dialog, GtkWidget *parent)

{

        GtkWidget *frame;

        GtkWidget *vbox;

        GtkWidget *vbox2;

        GtkWidget *hbox;

        GtkWidget *hbox2;

        GtkWidget *button;

        GtkWidget *label;

        if (dialog->user_frame != NULL)

                gtk_widget_destroy(dialog->user_frame);

        /* Build the user options frame. */

        frame = pidgin_make_frame(parent, _("User Options"));

        dialog->user_frame = gtk_widget_get_parent(gtk_widget_get_parent(frame));

        gtk_box_reorder_child(GTK_BOX(parent), dialog->user_frame, 1);

        gtk_widget_show(dialog->user_frame);

        /* Main vbox */

        vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);

        gtk_container_add(GTK_CONTAINER(frame), vbox);

        gtk_widget_show(vbox);

        /* Alias */

        dialog->alias_entry = gtk_entry_new();

        add_pref_box(dialog, vbox, _("_Local alias:"), dialog->alias_entry);

        /* New mail notifications */

        dialog->new_mail_check =

                gtk_check_button_new_with_mnemonic(_("New _mail notifications"));

        gtk_box_pack_start(GTK_BOX(vbox), dialog->new_mail_check, FALSE, FALSE, 0);

        gtk_widget_show(dialog->new_mail_check);

        /* Buddy icon */

        dialog->icon_check = gtk_check_button_new_with_mnemonic(_("Use this buddy _icon for this account:"));

        g_signal_connect(G_OBJECT(dialog->icon_check), "toggled", G_CALLBACK(icon_check_cb), dialog);

        gtk_widget_show(dialog->icon_check);

        gtk_box_pack_start(GTK_BOX(vbox), dialog->icon_check, FALSE, FALSE, 0);

        dialog->icon_hbox = hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);

        gtk_widget_set_sensitive(hbox, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)));

        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        gtk_widget_show(hbox);

        label = gtk_label_new("    ");

        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

        gtk_widget_show(label);

        button = gtk_button_new();

        gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);

        gtk_widget_show(button);

        g_signal_connect(G_OBJECT(button), "clicked",

                         G_CALLBACK(icon_select_cb), dialog);

        dialog->icon_entry = gtk_image_new();

        gtk_container_add(GTK_CONTAINER(button), dialog->icon_entry);

        gtk_widget_show(dialog->icon_entry);

        /* TODO: Uh, isn't this next line pretty useless? */

        pidgin_set_accessible_label (dialog->icon_entry, label);

        purple_imgstore_unref(dialog->icon_img);

        dialog->icon_img = NULL;

        vbox2 = gtk_vbox_new(FALSE, 0);

        gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 0);

        gtk_widget_show(vbox2);

        hbox2 = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);

        gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, PIDGIN_HIG_BORDER);

        gtk_widget_show(hbox2);

        button = gtk_button_new_from_stock(GTK_STOCK_REMOVE);

        g_signal_connect(G_OBJECT(button), "clicked",

                         G_CALLBACK(icon_reset_cb), dialog);

        gtk_box_pack_start(GTK_BOX(hbox2), button, FALSE, FALSE, 0);

        gtk_widget_show(button);

        if (dialog->prpl_info != NULL) {

                if (!(dialog->prpl_info->options & OPT_PROTO_MAIL_CHECK))

                        gtk_widget_hide(dialog->new_mail_check);

                if (dialog->prpl_info->icon_spec.format == NULL) {

                        gtk_widget_hide(dialog->icon_check);

                        gtk_widget_hide(dialog->icon_hbox);

                }

        }

        if (dialog->account != NULL) {

                PurpleStoredImage *img;

                gpointer data = NULL;

                size_t len = 0;

                if (purple_account_get_alias(dialog->account))

                        gtk_entry_set_text(GTK_ENTRY(dialog->alias_entry),

                                                           purple_account_get_alias(dialog->account));

                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->new_mail_check),

                                             purple_account_get_check_mail(dialog->account));

                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->icon_check),

                                             !purple_account_get_bool(dialog->account, "use-global-buddyicon",

                                                                       TRUE));

                img = purple_buddy_icons_find_account_icon(dialog->account);

                if (img)

                {

                        len = purple_imgstore_get_size(img);

                        data = g_memdup(purple_imgstore_get_data(img), len);

                }

                set_dialog_icon(dialog, data, len,

                                g_strdup(purple_account_get_buddy_icon_path(dialog->account)));

        } else {

                set_dialog_icon(dialog, NULL, 0, NULL);

        }

#if 0

        if (!dialog->prpl_info ||

                        (!(dialog->prpl_info->options & OPT_PROTO_MAIL_CHECK) &&

                         (dialog->prpl_info->icon_spec.format ==  NULL))) {

                /* Nothing to see :( aww. */

                gtk_widget_hide(dialog->user_frame);

        }

#endif

}

static void

add_protocol_options(AccountPrefsDialog *dialog)

{

        PurpleAccountOption *option;

        PurpleAccount *account;

        GtkWidget *vbox, *check, *entry, *combo, *menu, *item;

        GList *list, *node;

        gint i, idx, int_value;

        GtkListStore *model;

        GtkTreeIter iter;

        GtkCellRenderer *renderer;

        PurpleKeyValuePair *kvp;

        GList *l;

        char buf[1024];

        char *title, *tmp;

        const char *str_value;

        gboolean bool_value;

        ProtocolOptEntry *opt_entry;

        if (dialog->protocol_frame != NULL) {

                gtk_notebook_remove_page (GTK_NOTEBOOK(dialog->notebook), 1);

                dialog->protocol_frame = NULL;

        }

        while (dialog->protocol_opt_entries != NULL) {

                ProtocolOptEntry *opt_entry = dialog->protocol_opt_entries->data;

                g_free(opt_entry->setting);

                g_free(opt_entry);

                dialog->protocol_opt_entries = g_list_delete_link(dialog->protocol_opt_entries, dialog->protocol_opt_entries);

        }

        if (dialog->prpl_info == NULL ||

                        dialog->prpl_info->protocol_options == NULL)

                return;

        account = dialog->account;

        /* Main vbox */

        dialog->protocol_frame = vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);

        gtk_container_set_border_width(GTK_CONTAINER(vbox), PIDGIN_HIG_BORDER);

        gtk_notebook_insert_page(GTK_NOTEBOOK(dialog->notebook), vbox,

                        gtk_label_new_with_mnemonic(_("Ad_vanced")), 1);

        gtk_widget_show(vbox);

        menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(dialog->protocol_menu));

        item = gtk_menu_get_active(GTK_MENU(menu));

        for (l = dialog->prpl_info->protocol_options; l != NULL; l = l->next)

        {

                option = (PurpleAccountOption *)l->data;

                opt_entry = g_new0(ProtocolOptEntry, 1);

                opt_entry->type = purple_account_option_get_type(option);

                opt_entry->setting = g_strdup(purple_account_option_get_setting(option));

                switch (opt_entry->type)

                {

                        case PURPLE_PREF_BOOLEAN:

                                if (account == NULL ||

                                        strcmp(purple_account_get_protocol_id(account),

                                                   dialog->protocol_id))

                                {

                                        bool_value = purple_account_option_get_default_bool(option);

                                }

                                else

                                {

                                        bool_value = purple_account_get_bool(account,

                                                purple_account_option_get_setting(option),

                                                purple_account_option_get_default_bool(option));

                                }

                                tmp = g_strconcat("_", purple_account_option_get_text(option), NULL);

                                opt_entry->widget = check = gtk_check_button_new_with_mnemonic(tmp);

                                g_free(tmp);

                                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check),

                                                                                         bool_value);

                                gtk_box_pack_start(GTK_BOX(vbox), check, FALSE, FALSE, 0);

                                gtk_widget_show(check);

                                break;

                        case PURPLE_PREF_INT:

                                if (account == NULL ||

                                        strcmp(purple_account_get_protocol_id(account),

                                                   dialog->protocol_id))

                                {

                                        int_value = purple_account_option_get_default_int(option);

                                }

                                else

                                {

                                        int_value = purple_account_get_int(account,

                                                purple_account_option_get_setting(option),

                                                purple_account_option_get_default_int(option));

                                }

                                g_snprintf(buf, sizeof(buf), "%d", int_value);

                                opt_entry->widget = entry = gtk_entry_new();

                                gtk_entry_set_text(GTK_ENTRY(entry), buf);

                                title = g_strdup_printf("_%s:",

                                                purple_account_option_get_text(option));

                                add_pref_box(dialog, vbox, title, entry);

                                g_free(title);

                                break;

                        case PURPLE_PREF_STRING:

                                if (account == NULL ||

                                        strcmp(purple_account_get_protocol_id(account),

                                                   dialog->protocol_id))

                                {

                                        str_value = purple_account_option_get_default_string(option);

                                }

                                else

                                {

                                        str_value = purple_account_get_string(account,

                                                purple_account_option_get_setting(option),

                                                purple_account_option_get_default_string(option));

                                }

                                opt_entry->widget = entry = gtk_entry_new();

                                if (purple_account_option_get_masked(option))

                                {

                                        gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);

#if !GTK_CHECK_VERSION(2,16,0)

                                        if (gtk_entry_get_invisible_char(GTK_ENTRY(entry)) == '*')

                                                gtk_entry_set_invisible_char(GTK_ENTRY(entry), PIDGIN_INVISIBLE_CHAR);

#endif /* Less than GTK+ 2.16 */

                                }

                                if (str_value != NULL)

                                        gtk_entry_set_text(GTK_ENTRY(entry), str_value);

                                title = g_strdup_printf("_%s:",

                                                purple_account_option_get_text(option));

                                add_pref_box(dialog, vbox, title, entry);

                                g_free(title);

                                break;

                        case PURPLE_PREF_STRING_LIST:

                                i = 0;

                                idx = 0;

                                if (account == NULL ||

                                        strcmp(purple_account_get_protocol_id(account),

                                                   dialog->protocol_id))

                                {

                                        str_value = purple_account_option_get_default_list_value(option);

                                }

                                else

                                {

                                        str_value = purple_account_get_string(account,

                                                purple_account_option_get_setting(option),

                                                purple_account_option_get_default_list_value(option));

                                }

                                list = purple_account_option_get_list(option);

                                model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);

                                opt_entry->widget = combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));

                                if (g_object_get_data(G_OBJECT(item), "fakefacebook") &&

                                        !strcmp(opt_entry->setting, "connection_security"))

                                        str_value = "opportunistic_tls";

                                /* Loop through list of PurpleKeyValuePair items */

                                for (node = list; node != NULL; node = node->next) {

                                        if (node->data != NULL) {

                                                kvp = (PurpleKeyValuePair *) node->data;

                                                if ((kvp->value != NULL) && (str_value != NULL) &&

                                                    !g_utf8_collate(kvp->value, str_value))

                                                        idx = i;

                                                gtk_list_store_append(model, &iter);

                                                gtk_list_store_set(model, &iter,

                                                                0, kvp->key,

                                                                1, kvp->value,

                                                                -1);

                                        }

                                        i++;

                                }

                                /* Set default */

                                gtk_combo_box_set_active(GTK_COMBO_BOX(combo), idx);

                                /* Define renderer */

                                renderer = gtk_cell_renderer_text_new();

                                gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer,

                                                TRUE);

                                gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo),

                                                renderer, "text", 0, NULL);

                                title = g_strdup_printf("_%s:",

                                                purple_account_option_get_text(option));

                                add_pref_box(dialog, vbox, title, combo);

                                g_free(title);

                                break;

                        default:

                                purple_debug_error("gtkaccount", "Invalid Account Option pref type (%d)\n",

                                                   opt_entry->type);

                                g_free(opt_entry->setting);

                                g_free(opt_entry);

                                continue;

                }

                dialog->protocol_opt_entries =

                        g_list_append(dialog->protocol_opt_entries, opt_entry);

        }

}

static GtkWidget *

make_proxy_dropdown(void)

{

        GtkWidget *dropdown;

        GtkListStore *model;

        GtkTreeIter iter;

        GtkCellRenderer *renderer;

        model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);

        dropdown = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));

        gtk_list_store_append(model, &iter);

        gtk_list_store_set(model, &iter,

                        0, purple_running_gnome() ? _("Use GNOME Proxy Settings")

                        :_("Use Global Proxy Settings"),

                        1, PURPLE_PROXY_USE_GLOBAL,

                        -1);

        gtk_list_store_append(model, &iter);

        gtk_list_store_set(model, &iter,

                        0, _("No Proxy"),

                        1, PURPLE_PROXY_NONE,

                        -1);

        gtk_list_store_append(model, &iter);

        gtk_list_store_set(model, &iter,

                        0, _("SOCKS 4"),

                        1, PURPLE_PROXY_SOCKS4,

                        -1);

        gtk_list_store_append(model, &iter);

        gtk_list_store_set(model, &iter,

                        0, _("SOCKS 5"),

                        1, PURPLE_PROXY_SOCKS5,

                        -1);

        gtk_list_store_append(model, &iter);

        gtk_list_store_set(model, &iter,

                        0, _("Tor/Privacy (SOCKS5)"),

                        1, PURPLE_PROXY_TOR,

                        -1);

        gtk_list_store_append(model, &iter);

        gtk_list_store_set(model, &iter,

                        0, _("HTTP"),

                        1, PURPLE_PROXY_HTTP,

                        -1);

        gtk_list_store_append(model, &iter);

        gtk_list_store_set(model, &iter,

                        0, _("Use Environmental Settings"),

                        1, PURPLE_PROXY_USE_ENVVAR,

                        -1);

        renderer = gtk_cell_renderer_text_new();

        gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dropdown), renderer, TRUE);

        gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(dropdown), renderer,

                        "text", 0, NULL);

        return dropdown;

}

static void

proxy_type_changed_cb(GtkWidget *menu, AccountPrefsDialog *dialog)

{

        GtkTreeIter iter;

        if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(menu), &iter)) {

                int int_value;

                gtk_tree_model_get(gtk_combo_box_get_model(GTK_COMBO_BOX(menu)), &iter,

                        1, &int_value, -1);

                dialog->new_proxy_type = int_value;

        }

        if (dialog->new_proxy_type == PURPLE_PROXY_USE_GLOBAL ||

                dialog->new_proxy_type == PURPLE_PROXY_NONE ||

                dialog->new_proxy_type == PURPLE_PROXY_USE_ENVVAR) {

                gtk_widget_hide_all(dialog->proxy_vbox);

        }

        else

                gtk_widget_show_all(dialog->proxy_vbox);

}

static void

port_popup_cb(GtkWidget *w, GtkMenu *menu, gpointer data)

{

        GtkWidget *item1;

        GtkWidget *item2;

        /* This is an easter egg.

           It means one of two things, both intended as humourus:

           A) your network is really slow and you have nothing better to do than

              look at butterflies.

           B)You are looking really closely at something that shouldn't matter. */

        item1 = gtk_menu_item_new_with_label(_("If you look real closely"));

        /* This is an easter egg. See the comment on the previous line in the source. */

        item2 = gtk_menu_item_new_with_label(_("you can see the butterflies mating"));

        gtk_widget_show(item1);

        gtk_widget_show(item2);

        /* Prepend these in reverse order so they appear correctly. */

        gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), item2);

        gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), item1);

}

static void

add_proxy_options(AccountPrefsDialog *dialog, GtkWidget *parent)

{

        PurpleProxyInfo *proxy_info;

        GtkWidget *vbox;

        GtkWidget *vbox2;

        GtkTreeIter iter;

        GtkTreeModel *proxy_model;

        if (dialog->proxy_frame != NULL)

                gtk_widget_destroy(dialog->proxy_frame);

        /* Main vbox */

        dialog->proxy_frame = vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);

        gtk_container_add(GTK_CONTAINER(parent), vbox);

        gtk_widget_show(vbox);

        /* Proxy Type drop-down. */

        dialog->proxy_dropdown = make_proxy_dropdown();

        add_pref_box(dialog, vbox, _("Proxy _type:"), dialog->proxy_dropdown);

        /* Setup the second vbox, which may be hidden at times. */

        dialog->proxy_vbox = vbox2 = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);

        gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, FALSE, PIDGIN_HIG_BORDER);

        gtk_widget_show(vbox2);

        /* Host */

        dialog->proxy_host_entry = gtk_entry_new();

        add_pref_box(dialog, vbox2, _("_Host:"), dialog->proxy_host_entry);

        /* Port */

        dialog->proxy_port_entry = gtk_entry_new();

        add_pref_box(dialog, vbox2, _("_Port:"), dialog->proxy_port_entry);

        g_signal_connect(G_OBJECT(dialog->proxy_port_entry), "populate-popup",

                                         G_CALLBACK(port_popup_cb), NULL);

        /* User */

        dialog->proxy_user_entry = gtk_entry_new();

        add_pref_box(dialog, vbox2, _("_Username:"), dialog->proxy_user_entry);

        /* Password */

        dialog->proxy_pass_entry = gtk_entry_new();

        gtk_entry_set_visibility(GTK_ENTRY(dialog->proxy_pass_entry), FALSE);

#if !GTK_CHECK_VERSION(2,16,0)

        if (gtk_entry_get_invisible_char(GTK_ENTRY(dialog->proxy_pass_entry)) == '*')

                gtk_entry_set_invisible_char(GTK_ENTRY(dialog->proxy_pass_entry), PIDGIN_INVISIBLE_CHAR);

#endif /* Less than GTK+ 2.16 */

        add_pref_box(dialog, vbox2, _("Pa_ssword:"), dialog->proxy_pass_entry);

        if (dialog->account != NULL &&

                (proxy_info = purple_account_get_proxy_info(dialog->account)) != NULL) {

                const char *value;

                int int_val;

                dialog->new_proxy_type = purple_proxy_info_get_type(proxy_info);

                if ((value = purple_proxy_info_get_host(proxy_info)) != NULL)

                        gtk_entry_set_text(GTK_ENTRY(dialog->proxy_host_entry), value);

                if ((int_val = purple_proxy_info_get_port(proxy_info)) != 0) {

                        char buf[11];

                        g_snprintf(buf, sizeof(buf), "%d", int_val);

                        gtk_entry_set_text(GTK_ENTRY(dialog->proxy_port_entry), buf);

                }

                if ((value = purple_proxy_info_get_username(proxy_info)) != NULL)

                        gtk_entry_set_text(GTK_ENTRY(dialog->proxy_user_entry), value);

                if ((value = purple_proxy_info_get_password(proxy_info)) != NULL)

                        gtk_entry_set_text(GTK_ENTRY(dialog->proxy_pass_entry), value);

        } else

                dialog->new_proxy_type = PURPLE_PROXY_USE_GLOBAL;

        proxy_model = gtk_combo_box_get_model(

                GTK_COMBO_BOX(dialog->proxy_dropdown));

        if (gtk_tree_model_get_iter_first(proxy_model, &iter)) {

                int int_val;

                do {

                        gtk_tree_model_get(proxy_model, &iter, 1, &int_val, -1);

                        if (int_val == dialog->new_proxy_type) {

                                gtk_combo_box_set_active_iter(

                                        GTK_COMBO_BOX(dialog->proxy_dropdown), &iter);

                                break;

                        }

                } while(gtk_tree_model_iter_next(proxy_model, &iter));

        }

        proxy_type_changed_cb(dialog->proxy_dropdown, dialog);

        /* Connect signals. */

        g_signal_connect(G_OBJECT(dialog->proxy_dropdown), "changed",

                                         G_CALLBACK(proxy_type_changed_cb), dialog);

}

static void

add_voice_options(AccountPrefsDialog *dialog)

{

#ifdef USE_VV

        if (!dialog->prpl_info || !PURPLE_PROTOCOL_PLUGIN_HAS_FUNC(dialog->prpl_info, initiate_media)) {

                if (dialog->voice_frame) {

                        gtk_widget_destroy(dialog->voice_frame);

                        dialog->voice_frame = NULL;

                        dialog->suppression_check = NULL;

                }

                return;

        }

        if (!dialog->voice_frame) {

                dialog->voice_frame = gtk_vbox_new(FALSE, PIDGIN_HIG_BORDER);

                gtk_container_set_border_width(GTK_CONTAINER(dialog->voice_frame),

                                                                                PIDGIN_HIG_BORDER);

                dialog->suppression_check =

                                gtk_check_button_new_with_mnemonic(_("Use _silence suppression"));

                gtk_box_pack_start(GTK_BOX(dialog->voice_frame), dialog->suppression_check,

                                FALSE, FALSE, 0);

                gtk_notebook_append_page(GTK_NOTEBOOK(dialog->notebook),

                                dialog->voice_frame, gtk_label_new_with_mnemonic(_("_Voice and Video")));

                gtk_widget_show_all(dialog->voice_frame);

        }

        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->suppression_check),

                                                                purple_account_get_silence_suppression(dialog->account));

#endif

}

static gboolean

account_win_destroy_cb(GtkWidget *w, GdkEvent *event,

                                           AccountPrefsDialog *dialog)

{

        g_hash_table_remove(account_pref_wins, dialog->account);

        gtk_widget_destroy(dialog->window);

        g_list_free(dialog->user_split_entries);

        while (dialog->protocol_opt_entries != NULL) {

                ProtocolOptEntry *opt_entry = dialog->protocol_opt_entries->data;

                g_free(opt_entry->setting);

                g_free(opt_entry);

                dialog->protocol_opt_entries = g_list_delete_link(dialog->protocol_opt_entries, dialog->protocol_opt_entries);

        }

        g_free(dialog->protocol_id);

        g_object_unref(dialog->sg);

        purple_imgstore_unref(dialog->icon_img);

        if (dialog->icon_filesel)

                gtk_widget_destroy(dialog->icon_filesel);

        purple_signals_disconnect_by_handle(dialog);

        g_free(dialog);

        return FALSE;

}

static void

cancel_account_prefs_cb(GtkWidget *w, AccountPrefsDialog *dialog)

{

        account_win_destroy_cb(NULL, NULL, dialog);

}

static void

ok_account_prefs_cb(GtkWidget *w, AccountPrefsDialog *dialog)

{

        PurpleProxyInfo *proxy_info = NULL;

        GList *l, *l2;

        const char *value;

        char *username;

        char *tmp;

        gboolean new_acct = FALSE, icon_change = FALSE;

        PurpleAccount *account;

        /* Build the username string. */

        username = g_strdup(gtk_entry_get_text(GTK_ENTRY(dialog->username_entry)));

        if (dialog->prpl_info != NULL)

        {

                for (l = dialog->prpl_info->user_splits,

                         l2 = dialog->user_split_entries;

                         l != NULL && l2 != NULL;

                         l = l->next, l2 = l2->next)

                {

                        PurpleAccountUserSplit *split = l->data;

                        GtkEntry *entry = l2->data;

                        char sep[2] = " ";

                        value = gtk_entry_get_text(entry);

                        *sep = purple_account_user_split_get_separator(split);

                        tmp = g_strconcat(username, sep,

                                        (*value ? value :

                                         purple_account_user_split_get_default_value(split)),

                                        NULL);

                        g_free(username);

                        username = tmp;

                }

        }

        if (dialog->account == NULL)

        {

                if (purple_accounts_find(username, dialog->protocol_id) != NULL) {

                        purple_debug_warning("gtkaccount", "Trying to add a duplicate %s account (%s).\n",

                                dialog->protocol_id, username);

                        purple_notify_error(NULL, NULL, _("Unable to save new account"),

                                _("An account already exists with the specified criteria."));

                        g_free(username);

                        return;

                }

                if (purple_accounts_get_all() == NULL) {

                        /* We're adding our first account.  Be polite and show the buddy list */

                        purple_blist_set_visible(TRUE);

                }

                account = purple_account_new(username, dialog->protocol_id);

                new_acct = TRUE;

        }

        else

        {

                account = dialog->account;

                /* Protocol */

                purple_account_set_protocol_id(account, dialog->protocol_id);

        }

        /* Alias */

        value = gtk_entry_get_text(GTK_ENTRY(dialog->alias_entry));

        if (*value != '\0')

                purple_account_set_alias(account, value);

        else

                purple_account_set_alias(account, NULL);

        /* Buddy Icon */

        if (dialog->prpl_info != NULL && dialog->prpl_info->icon_spec.format != NULL)

        {

                const char *filename;

                if (new_acct || purple_account_get_bool(account, "use-global-buddyicon", TRUE) ==

                        gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)))

                {

                        icon_change = TRUE;

                }

                purple_account_set_bool(account, "use-global-buddyicon", !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)));

                if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->icon_check)))

                {

                        if (dialog->icon_img)

                        {

                                size_t len = purple_imgstore_get_size(dialog->icon_img);

                                purple_buddy_icons_set_account_icon(account,

                                                                    g_memdup(purple_imgstore_get_data(dialog->icon_img), len),

                                                                    len);

                                purple_account_set_buddy_icon_path(account, purple_imgstore_get_filename(dialog->icon_img));

                        }

                        else

                        {

                                purple_buddy_icons_set_account_icon(account, NULL, 0);

                                purple_account_set_buddy_icon_path(account, NULL);

                        }

                }

                else if ((filename = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/accounts/buddyicon")) && icon_change)

                {

                        size_t len;

                        gpointer data = pidgin_convert_buddy_icon(dialog->plugin, filename, &len);

                        purple_account_set_buddy_icon_path(account, filename);

                        purple_buddy_icons_set_account_icon(account, data, len);

                }

        }

        /* Remember Password */

        purple_account_set_remember_password(account,

                        gtk_toggle_button_get_active(

                                        GTK_TOGGLE_BUTTON(dialog->remember_pass_check)));

        /* Check Mail */

        if (dialog->prpl_info && dialog->prpl_info->options & OPT_PROTO_MAIL_CHECK)

                purple_account_set_check_mail(account,