aboutsummaryrefslogblamecommitdiffstats
path: root/mail/mail-config.c
blob: 91142d95a77275453941ef048100017f4c94854b (plain) (tree)
1
2
3
4
5
6
7



                                                                           
            
                                    
                                         























                                                                      
                        
















                                                      














                                                                                        
                                                              

















                                                                                                   


                                                                                 


                                                                                
                                                                                  


                                                                                      























                                                                    




                                                                              





















                                                                       
                              

                                                                
                                       







                                                            









                                                                          
                           








                                                                        








                                                            

                                                                       




























                                                                          

                                                                         












                                                    









                                                                                
 

                                                                           









                                                                     
                                 









                                                                          
                                             
















                                                                       







                                                                              
                           
 





                                                                                     







                                                              

                                                                            




















                                                                            

                                                                                









                                                                     

                                                                           



















































                                                                                        



                                                                 











                                                                         

                                                                                     

























































































                                                                               












                                                 

                                                                  
                       
         













                                                                     

                                                                         
     










                                                                               
      

         




                                  

                                                   
                  




                                  





                                                                              
                                                                     










                                                                    
                                  


               


















                                                                          
 







                                                                         
                                   

                                                                     
 



                                                                
 



                                                        
                            


                                                

       
                                                                                   
                                  






                                                                      



















































                                                                           
                                                                              

























































































                                                                                        
                                                                              
































































































                                                                                        
                                                                                      

                                                                             
                                                                                  


















                                                                                
                                                                                      





                                                                              
                                                                                  







                                                                          
                                                                                 

























                                                                            
                                                


                                  
                                                                                      



                                                                          


                                                                                 
                                                          







                                                                               















                                                                          
                                                                     


































                                                                              
                                              
                               









                                             
                   


                   































                                                                              
 



                                                                              
                             

 






                                                             










                                                    
                                                                 



                                              


                                                       





















                                                                           







                                                                       









































                                                                               



                                                                          
















                                                                               



                                                                          



                               




                                                             

















                                                                       
 


                              





                                      






                           




















                                                                                                 
                    


                                                                         

                                                                               
                                                                                























                                                                                                    
                                 













                                                                                         
                                                                              




































































                                                                                                             
           




                                                                                         
                    










                                                                                          
                                      

                                    
                                             

                                                                               

                                                                                 
                                                                                      









                                            
                                                                                  





































                                                                                         
                                                                           











































                                                                                                             
                                                    


                                                              
                                









                                                                                 

                                                                        
 

                           
 




                                                                     


           
                                                                 
 



                                                       
 

                                                                                
 
                                                                                         
 


                                                                                       


           
                                                                  
 



















                                                                              
 







                                                                                      


                               

                                                               


           
                                                                
 



                                                       
 

                                                                              
 

                                                                                         
                                           
                                                                                      
                                 


           
                                                                 
 
                          



                                     

                      
                             
                       
 
                                                                             

                                 


                                           
                                                                                      
 
                                               





                                                                                   
                                 


           
                                                                   
 



                                                             
                        




                                                                     

                                                
 









                                                                                        
                                                            
         

                       







                                                                         





                                                            


                           
                      

                                    
                            
                                   


                                     
                                


                                    
                                      
                                          
                                       
                             
                                                    
                                             

                            





















                                                                           
 

                                                                            
 


                                                                   
 


                                                                  
 



                                                                 
                                                                       
 
                                                                        
                                         

                                                                     
                                                                       
                                                                        
 











                                                                              


























                                                                                           

         


                                                                            
 
                                                                  
                                      

                                                                 
                                                                       
                                                                     
 










                                                                                  


                                                                                       

         


                                                                          

                                      
                                                                                



                                                                                                            
 




                                                                                     




                                                                                               
                                                                        


                         


                                                                                   
 
                                                                   
                                                            



                                                                                        
















                                                                                      

                                                                                      


                                                                        
                                             

                                                                         
                                             

                                                                           

                                             

                                                                       
                                          

                                                                        
                                          

                                                                          

                                          


                                                                            


                                                                                






                                                                            
 



                                                                   

                                




 
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* mail-config.c: Mail configuration dialogs/wizard. */

/* 
 * Authors: 
 *  Dan Winship <danw@helixcode.com>
 *  Jeffrey Stedfast <fejj@helixcode.com>
 *
 * Copyright 2000 Helix Code, Inc. (http://www.helixcode.com)
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */

#include <config.h>
#include <pwd.h>

#include <gnome.h>
#include <gtkhtml/gtkhtml.h>
#include <glade/glade.h>

#include "mail.h"
#include "e-util/e-html-utils.h"
#include "e-util/e-setup.h"

struct service_type {
    CamelProvider *provider;
    CamelService *service;
    GList *authtypes;
};

struct identity_record {
    char *name, *address, *organization, *sigfile;
};

static char *username = NULL;

/* private prototypes - these are ugly, rename some of them? */
static void html_size_req (GtkWidget *widget, GtkRequisition *requisition);
static GtkWidget *html_new (gboolean white);
static void put_html (GtkHTML *html, char *text);
static void error_dialog (GtkWidget *parent_finder, const char *fmt, ...);
static void identity_note_doneness (GtkObject *page, gpointer user_data);
static void prepare_identity (GnomeDruidPage *page, gpointer arg1, gpointer user_data);
static gboolean identity_next (GnomeDruidPage *page, gpointer arg1, gpointer user_data);
static void destroy_identity (GtkObject *table, gpointer idrecp);
static void create_identity_page (GtkWidget *vbox, struct identity_record *idrec);
static void service_note_doneness (GtkObject *page, gpointer user_data);
static void prepare_service (GnomeDruidPage *page, gpointer arg1, gpointer user_data);
static void auth_menuitem_activate (GtkObject *menuitem, GtkHTML *html);
static void fill_auth_menu (GtkOptionMenu *optionmenu, GtkHTML *html, GList *authtypes);
static char *get_service_url (GtkObject *table);
static void set_service_url (GtkObject *table, char *url_str);
static void autodetect_cb (GtkWidget *button, GtkObject *table);
static gboolean service_acceptable (GtkNotebook *notebook);
static gboolean service_next (GnomeDruidPage *page, gpointer arg1, gpointer user_data);
static void destroy_service (GtkObject *notebook, gpointer urlp);
static void add_row (GtkWidget *table, int row, const char *label_text, const char *tag, int flag);
static GtkWidget *create_source (struct service_type *st);
static GtkWidget *create_transport (struct service_type *st);
static void stype_menuitem_activate (GtkObject *menuitem, GtkObject *table);
static void create_service_page (GtkWidget *vbox, const char *label_text, GList *services,
                 GtkWidget *(*create_service)(struct service_type *),
                 char **urlp);
static void create_source_page (GtkWidget *vbox, GList *sources, char **urlp);
static void create_transport_page (GtkWidget *vbox, GList *transports, char **urlp);
static GList *add_service (GList *services, CamelProviderType type, CamelProvider *prov);
static GdkImlibImage *load_image (const char *name);
static void prepare_first (GnomeDruidPage *page, GnomeDruid *druid, gpointer user_data);
static void cancel (GnomeDruid *druid, gpointer window);
static void finish (GnomeDruidPage *page, gpointer arg1, gpointer window);
static void on_cmdIdentityAdd_clicked (GtkWidget *widget, gpointer user_data);
static void on_cmdIdentityEdit_clicked (GtkWidget *widget, gpointer user_data);
static void on_cmdIdentityDelete_clicked (GtkWidget *widget, gpointer user_data);
static void on_cmdSourcesAdd_clicked (GtkWidget *widget, gpointer user_data);
static void on_cmdSourcesEdit_clicked (GtkWidget *widget, gpointer user_data);
static void on_cmdSourcesDelete_clicked (GtkWidget *widget, gpointer user_data);
static void on_cmdCamelServicesOK_clicked (GtkButton *button, gpointer user_data);
static void on_cmdCamelServicesCancel_clicked (GtkButton *button, gpointer user_data);



/* HTML Helpers */

static void
html_size_req (GtkWidget *widget, GtkRequisition *requisition)
{
    requisition->height = GTK_LAYOUT (widget)->height;
}

/* Returns a GtkHTML which is already inside a GtkScrolledWindow. If
 * @white is TRUE, the GtkScrolledWindow will be inside a GtkFrame.
 */
static GtkWidget *
html_new (gboolean white)
{
    GtkWidget *html, *scrolled, *frame;
    GtkStyle *style;

    html = gtk_html_new ();
    GTK_LAYOUT (html)->height = 0;
    gtk_signal_connect (GTK_OBJECT (html), "size_request",
                GTK_SIGNAL_FUNC (html_size_req), NULL);
    gtk_html_set_editable (GTK_HTML (html), FALSE);
    style = gtk_rc_get_style (html);
    if (style) {
        gtk_html_set_default_background_color (GTK_HTML (html),
                               white ? &style->white :
                               &style->bg[0]);
    }
    gtk_widget_set_sensitive (html, FALSE);
    scrolled = gtk_scrolled_window_new (NULL, NULL);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
                    GTK_POLICY_NEVER,
                    GTK_POLICY_NEVER);
    gtk_container_add (GTK_CONTAINER (scrolled), html);

    if (white) {
        frame = gtk_frame_new (NULL);
        gtk_frame_set_shadow_type (GTK_FRAME (frame),
                       GTK_SHADOW_ETCHED_IN);
        gtk_container_add (GTK_CONTAINER (frame), scrolled);
        gtk_widget_show_all (frame);
    } else
        gtk_widget_show_all (scrolled);

    return html;
}

static void
put_html (GtkHTML *html, char *text)
{
    GtkHTMLStream *handle;

    text = e_text_to_html (text, E_TEXT_TO_HTML_CONVERT_NL);
    handle = gtk_html_begin (html);
    gtk_html_write (html, handle, "<HTML><BODY>", 12);
    gtk_html_write (html, handle, text, strlen (text));
    gtk_html_write (html, handle, "</BODY></HTML>", 14);
    g_free (text);
    gtk_html_end (html, handle, GTK_HTML_STREAM_OK);
}


/* Error helper */
static void
error_dialog (GtkWidget *parent_finder, const char *fmt, ...)
{
    GtkWidget *parent, *dialog;
    char *msg;
    va_list ap;

    parent = gtk_widget_get_ancestor (parent_finder, GTK_TYPE_WINDOW);

    va_start (ap, fmt);
    msg = g_strdup_vprintf (fmt, ap);
    va_end (ap);

    dialog = gnome_error_dialog_parented (msg, GTK_WINDOW (parent));
    gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
    g_free (msg);
}


/* Identity page */

static void
identity_note_doneness (GtkObject *page, gpointer user_data)
{
    GtkWidget *exit_button;
    GtkEntry *entry;
    char *data;

    if (!(exit_button = gtk_object_get_data (page, "exit_button")))
        exit_button = gtk_object_get_data (page, "ok_button");

    entry = gtk_object_get_data (page, "name");
    data = gtk_entry_get_text (entry);
    if (data && *data) {
        entry = gtk_object_get_data (page, "addr");
        data = gtk_entry_get_text (entry);
    }

    gtk_widget_set_sensitive (exit_button, data && *data);
}

static void
prepare_identity (GnomeDruidPage *page, gpointer arg1, gpointer user_data)
{
    identity_note_doneness (user_data, NULL);
}

static gboolean
identity_next (GnomeDruidPage *page, gpointer arg1, gpointer user_data)
{
    GtkObject *box = user_data;
    GtkEntry *addr = gtk_object_get_data (box, "addr");
    char *data, *at;

    /* FIXME: we need more sanity checking than this. */

    data = gtk_entry_get_text (addr);
    at = strchr (data, '@');
    if (!at || !strchr (at + 1, '.')) {
        error_dialog (GTK_WIDGET (page), "Email address must be "
                  "of the form \"user@domain\".");
        return TRUE;
    }

    g_free (username);
    username = g_strndup (data, at - data);

    return FALSE;
}

static void
destroy_identity (GtkObject *table, gpointer idrecp)
{
    struct identity_record *idrec = idrecp;
    GtkWidget *entry;

    entry = gtk_object_get_data (table, "name");
    idrec->name = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));

    entry = gtk_object_get_data (table, "addr");
    idrec->address = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));

    entry = gtk_object_get_data (table, "org");
    idrec->organization = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));

    entry = gtk_object_get_data (table, "sig");
    idrec->sigfile = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
}

static void
create_identity_page (GtkWidget *vbox, struct identity_record *idrec)
{
    GtkWidget *html, *table;
    GtkWidget *name, *addr, *org, *sig;
    GtkWidget *name_entry, *addr_entry, *org_entry, *sig_entry;
    GtkWidget *hsep;
    char *user;
    struct passwd *pw = NULL;

    html = html_new (FALSE);
    put_html (GTK_HTML (html),
          _("Enter your name and email address to be used in "
            "outgoing mail. You may also, optionally, enter the "
            "name of your organization, and the name of a file "
            "to read your signature from."));
    gtk_box_pack_start (GTK_BOX (vbox), html->parent, FALSE, TRUE, 0);

    table = gtk_table_new (5, 2, FALSE);
    gtk_widget_set_name (table, "table");
    gtk_table_set_row_spacings (GTK_TABLE (table), 10);
    gtk_table_set_col_spacings (GTK_TABLE (table), 6);
    gtk_container_set_border_width (GTK_CONTAINER (table), 8);
    gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
    gtk_signal_connect (GTK_OBJECT (vbox), "destroy",
                GTK_SIGNAL_FUNC (destroy_identity), idrec);

    name = gtk_label_new (_("Full name:"));
    gtk_table_attach (GTK_TABLE (table), name, 0, 1, 0, 1,
              GTK_FILL, 0, 0, 0);
    gtk_misc_set_alignment (GTK_MISC (name), 1, 0.5);

    name_entry = gtk_entry_new ();
    gtk_table_attach (GTK_TABLE (table), name_entry, 1, 2, 0, 1,
              GTK_EXPAND | GTK_FILL, 0, 0, 0);
    gtk_object_set_data (GTK_OBJECT (vbox), "name", name_entry);

    if (!idrec || !idrec->name) {
        user = getenv ("USER");
        if (user)
            pw = getpwnam (user);
        else
            pw = getpwuid (getuid ());
    }
    if ((idrec && idrec->name) || (pw && pw->pw_gecos && *pw->pw_gecos)) {
        char *name;

        if (idrec && idrec->name)
            name = g_strdup (idrec->name);
        else
            name = g_strndup (pw->pw_gecos, strcspn (pw->pw_gecos, ","));
        gtk_entry_set_text (GTK_ENTRY (name_entry), name);
        g_free (name);
    }

    addr = gtk_label_new (_("Email address:"));
    gtk_table_attach (GTK_TABLE (table), addr, 0, 1, 1, 2,
              GTK_FILL, 0, 0, 0);
    gtk_misc_set_alignment (GTK_MISC (addr), 1, 0.5);

    addr_entry = gtk_entry_new ();
    if (idrec && idrec->address)
        gtk_entry_set_text (GTK_ENTRY (addr_entry), idrec->address);
    gtk_table_attach (GTK_TABLE (table), addr_entry, 1, 2, 1, 2,
              GTK_EXPAND | GTK_FILL, 0, 0, 0);
    gtk_object_set_data (GTK_OBJECT (vbox), "addr", addr_entry);

    gtk_signal_connect_object (GTK_OBJECT (name_entry), "changed",
                   GTK_SIGNAL_FUNC (identity_note_doneness),
                   GTK_OBJECT (vbox));
    gtk_signal_connect_object (GTK_OBJECT (addr_entry), "changed",
                   GTK_SIGNAL_FUNC (identity_note_doneness),
                   GTK_OBJECT (vbox));

    hsep = gtk_hseparator_new ();
    gtk_table_attach (GTK_TABLE (table), hsep, 0, 2, 2, 3,
              GTK_FILL, 0, 0, 8);

    org = gtk_label_new (_("Organization:"));
    gtk_table_attach (GTK_TABLE (table), org, 0, 1, 3, 4,
              GTK_FILL, 0, 0, 0);
    gtk_misc_set_alignment (GTK_MISC (org), 1, 0.5);

    org_entry = gtk_entry_new ();
    if (idrec && idrec->organization)
        gtk_entry_set_text (GTK_ENTRY (org_entry), idrec->organization);
    gtk_table_attach (GTK_TABLE (table), org_entry, 1, 2, 3, 4,
              GTK_EXPAND | GTK_FILL, 0, 0, 0);
    gtk_object_set_data (GTK_OBJECT (vbox), "org", org_entry);

    sig = gtk_label_new (_("Signature file:"));
    gtk_table_attach (GTK_TABLE (table), sig, 0, 1, 4, 5,
              GTK_FILL, GTK_FILL, 0, 0);
    gtk_misc_set_alignment (GTK_MISC (sig), 1, 0);

    sig_entry = gnome_file_entry_new (NULL, _("Signature File"));
    if (idrec && idrec->sigfile)
        gtk_entry_set_text (GTK_ENTRY (sig_entry), idrec->sigfile);
    gtk_table_attach (GTK_TABLE (table), sig_entry, 1, 2, 4, 5,
              GTK_FILL, 0, 0, 0);
    gnome_file_entry_set_default_path (GNOME_FILE_ENTRY (sig_entry),
                       g_get_home_dir ());
    gtk_object_set_data (GTK_OBJECT (vbox), "sig",
                 gnome_file_entry_gtk_entry (GNOME_FILE_ENTRY (sig_entry)));

    gtk_widget_show_all (table);
}


/* Source/Transport pages */

static void
service_note_doneness (GtkObject *page, gpointer user_data)
{
    GtkObject *box;
    GtkWidget *button;
    GtkEntry *entry;
    char *data;
    gboolean sensitive = TRUE;

    entry = gtk_object_get_data (page, "server_entry");
    if (entry) {
        data = gtk_entry_get_text (entry);
        if (!data || !*data)
            sensitive = FALSE;
    }

    if (sensitive) {
        entry = gtk_object_get_data (page, "user_entry");
        if (entry) {
            data = gtk_entry_get_text (entry);
            if (!data || !*data)
                sensitive = FALSE;
        }
    }

    if (sensitive) {
        entry = gtk_object_get_data (page, "path_entry");
        if (entry) {
            data = gtk_entry_get_text (entry);
            if (!data || !*data)
                sensitive = FALSE;
        }
    }

    button = gtk_object_get_data (page, "autodetect");
    if (button)
        gtk_widget_set_sensitive (button, sensitive);

    box = gtk_object_get_data (page, "box");
    
    if (!(button = gtk_object_get_data (box, "exit_button")))
        button = gtk_object_get_data (box, "ok_button");

    if (button)
        gtk_widget_set_sensitive (button, sensitive);
}

static void
prepare_service (GnomeDruidPage *page, gpointer arg1, gpointer user_data)
{
    GtkObject *box = user_data;
    GtkNotebook *notebook = gtk_object_get_data (box, "notebook");
    GtkWidget *table;
    GtkEntry *entry;

    table = gtk_notebook_get_nth_page (notebook,
                       gtk_notebook_get_current_page (notebook));

    if (username) {
        char *data = NULL;

        entry = gtk_object_get_data (GTK_OBJECT (table), "user_entry");
        if (entry) {
            data = gtk_entry_get_text (entry);
            if (!data || !*data)
                gtk_entry_set_text (entry, username);
        }
    }

    service_note_doneness (GTK_OBJECT (table), NULL);
}

static void
auth_menuitem_activate (GtkObject *menuitem, GtkHTML *html)
{
    CamelServiceAuthType *authtype;

    authtype = gtk_object_get_data (menuitem, "authtype");
    put_html (html, authtype->description);
}

static void
fill_auth_menu (GtkOptionMenu *optionmenu, GtkHTML *html, GList *authtypes)
{
    CamelServiceAuthType *authtype;
    GtkWidget *menu, *item, *firstitem = NULL;

    menu = gtk_menu_new ();
    gtk_option_menu_set_menu (optionmenu, menu);
    for (; authtypes; authtypes = authtypes->next) {
        authtype = authtypes->data;
        item = gtk_menu_item_new_with_label (_(authtype->name));
        if (!firstitem)
            firstitem = item;
        gtk_menu_append (GTK_MENU (menu), item);
        gtk_object_set_data (GTK_OBJECT (item), "authtype", authtype);
        gtk_signal_connect (GTK_OBJECT (item), "activate",
                    GTK_SIGNAL_FUNC (auth_menuitem_activate),
                    html);
    }
    gtk_widget_show_all (menu);
    gtk_option_menu_set_history (optionmenu, 0);
    if (firstitem)
        auth_menuitem_activate (GTK_OBJECT (firstitem), html);
}

static char *
get_service_url (GtkObject *table)
{
    CamelURL *url;
    GtkEditable *editable;
    GtkOptionMenu *auth_optionmenu;
    char *url_str;

    url = g_new0 (CamelURL, 1);
    url->protocol = g_strdup (gtk_object_get_data (table, "protocol"));
    editable = gtk_object_get_data (table, "user_entry");
    if (editable)
        url->user = gtk_editable_get_chars (editable, 0, -1);
    editable = gtk_object_get_data (table, "server_entry");
    if (editable)
        url->host = gtk_editable_get_chars (editable, 0, -1);
    editable = gtk_object_get_data (table, "path_entry");
    if (editable)
        url->path = gtk_editable_get_chars (editable, 0, -1);

    auth_optionmenu = gtk_object_get_data (table, "auth_optionmenu");
    if (auth_optionmenu) {
        GtkWidget *menu, *item;
        CamelServiceAuthType *authtype;

        menu = gtk_option_menu_get_menu (auth_optionmenu);
        if (menu) {
            item = gtk_menu_get_active (GTK_MENU (menu));
            authtype = gtk_object_get_data (GTK_OBJECT (item),
                            "authtype");
            if (*authtype->authproto)
                url->authmech = g_strdup (authtype->authproto);
        }
    }

    url_str = camel_url_to_string (url, FALSE);
    camel_url_free (url);
    return url_str;
}

static void
set_service_url (GtkObject *table, char *url_str)
{
    CamelURL *url;
    GtkEditable *editable;
    GtkOptionMenu *auth_optionmenu;
    CamelException *ex;

    g_return_if_fail (table != NULL);
    g_return_if_fail (url_str != NULL);

    ex = camel_exception_new ();
    
    url = camel_url_new (url_str, ex);
    if (camel_exception_get_id (ex) != CAMEL_EXCEPTION_NONE) {
        camel_exception_free (ex);
        return;
    }

    editable = gtk_object_get_data (table, "user_entry");
    if (editable && url)
        gtk_entry_set_text (GTK_ENTRY (editable), url->user);

    editable = gtk_object_get_data (table, "server_entry");
    if (editable && url)
        gtk_entry_set_text (GTK_ENTRY (editable), url->host);

    editable = gtk_object_get_data (table, "path_entry");
    if (editable && url)
        gtk_entry_set_text (GTK_ENTRY (editable), url->path);

        /* How are we gonna do this? */
    auth_optionmenu = gtk_object_get_data (table, "auth_optionmenu");
    if (auth_optionmenu) {
#if 0
        GtkWidget *menu, *item;
        CamelServiceAuthType *authtype;

        menu = gtk_option_menu_get_menu (auth_optionmenu);
        if (menu) {
            item = gtk_menu_get_active (GTK_MENU (menu));
            authtype = gtk_object_get_data (GTK_OBJECT (item),
                            "authtype");
            if (*authtype->authproto)
                url->authmech = g_strdup (authtype->authproto);
        }
#endif
    }

    camel_exception_free (ex);
    camel_url_free (url);
}

static void
autodetect_cb (GtkWidget *button, GtkObject *table)
{
    char *url;
    CamelException *ex;
    CamelService *service;
    GList *authtypes;
    GtkHTML *html;
    GtkOptionMenu *optionmenu;
    int type;

    type = GPOINTER_TO_UINT (gtk_object_get_data (table, "service_type"));
    url = get_service_url (table);

    ex = camel_exception_new ();
    service = camel_session_get_service (session, url, type, ex);
    g_free (url);
    if (camel_exception_get_id (ex) != CAMEL_EXCEPTION_NONE)
        goto error;

    authtypes = camel_service_query_auth_types (service, ex);
    if (camel_exception_get_id (ex) != CAMEL_EXCEPTION_NONE)
        goto error;

    html = gtk_object_get_data (table, "auth_html");
    optionmenu = gtk_object_get_data (table, "auth_optionmenu");
    fill_auth_menu (optionmenu, html, authtypes);
    camel_exception_free (ex);
    return;

 error:
    error_dialog (button, "Could not detect supported authentication "
              "types:\n%s", camel_exception_get_description (ex));
    camel_exception_free (ex);
}

static gboolean
service_acceptable (GtkNotebook *notebook)
{
    char *url;
    GtkWidget *table;
    GtkToggleButton *check;
    int page, type;
    CamelService *service;
    CamelException *ex;
    gboolean ok;

    page = gtk_notebook_get_current_page (notebook);
    table = gtk_notebook_get_nth_page (notebook, page);
    check = gtk_object_get_data (GTK_OBJECT (table), "check");

    if (!check || !gtk_toggle_button_get_active (check))
        return TRUE;

    type = GPOINTER_TO_UINT (gtk_object_get_data (GTK_OBJECT (table),
                              "service_type"));
    url = get_service_url (GTK_OBJECT (table));

    ex = camel_exception_new ();
    camel_exception_clear (ex);
    service = camel_session_get_service (session, url, type, ex);
    g_free (url);

    if (camel_exception_get_id (ex) != CAMEL_EXCEPTION_NONE)
        goto error;

    ok = camel_service_connect (service, ex);

    if (ok) {
        camel_service_disconnect (service, ex);
        gtk_object_unref (GTK_OBJECT (service));
        camel_exception_free (ex);
        return TRUE;
    }

    gtk_object_unref (GTK_OBJECT (service));

 error:
    error_dialog (GTK_WIDGET (notebook), camel_exception_get_description (ex));
    camel_exception_free (ex);
    return FALSE;
}

static gboolean
service_next (GnomeDruidPage *page, gpointer arg1, gpointer user_data)
{
    return !service_acceptable (user_data);
}

static void
destroy_service (GtkObject *notebook, gpointer urlp)
{
    char **url = urlp;
    GtkWidget *table;
    int page;

    page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
    table = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), page);
    *url = get_service_url (GTK_OBJECT (table));
}

static void
add_row (GtkWidget *table, int row, const char *label_text,
     const char *tag, int flag)
{
    GtkWidget *label, *entry;

    label = gtk_label_new (label_text);
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, row, row + 1,
              GTK_FILL, 0, 0, 0);
    gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);

    entry = gtk_entry_new ();
    gtk_table_attach (GTK_TABLE (table), entry, 1, 3, row, row + 1,
              GTK_EXPAND | GTK_FILL, 0, 0, 0);
    gtk_signal_connect_object (GTK_OBJECT (entry), "changed",
                   GTK_SIGNAL_FUNC (service_note_doneness),
                   GTK_OBJECT (table));
    gtk_object_set_data (GTK_OBJECT (table), tag, entry);
}

static GtkWidget *
create_source (struct service_type *st)
{
    GtkWidget *table;
    GtkWidget *auth, *auth_optionmenu, *auth_html;
    GtkWidget *autodetect;
    int row, service_flags;

    table = gtk_table_new (5, 3, FALSE);
    gtk_table_set_row_spacings (GTK_TABLE (table), 2);
    gtk_table_set_col_spacings (GTK_TABLE (table), 10);
    gtk_container_set_border_width (GTK_CONTAINER (table), 8);
    gtk_object_set_data (GTK_OBJECT (table), "protocol",
                 st->provider->protocol);
    gtk_object_set_data (GTK_OBJECT (table), "service_type",
                 GUINT_TO_POINTER (CAMEL_PROVIDER_STORE));

    row = 0;
    service_flags = st->service->url_flags & ~CAMEL_SERVICE_URL_NEED_AUTH;

    if (service_flags & CAMEL_SERVICE_URL_NEED_HOST) {
        add_row (table, row, _("Server:"), "server_entry",
             CAMEL_SERVICE_URL_NEED_HOST);
        row++;
    }

    if (service_flags & CAMEL_SERVICE_URL_NEED_USER) {
        add_row (table, row, _("Username:"), "user_entry",
             CAMEL_SERVICE_URL_NEED_USER);
        row++;
    }

    if (service_flags & CAMEL_SERVICE_URL_NEED_PATH) {
        add_row (table, row, _("Path:"), "path_entry",
             CAMEL_SERVICE_URL_NEED_PATH);
        row++;
    }

    if (st->authtypes) {
        auth = gtk_label_new (_("Authentication:"));
        gtk_table_attach (GTK_TABLE (table), auth, 0, 1,
                  row, row + 1, GTK_FILL, 0, 0, 0);
        gtk_misc_set_alignment (GTK_MISC (auth), 1, 0.5);

        auth_optionmenu = gtk_option_menu_new ();
        gtk_table_attach (GTK_TABLE (table), auth_optionmenu, 1, 2,
                  row, row + 1, GTK_FILL | GTK_EXPAND,
                  0, 0, 0);
        gtk_object_set_data (GTK_OBJECT (table), "auth_optionmenu",
                     auth_optionmenu);

        autodetect = gtk_button_new_with_label (_("Detect supported types..."));
        gtk_table_attach (GTK_TABLE (table), autodetect, 2, 3,
                  row, row + 1, 0, 0, 0, 0);
        gtk_widget_set_sensitive (autodetect, FALSE);
        gtk_signal_connect (GTK_OBJECT (autodetect), "clicked",
                    GTK_SIGNAL_FUNC (autodetect_cb), table);
        gtk_object_set_data (GTK_OBJECT (table), "autodetect",
                     autodetect);

        auth_html = html_new (TRUE);
        gtk_table_attach (GTK_TABLE (table), auth_html->parent->parent,
                  0, 3, row + 1, row + 2,
                  GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
        gtk_object_set_data (GTK_OBJECT (table), "auth_html",
                     auth_html);

        fill_auth_menu (GTK_OPTION_MENU (auth_optionmenu),
                GTK_HTML (auth_html), st->authtypes);

        row += 2;
    }

    if (row != 0) {
        GtkWidget *check;

        check = gtk_check_button_new_with_label (
            _("Test these values before continuing"));
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
        gtk_table_attach (GTK_TABLE (table), check, 0, 3,
                  row, row + 1, GTK_FILL, GTK_FILL, 0, 0);
        gtk_object_set_data (GTK_OBJECT (table), "check", check);
        row += 1;
    }

    gtk_table_resize (GTK_TABLE (table), row, 3);
    gtk_widget_show_all (table);

    return table;
}

static GtkWidget *
create_transport (struct service_type *st)
{
    GtkWidget *table;
    GtkWidget *auth, *auth_optionmenu, *auth_html;
    GtkWidget *autodetect;
    int row, service_flags;

    table = gtk_table_new (5, 3, FALSE);
    gtk_table_set_row_spacings (GTK_TABLE (table), 2);
    gtk_table_set_col_spacings (GTK_TABLE (table), 10);
    gtk_container_set_border_width (GTK_CONTAINER (table), 8);
    gtk_object_set_data (GTK_OBJECT (table), "protocol",
                 st->provider->protocol);
    gtk_object_set_data (GTK_OBJECT (table), "service_type",
                 GUINT_TO_POINTER (CAMEL_PROVIDER_TRANSPORT));

    row = 0;
    service_flags = st->service->url_flags & ~CAMEL_SERVICE_URL_NEED_AUTH;

    if (service_flags & CAMEL_SERVICE_URL_NEED_HOST) {
        add_row (table, row, _("Server:"), "server_entry",
             CAMEL_SERVICE_URL_NEED_HOST);
        row++;
    }

    if (st->authtypes) {
        auth = gtk_label_new (_("Authentication:"));
        gtk_table_attach (GTK_TABLE (table), auth, 0, 1,
                  row, row + 1, GTK_FILL, 0, 0, 0);
        gtk_misc_set_alignment (GTK_MISC (auth), 1, 0.5);

        auth_optionmenu = gtk_option_menu_new ();
        gtk_table_attach (GTK_TABLE (table), auth_optionmenu, 1, 2,
                  row, row + 1, GTK_FILL | GTK_EXPAND,
                  0, 0, 0);
        gtk_object_set_data (GTK_OBJECT (table), "auth_optionmenu",
                     auth_optionmenu);

        autodetect = gtk_button_new_with_label (_("Detect supported types..."));
        gtk_table_attach (GTK_TABLE (table), autodetect, 2, 3,
                  row, row + 1, 0, 0, 0, 0);
        gtk_widget_set_sensitive (autodetect, FALSE);
        gtk_object_set_data (GTK_OBJECT (table), "autodetect",
                     autodetect);

        auth_html = html_new (TRUE);
        gtk_table_attach (GTK_TABLE (table), auth_html->parent->parent,
                  0, 3, row + 1, row + 2,
                  GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

        fill_auth_menu (GTK_OPTION_MENU (auth_optionmenu),
                GTK_HTML (auth_html), st->authtypes);

        row += 2;
    }

    if (row != 0) {
        GtkWidget *check;

        check = gtk_check_button_new_with_label (
            _("Test these values before continuing"));
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
        gtk_table_attach (GTK_TABLE (table), check, 0, 3,
                  row, row + 1, GTK_FILL | GTK_EXPAND,
                  GTK_FILL, 0, 0);
        gtk_object_set_data (GTK_OBJECT (table), "check", check);
        row += 1;
    }

    gtk_table_resize (GTK_TABLE (table), row, 3);
    gtk_widget_show_all (table);

    return table;
}

static void
stype_menuitem_activate (GtkObject *menuitem, GtkObject *table)
{
    GtkHTML *html;
    char *text;
    int page;
    GtkNotebook *notebook;

    text = gtk_object_get_data (menuitem, "description");
    html = gtk_object_get_data (table, "html");
    put_html (html, text);

    page = GPOINTER_TO_UINT (gtk_object_get_data (menuitem, "page"));
    notebook = gtk_object_get_data (table, "notebook");
    gtk_notebook_set_page (notebook, page);
    service_note_doneness (GTK_OBJECT (gtk_notebook_get_nth_page (notebook,
                                      page)),
                   NULL);                  
}

/* Create the mail source/transport page. */
static void
create_service_page (GtkWidget *vbox, const char *label_text, GList *services,
             GtkWidget *(*create_service)(struct service_type *),
             char **urlp)
{
    GtkWidget *hbox, *stype, *stype_optionmenu, *stype_menu;
    GtkWidget *menuitem, *first_menuitem = NULL;
    GtkWidget *stype_html, *notebook, *service;
    int page;
    GList *s;

    hbox = gtk_hbox_new (FALSE, 8);
    gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);

    stype = gtk_label_new (label_text);
    gtk_box_pack_start (GTK_BOX (hbox), stype, FALSE, FALSE, 0);
    gtk_misc_set_alignment (GTK_MISC (stype), 1, 0.5);

    stype_optionmenu = gtk_option_menu_new ();
    gtk_object_set_data (GTK_OBJECT (vbox), "stype_optionmenu", stype_optionmenu);
    gtk_box_pack_start (GTK_BOX (hbox), stype_optionmenu, TRUE, TRUE, 0);
    stype_menu = gtk_menu_new ();
    gtk_option_menu_set_menu (GTK_OPTION_MENU (stype_optionmenu), stype_menu);

    stype_html = html_new (TRUE);
    gtk_object_set_data (GTK_OBJECT (vbox), "html", stype_html);
    gtk_box_pack_start (GTK_BOX (vbox), stype_html->parent->parent,
                TRUE, TRUE, 0);

    notebook = gtk_notebook_new ();
    gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE);
    gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
    gtk_object_set_data (GTK_OBJECT (vbox), "notebook", notebook);
    gtk_signal_connect (GTK_OBJECT (notebook), "destroy",
                GTK_SIGNAL_FUNC (destroy_service), urlp);

    for (s = services, page = 0; s; s = s->next, page++) {
        struct service_type *st = s->data;

        menuitem = gtk_menu_item_new_with_label (_(st->provider->name));
        if (!first_menuitem)
            first_menuitem = menuitem;
        gtk_object_set_data (GTK_OBJECT (vbox), st->provider->name, menuitem);
        gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
                    GTK_SIGNAL_FUNC (stype_menuitem_activate),
                    vbox);
        gtk_menu_append (GTK_MENU (stype_menu), menuitem);

        service = (*create_service) (st);
        gtk_notebook_append_page (GTK_NOTEBOOK (notebook), service, NULL);
        gtk_object_set_data (GTK_OBJECT (service), "box", vbox);

        gtk_object_set_data (GTK_OBJECT (menuitem), "page",
                     GUINT_TO_POINTER (page));
        gtk_object_set_data (GTK_OBJECT (menuitem), "description",
                     st->provider->description);
    }

    stype_menuitem_activate (GTK_OBJECT (first_menuitem), GTK_OBJECT (vbox));
    gtk_option_menu_set_history (GTK_OPTION_MENU (stype_optionmenu), 0);

    gtk_widget_show_all (vbox);
}

static void
create_source_page (GtkWidget *vbox, GList *sources, char **urlp)
{
    GtkWidget *html;

    html = html_new (FALSE);
    put_html (GTK_HTML (html),
          _("Select the kind of mail server you have, and enter "
            "the relevant information about it.\n\nIf the server "
            "requires authentication, you can click the "
            "\"Detect supported types...\" button after entering "
            "the other information."));
    gtk_box_pack_start (GTK_BOX (vbox), html->parent, FALSE, TRUE, 0);

    create_service_page (vbox, "Mail source type:", sources,
                 create_source, urlp);
}

static void
create_transport_page (GtkWidget *vbox, GList *transports, char **urlp)
{
    GtkWidget *html, *optionmenu, *menuitem;

    html = html_new (FALSE);
    put_html (GTK_HTML (html),
          _("Select the method you would like to use to deliver your mail."));
    gtk_box_pack_start (GTK_BOX (vbox), html->parent, FALSE, TRUE, 0);

    create_service_page (vbox, "Mail transport type:", transports,
                 create_transport, urlp);

    optionmenu = gtk_object_get_data (GTK_OBJECT (vbox), "stype_optionmenu");

    if (*urlp && !strncasecmp(*urlp, "sendmail", 8)) {
        menuitem = gtk_object_get_data (GTK_OBJECT (vbox), "Sendmail");
        gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 1);
    } else {
        menuitem = gtk_object_get_data (GTK_OBJECT (vbox), "SMTP");
        gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 0);
    }

    stype_menuitem_activate (GTK_OBJECT (menuitem), GTK_OBJECT (vbox));
}


/* Generic stuff */

static GList *
add_service (GList *services, CamelProviderType type, CamelProvider *prov)
{
    CamelService *service;
    CamelException *ex;
    char *url;
    struct service_type *st;

    ex = camel_exception_new ();

    url = g_strdup_printf ("%s:", prov->protocol);
    service = camel_session_get_service (session, url, type, ex);
    g_free (url);
    if (!service) {
        camel_exception_free (ex);
        return services;
    }

    st = g_new (struct service_type, 1);
    st->provider = prov;
    st->service = service;
    st->authtypes = camel_service_query_auth_types (st->service, ex);
    camel_exception_free (ex);

    return g_list_append (services, st);
}

static GdkImlibImage *
load_image (const char *name)
{
    char *path;
    GdkImlibImage *image;

    path = g_strdup_printf ("/usr/local/share/images/evolution/%s", name);
    image = gdk_imlib_load_image (path);
    g_free (path);

    return image;
}

static void
prepare_first (GnomeDruidPage *page, GnomeDruid *druid, gpointer user_data)
{
    gnome_druid_set_buttons_sensitive (druid, TRUE, TRUE, TRUE);
}

static struct identity_record idrec;
static char *source = NULL, *transport = NULL;
static gboolean format = FALSE;

static void
cancel (GnomeDruid *druid, gpointer window)
{
    gtk_window_set_modal (window, FALSE);
    gtk_widget_destroy (window);
    gtk_main_quit ();
}

static void
write_config (void)
{
    char *path;

    /* According to the API docs, there's an easier way to do this,
     * except that it doesn't work. Anyway, this will be replaced
     * by GConf eventually. FIXME.
     */

    path = g_strdup_printf ("=%s/config=/mail/configured", evolution_dir);
    gnome_config_set_bool (path, TRUE);
    g_free (path);

    path = g_strdup_printf ("=%s/config=/mail/id_name", evolution_dir);
    gnome_config_set_string (path, idrec.name);
    g_free (path);

    path = g_strdup_printf ("=%s/config=/mail/id_addr", evolution_dir);
    gnome_config_set_string (path, idrec.address);
    g_free (path);

    path = g_strdup_printf ("=%s/config=/mail/id_org", evolution_dir);
    gnome_config_set_string (path, idrec.organization);
    g_free (path);

    path = g_strdup_printf ("=%s/config=/mail/id_sig", evolution_dir);
    gnome_config_set_string (path, idrec.sigfile);
    g_free (path);

    path = g_strdup_printf ("=%s/config=/mail/source", evolution_dir);
    gnome_config_set_string (path, source);
    g_free (path);

    path = g_strdup_printf ("=%s/config=/mail/transport", evolution_dir);
    gnome_config_set_string (path, transport);
    g_free (path);

    path = g_strdup_printf ("=%s/config=/mail/msg_format", evolution_dir);
    gnome_config_set_string (path, format ? "alternative" : "plain");
    g_free (path);

    gnome_config_sync ();
}

static void
finish (GnomeDruidPage *page, gpointer arg1, gpointer window)
{
    cancel (arg1, window);
    write_config();
}

void
mail_config_druid (void)
{
    GnomeDruid *druid;
    GtkWidget *page, *window;
    GnomeDruidPageStandard *dpage;
    GList *providers, *p, *sources, *transports;
    GdkImlibImage *mail_logo, *identity_logo;
    GdkImlibImage *source_logo, *transport_logo;

    /* Fetch list of all providers. */
    providers = camel_session_list_providers (session, TRUE);
    sources = transports = NULL;
    for (p = providers; p; p = p->next) {
        CamelProvider *prov = p->data;

        if (strcmp (prov->domain, "mail") != 0)
            continue;

        if (prov->object_types[CAMEL_PROVIDER_STORE]) {
            sources = add_service (sources,
                           CAMEL_PROVIDER_STORE,
                           prov);
        } else if (prov->object_types[CAMEL_PROVIDER_TRANSPORT]) {
            transports = add_service (transports,
                          CAMEL_PROVIDER_TRANSPORT,
                          prov);
        }
    }

    mail_logo = load_image ("evolution-inbox.png");
    identity_logo = load_image ("malehead.png");
    source_logo = mail_logo;
    transport_logo = load_image ("envelope.png");

    window = gtk_window_new (GTK_WINDOW_DIALOG);
    druid = GNOME_DRUID (gnome_druid_new ());
    gtk_signal_connect (GTK_OBJECT (druid), "cancel",
                GTK_SIGNAL_FUNC (cancel), window);

    /* Start page */
    page = gnome_druid_page_start_new_with_vals (
        _("Mail Configuration"),
        "Welcome to the Evolution Mail configuration wizard!\n"
        "By filling in some information about your email\n"
        "settings,you can start sending and receiving email\n"
        "right away. Click \"Next\" to continue.",
        mail_logo, NULL);

    gnome_druid_page_start_set_logo_bg_color (
        GNOME_DRUID_PAGE_START (page),
        &GNOME_DRUID_PAGE_START (page)->background_color);
    gnome_druid_append_page (druid, GNOME_DRUID_PAGE (page));
    gtk_signal_connect (GTK_OBJECT (page), "prepare",
                GTK_SIGNAL_FUNC (prepare_first), NULL);
    gtk_widget_show_all (page);


    /* Identity page */
    page = gnome_druid_page_standard_new_with_vals (_("Identity"),
                            identity_logo);
    dpage = GNOME_DRUID_PAGE_STANDARD (page);
    gnome_druid_page_standard_set_logo_bg_color (dpage,
                             &dpage->background_color);
    gtk_container_set_border_width (GTK_CONTAINER (dpage->vbox), 8);
    gtk_box_set_spacing (GTK_BOX (dpage->vbox), 5);
    create_identity_page (dpage->vbox, &idrec);
    gtk_object_set_data (GTK_OBJECT (dpage->vbox), "exit_button",
                 druid->next);
    gnome_druid_append_page (druid, GNOME_DRUID_PAGE (page));
    gtk_signal_connect (GTK_OBJECT (page), "prepare",
                GTK_SIGNAL_FUNC (prepare_identity), dpage->vbox);
    gtk_signal_connect (GTK_OBJECT (page), "next",
                GTK_SIGNAL_FUNC (identity_next), dpage->vbox);
    gtk_widget_show (page);


    /* Source page */
    page = gnome_druid_page_standard_new_with_vals (_("Mail Source"),
                            source_logo);
    dpage = GNOME_DRUID_PAGE_STANDARD (page);
    gnome_druid_page_standard_set_logo_bg_color (dpage,
                             &dpage->background_color);
    gtk_container_set_border_width (GTK_CONTAINER (dpage->vbox), 8);
    gtk_box_set_spacing (GTK_BOX (dpage->vbox), 5);
    create_source_page (dpage->vbox, sources, &source);
    gtk_object_set_data (GTK_OBJECT (dpage->vbox), "exit_button",
                 druid->next);
    gnome_druid_append_page (druid, GNOME_DRUID_PAGE (page));
    gtk_signal_connect (GTK_OBJECT (page), "prepare", 
                GTK_SIGNAL_FUNC (prepare_service), dpage->vbox);
    gtk_signal_connect (GTK_OBJECT (page), "next", 
                GTK_SIGNAL_FUNC (service_next),
                gtk_object_get_data (GTK_OBJECT (dpage->vbox),
                         "notebook"));
    gtk_widget_show (page);


    /* Transport page */
    page = gnome_druid_page_standard_new_with_vals (_("Mail Transport"),
                            transport_logo);
    dpage = GNOME_DRUID_PAGE_STANDARD (page);
    gnome_druid_page_standard_set_logo_bg_color (dpage,
                             &dpage->background_color);
    gtk_container_set_border_width (GTK_CONTAINER (dpage->vbox), 8);
    gtk_box_set_spacing (GTK_BOX (dpage->vbox), 5);
    create_transport_page (dpage->vbox, transports, &transport);
    gtk_object_set_data (GTK_OBJECT (dpage->vbox), "exit_button",
                 druid->next);
    gnome_druid_append_page (druid, GNOME_DRUID_PAGE (page));
    gtk_signal_connect (GTK_OBJECT (page), "prepare", 
                GTK_SIGNAL_FUNC (prepare_service), dpage->vbox);
    gtk_signal_connect (GTK_OBJECT (page), "next", 
                GTK_SIGNAL_FUNC (service_next),
                gtk_object_get_data (GTK_OBJECT (dpage->vbox),
                         "notebook"));
    gtk_widget_show (page);


    /* Finish page */
    page = gnome_druid_page_finish_new_with_vals (
        _("Mail Configuration"),
        "Your email configuration is now complete.\n"
        "Click \"finish\" to save your new settings",
        mail_logo, NULL);
    gnome_druid_page_finish_set_logo_bg_color (
        GNOME_DRUID_PAGE_FINISH (page),
        &GNOME_DRUID_PAGE_FINISH (page)->background_color);
    gnome_druid_append_page (druid, GNOME_DRUID_PAGE (page));
    gtk_signal_connect (GTK_OBJECT (page), "finish",
                GTK_SIGNAL_FUNC (finish), window);
    gtk_widget_show_all (page);

    gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (druid));

    gtk_widget_show (GTK_WIDGET (druid));
    gtk_widget_show (window);
    gtk_widget_queue_resize (window);
    gnome_druid_set_buttons_sensitive (druid, FALSE, TRUE, TRUE);

    gtk_window_set_modal (GTK_WINDOW (window), TRUE);
    gtk_main ();
}

static gint identity_row = -1;
static gint source_row = -1;

struct identity_dialog_data {
    GtkWidget *clist;
    struct identity_record *idrec;
    gboolean new_entry;
};

struct source_dialog_data {
    GtkWidget *clist;
    char *source;
    gboolean new_entry;
};


static void
on_cmdIdentityConfigDialogOK_clicked (GtkWidget *dialog, gpointer user_data)
{
    struct identity_dialog_data *data = user_data;
    GtkWidget *vbox = gtk_object_get_data (GTK_OBJECT (dialog), "vbox");

    destroy_identity (GTK_OBJECT (vbox), data->idrec);

    gtk_clist_set_text (GTK_CLIST (data->clist), identity_row, 0, data->idrec->name);
    gtk_clist_set_text (GTK_CLIST (data->clist), identity_row, 1, data->idrec->address);
    gtk_clist_set_text (GTK_CLIST (data->clist), identity_row, 2, data->idrec->organization);
    gtk_clist_set_text (GTK_CLIST (data->clist), identity_row, 3, data->idrec->sigfile);

    gtk_clist_set_row_data (GTK_CLIST (data->clist), identity_row,
                g_memdup (data->idrec, sizeof (struct identity_record)));
}

static void
on_cmdIdentityConfigDialogCancel_clicked (GtkWidget *dialog, gpointer user_data)
{
    struct identity_dialog_data *data = user_data;
    int max_row;
    
    if (data && data->new_entry) {
        gtk_clist_remove (GTK_CLIST (data->clist), identity_row);
                max_row = GTK_CLIST (data->clist)->rows - 1;
        identity_row = identity_row > max_row ? max_row : identity_row;
        gtk_clist_select_row (GTK_CLIST (data->clist), identity_row, 0);
    }
}

static void
on_IdentityConfigDialogButton_clicked (GnomeDialog *dialog, int button, gpointer user_data)
{
    switch (button) {
    case 0: /* OK clicked */
        g_print ("OK clicked\n");
        on_cmdIdentityConfigDialogOK_clicked (GTK_WIDGET (dialog), user_data);
        break;
    case 1: /* Cancel clicked */
        g_print ("Cancel clicked\n");
        on_cmdIdentityConfigDialogCancel_clicked (GTK_WIDGET (dialog), user_data);
        break;
    }

    if (button != -1)
        gnome_dialog_close (dialog);
}

static GtkWidget*
create_identity_config_dialog (gboolean edit_mode, struct identity_record *idrecp, GtkWidget *clist)
{
    GtkWidget *config_dialog;
    GtkWidget *dialog_vbox1;
    GtkWidget *dialog_action_area1;
    GtkWidget *cmdConfigDialogOK;
    GtkWidget *cmdConfigDialogCancel;
    GtkWidget *vbox;
    struct identity_dialog_data *data = NULL;

    if (edit_mode)
        config_dialog = gnome_dialog_new (_("Edit Identity"), NULL);
    else
        config_dialog = gnome_dialog_new (_("Add Identity"), NULL);
    gtk_window_set_modal (GTK_WINDOW (config_dialog), TRUE);
    gtk_widget_set_name (config_dialog, "config_dialog");
    gtk_object_set_data (GTK_OBJECT (config_dialog), "config_dialog", config_dialog);
    gtk_window_set_policy (GTK_WINDOW (config_dialog), TRUE, TRUE, FALSE);
    
    dialog_vbox1 = GNOME_DIALOG (config_dialog)->vbox;
    gtk_widget_set_name (dialog_vbox1, "dialog_vbox1");
    gtk_object_set_data (GTK_OBJECT (config_dialog), "dialog_vbox1", dialog_vbox1);
    gtk_widget_show (dialog_vbox1);
    
    dialog_action_area1 = GNOME_DIALOG (config_dialog)->action_area;
    gtk_widget_set_name (dialog_action_area1, "dialog_action_area1");
    gtk_object_set_data (GTK_OBJECT (config_dialog), "dialog_action_area1", dialog_action_area1);
    gtk_widget_show (dialog_action_area1);
    gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
    gtk_button_box_set_spacing (GTK_BUTTON_BOX (dialog_action_area1), 8);

    /* Create the vbox that we will pack the identity widget into */
    vbox = gtk_vbox_new (FALSE, 0);
    gtk_widget_set_name (vbox, "vbox");
    gtk_object_set_data (GTK_OBJECT (config_dialog), "vbox", vbox);
    gtk_widget_ref (vbox);
    gtk_object_set_data_full (GTK_OBJECT (config_dialog), "vbox", vbox,
                  (GtkDestroyNotify) gtk_widget_unref);
    gtk_widget_show (vbox);
    gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox, TRUE, TRUE, 0);
    
    gnome_dialog_append_button (GNOME_DIALOG (config_dialog), GNOME_STOCK_BUTTON_OK);
    cmdConfigDialogOK = g_list_last (GNOME_DIALOG (config_dialog)->buttons)->data;
    gtk_widget_set_name (cmdConfigDialogOK, "cmdConfigDialogOK");
    gtk_object_set_data (GTK_OBJECT (vbox), "ok_button", cmdConfigDialogOK);
    gtk_widget_ref (cmdConfigDialogOK);
    gtk_object_set_data_full (GTK_OBJECT (config_dialog), "cmdConfigDialogOK", cmdConfigDialogOK,
                  (GtkDestroyNotify) gtk_widget_unref);
    gtk_widget_show (cmdConfigDialogOK);
    GTK_WIDGET_SET_FLAGS (cmdConfigDialogOK, GTK_CAN_DEFAULT);
    gtk_widget_set_sensitive (cmdConfigDialogOK, FALSE);
    
    gnome_dialog_append_button (GNOME_DIALOG (config_dialog), GNOME_STOCK_BUTTON_CANCEL);
    cmdConfigDialogCancel = g_list_last (GNOME_DIALOG (config_dialog)->buttons)->data;
    gtk_widget_set_name (cmdConfigDialogCancel, "cmdConfigDialogCancel");
    gtk_widget_ref (cmdConfigDialogCancel);
    gtk_object_set_data_full (GTK_OBJECT (config_dialog), "cmdConfigDialogCancel", cmdConfigDialogCancel,
                  (GtkDestroyNotify) gtk_widget_unref);
    gtk_widget_show (cmdConfigDialogCancel);
    GTK_WIDGET_SET_FLAGS (cmdConfigDialogCancel, GTK_CAN_DEFAULT);
    
        /* create/pack our Identity widget */
    create_identity_page (vbox, &idrec);
    
    /*gtk_signal_disconnect_by_func (GTK_OBJECT (vbox), GTK_SIGNAL_FUNC (destroy_identity), NULL);*/

    data = g_malloc0 (sizeof (struct identity_dialog_data));
    data->clist  = clist;
    data->idrec  = idrecp;
    data->new_entry = !edit_mode;

    gtk_signal_connect(GTK_OBJECT (config_dialog), "clicked",
               GTK_SIGNAL_FUNC (on_IdentityConfigDialogButton_clicked),
               data);
    /*
    gtk_signal_connect (GTK_OBJECT (cmdConfigDialogOK), "clicked",
                GTK_SIGNAL_FUNC (on_cmdIdentityConfigDialogOK_clicked),
                data);
    
    gtk_signal_connect (GTK_OBJECT (cmdConfigDialogCancel), "clicked",
                GTK_SIGNAL_FUNC (on_cmdIdentityConfigDialogCancel_clicked),
                data);
    */
    
    return config_dialog;
}

static void
on_SourceConfigDialogButton_clicked (GnomeDialog *dialog, int button, gpointer user_data)
{
    struct source_dialog_data *data = user_data;
    GtkWidget *vbox;
    GtkWidget *notebook;
    int max_row;

    switch (button) {
    case 0: /* OK clicked */
        vbox = gtk_object_get_data (GTK_OBJECT (dialog), "vbox");
        notebook = gtk_object_get_data (GTK_OBJECT (vbox), "notebook");
        
        destroy_service (GTK_OBJECT (notebook), &data->source);
        
        gtk_clist_set_text (GTK_CLIST (data->clist), source_row, 0, data->source);
        gtk_clist_set_row_data (GTK_CLIST (data->clist), source_row,
                    g_strdup (data->source));
        source = data->source;
        break;
    case 1: /* Cancel clicked */
        g_print ("Cancel clicked\n");
        if (data && data->new_entry) {
            gtk_clist_remove (GTK_CLIST (data->clist), source_row);
            max_row = GTK_CLIST (data->clist)->rows - 1;
            source_row = source_row > max_row ? max_row : source_row;
            gtk_clist_select_row (GTK_CLIST (data->clist), source_row, 0);
        }
        break;
    }

    if (button != -1) {
        gnome_dialog_close (dialog);
    }
}

static GtkWidget*
create_source_config_dialog (gboolean edit_mode, char **sourcep, GtkWidget *clist)
{
    GtkWidget *config_dialog;
    GtkWidget *dialog_vbox1;
    GtkWidget *dialog_action_area1;
    GtkWidget *cmdConfigDialogOK;
    GtkWidget *cmdConfigDialogCancel;
    GtkWidget *vbox;
    GList *providers, *p, *sources, *transports;
    struct source_dialog_data *data = NULL;

        /* Fetch list of all providers. */
    providers = camel_session_list_providers (session, TRUE);
    sources = transports = NULL;
    for (p = providers; p; p = p->next) {
        CamelProvider *prov = p->data;

        if (strcmp (prov->domain, "mail") != 0)
            continue;

        if (prov->object_types[CAMEL_PROVIDER_STORE]) {
            sources = add_service (sources,
                           CAMEL_PROVIDER_STORE,
                           prov);
        } else if (prov->object_types[CAMEL_PROVIDER_TRANSPORT]) {
            transports = add_service (transports,
                          CAMEL_PROVIDER_TRANSPORT,
                          prov);
        }
    }
    
    if (edit_mode)
        config_dialog = gnome_dialog_new (_("Edit Source"), NULL);
    else
        config_dialog = gnome_dialog_new (_("Add Source"), NULL);
    gtk_window_set_modal (GTK_WINDOW (config_dialog), TRUE);
    gtk_widget_set_name (config_dialog, "config_dialog");
    gtk_object_set_data (GTK_OBJECT (config_dialog), "config_dialog", config_dialog);
    gtk_window_set_policy (GTK_WINDOW (config_dialog), TRUE, TRUE, FALSE);
    gtk_window_set_default_size (GTK_WINDOW (config_dialog), 380, 450);
    
    dialog_vbox1 = GNOME_DIALOG (config_dialog)->vbox;
    gtk_widget_set_name (dialog_vbox1, "dialog_vbox1");
    gtk_object_set_data (GTK_OBJECT (config_dialog), "dialog_vbox1", dialog_vbox1);
    gtk_widget_show (dialog_vbox1);
    
    dialog_action_area1 = GNOME_DIALOG (config_dialog)->action_area;
    gtk_widget_set_name (dialog_action_area1, "dialog_action_area1");
    gtk_object_set_data (GTK_OBJECT (config_dialog), "dialog_action_area1", dialog_action_area1);
    gtk_widget_show (dialog_action_area1);
    gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
    gtk_button_box_set_spacing (GTK_BUTTON_BOX (dialog_action_area1), 8);

    /* Create the vbox that we will pack the source widget into */
    vbox = gtk_vbox_new (FALSE, 0);
    gtk_widget_set_name (vbox, "vbox");
    gtk_object_set_data (GTK_OBJECT (config_dialog), "vbox", vbox);
    gtk_widget_ref (vbox);
    gtk_object_set_data_full (GTK_OBJECT (config_dialog), "vbox", vbox,
                  (GtkDestroyNotify) gtk_widget_unref);
    gtk_widget_show (vbox);
    gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox, TRUE, TRUE, 0);
    
    gnome_dialog_append_button (GNOME_DIALOG (config_dialog), GNOME_STOCK_BUTTON_OK);
    cmdConfigDialogOK = g_list_last (GNOME_DIALOG (config_dialog)->buttons)->data;
    gtk_widget_set_name (cmdConfigDialogOK, "cmdConfigDialogOK");
    gtk_object_set_data (GTK_OBJECT (vbox), "ok_button", cmdConfigDialogOK);
    gtk_widget_ref (cmdConfigDialogOK);
    gtk_object_set_data_full (GTK_OBJECT (config_dialog), "cmdConfigDialogOK", cmdConfigDialogOK,
                  (GtkDestroyNotify) gtk_widget_unref);
    gtk_widget_show (cmdConfigDialogOK);
    GTK_WIDGET_SET_FLAGS (cmdConfigDialogOK, GTK_CAN_DEFAULT);
    gtk_widget_set_sensitive (cmdConfigDialogOK, FALSE);
    
    gnome_dialog_append_button (GNOME_DIALOG (config_dialog), GNOME_STOCK_BUTTON_CANCEL);
    cmdConfigDialogCancel = g_list_last (GNOME_DIALOG (config_dialog)->buttons)->data;
    gtk_widget_set_name (cmdConfigDialogCancel, "cmdConfigDialogCancel");
    gtk_widget_ref (cmdConfigDialogCancel);
    gtk_object_set_data_full (GTK_OBJECT (config_dialog), "cmdConfigDialogCancel", cmdConfigDialogCancel,
                  (GtkDestroyNotify) gtk_widget_unref);
    gtk_widget_show (cmdConfigDialogCancel);
    GTK_WIDGET_SET_FLAGS (cmdConfigDialogCancel, GTK_CAN_DEFAULT);
    
        /* create/pack our source widget */
    create_source_page (vbox, sources, sourcep);
    
    data = g_malloc0 (sizeof (struct source_dialog_data));
    data->clist = clist;
    data->source = *sourcep;
    data->new_entry = !edit_mode;

    gtk_signal_connect(GTK_OBJECT (config_dialog), "clicked",
               GTK_SIGNAL_FUNC (on_SourceConfigDialogButton_clicked),
               data);
    
    return config_dialog;
}

static void
on_clistIdentities_select_row (GtkWidget *widget, gint row, gint column,
                   GdkEventButton *event, gpointer data)
{
    identity_row = row;
}

static void
on_clistSources_select_row (GtkWidget *widget, gint row, gint column,
                   GdkEventButton *event, gpointer data)
{
    source_row = row;
}

static void
on_cmdIdentityAdd_clicked (GtkWidget *widget, gpointer user_data)
{
    GtkWidget *dialog;
    char *text[] = { "", "", "", "" };

    gtk_clist_append (GTK_CLIST (user_data), text);

    if (identity_row > -1)
        gtk_clist_unselect_row (GTK_CLIST (user_data), identity_row, 0);

    gtk_clist_select_row (GTK_CLIST (user_data), GTK_CLIST (user_data)->rows - 1, 0);

    /* now create the editing dialog */
    dialog = create_identity_config_dialog (FALSE, &idrec, GTK_WIDGET (user_data));
    gtk_widget_show (dialog);
}

static void
on_cmdIdentityEdit_clicked (GtkWidget *widget, gpointer user_data)
{
    GtkWidget *dialog;
    struct identity_record *idrecp;
    
    if (identity_row == -1)
        return;

    idrecp = gtk_clist_get_row_data (GTK_CLIST (user_data), identity_row);
    if (!idrecp) {
        idrecp = &idrec;
#if 0
        g_free (idrecp->name);
        idrecp->name = NULL;
        g_free (idrecp->address);
        idrecp->address = NULL;
        g_free (idrecp->organization);
        idrecp->organization = NULL;
        g_free (idrecp->sigfile);
        idrecp->sigfile = NULL;
#endif
    }

    /* now create the editing dialog */
    dialog = create_identity_config_dialog (TRUE, idrecp, GTK_WIDGET (user_data));
    gtk_widget_show (dialog);
}

static void
on_cmdIdentityDelete_clicked (GtkWidget *widget, gpointer user_data)
{
    if (identity_row == -1)
        return;
    
    gtk_clist_remove (GTK_CLIST (user_data), identity_row);
    identity_row = -1;
}

static void
on_cmdSourcesAdd_clicked (GtkWidget *widget, gpointer user_data)
{
    GtkWidget *dialog;
    char *text[] = { "" };

    gtk_clist_append (GTK_CLIST (user_data), text);

    if (source_row > -1)
        gtk_clist_unselect_row (GTK_CLIST (user_data), source_row, 0);

    gtk_clist_select_row (GTK_CLIST (user_data), GTK_CLIST (user_data)->rows - 1, 0);
    
    /* now create the editing dialog */
    dialog = create_source_config_dialog (FALSE, &source, GTK_WIDGET (user_data));
    gtk_widget_show (dialog);
}

static void
on_cmdSourcesEdit_clicked (GtkWidget *widget, gpointer user_data)
{
    GtkWidget *dialog;
    GtkWidget *vbox;
    GtkWidget *interior_notebook;
    GtkWidget *table;
    int page;
    char *sourcep;
    
    if (source_row == -1)
        return;

    sourcep = gtk_clist_get_row_data (GTK_CLIST (user_data), source_row);
    if (sourcep) {
        source = sourcep;
    }

    /* now create the editing dialog */
    dialog = create_source_config_dialog (TRUE, &sourcep, GTK_WIDGET (user_data));

        /* Set the data in the source editor */
    vbox = gtk_object_get_data (GTK_OBJECT (dialog), "vbox");
    interior_notebook = gtk_object_get_data (GTK_OBJECT (vbox), "notebook");
    page = gtk_notebook_get_current_page (GTK_NOTEBOOK (interior_notebook));
    table = gtk_notebook_get_nth_page (GTK_NOTEBOOK (interior_notebook), page);
    set_service_url (GTK_OBJECT (table), source);

    gtk_widget_show (dialog);
}

static void
on_cmdSourcesDelete_clicked (GtkWidget *widget, gpointer user_data)
{
    if (source_row == -1)
        return;
    
    gtk_clist_remove (GTK_CLIST (user_data), source_row);
    source_row = -1;
}

static void
on_cmdCamelServicesOK_clicked (GtkButton *button, gpointer user_data)
{
    GtkWidget *notebook, *interior_notebook;
        GtkWidget *vbox;

    notebook = gtk_object_get_data (GTK_OBJECT (user_data), "notebook");

    /* switch to the third page which is the transport page */
    gtk_notebook_set_page (GTK_NOTEBOOK (notebook), 2);

    vbox = gtk_object_get_data (GTK_OBJECT (notebook), "transport_page_vbox");
    interior_notebook = gtk_object_get_data (GTK_OBJECT (vbox), "notebook");

        if (service_acceptable (GTK_NOTEBOOK (interior_notebook))) {
        destroy_service (GTK_OBJECT (interior_notebook), (gpointer) &transport);
        gtk_widget_destroy (GTK_WIDGET (user_data));
    }

    write_config();
}

static void
on_cmdCamelServicesCancel_clicked (GtkButton *button, gpointer user_data)
{
    gtk_widget_destroy(GTK_WIDGET (user_data));
}

static void
on_chkFormat_toggled (GtkWidget *widget, gpointer user_data)
{
    format = GTK_TOGGLE_BUTTON (widget)->active;
}

GtkWidget*
providers_config_new (void)
{
    GladeXML *gui;
    GtkWidget *providers_config;
    GtkWidget *dialog_vbox1;
    GtkWidget *notebook;
    GtkWidget *clistIdentities;
    GtkWidget *cmdIdentityAdd;
    GtkWidget *cmdIdentityEdit;
    GtkWidget *cmdIdentityDelete;
    GtkWidget *clistSources;
    GtkWidget *cmdSourcesAdd;
    GtkWidget *cmdSourcesEdit;
    GtkWidget *cmdSourcesDelete;
    GtkWidget *cmdCamelServicesOK;
    GtkWidget *cmdCamelServicesCancel;
    GtkWidget *transport_page_vbox;
    GtkWidget *chkFormat;
    GList *providers, *p, *sources, *transports;
    GtkWidget *table, *interior_notebook;
    char *path;
    gboolean configured;
    int page;


    /* Fetch list of all providers. */
    providers = camel_session_list_providers (session, TRUE);
    sources = transports = NULL;
    for (p = providers; p; p = p->next) {
        CamelProvider *prov = p->data;

        if (strcmp (prov->domain, "mail") != 0)
            continue;

        if (prov->object_types[CAMEL_PROVIDER_STORE]) {
            sources = add_service (sources,
                           CAMEL_PROVIDER_STORE,
                           prov);
        } else if (prov->object_types[CAMEL_PROVIDER_TRANSPORT]) {
            transports = add_service (transports,
                          CAMEL_PROVIDER_TRANSPORT,
                          prov);
        }
    }

    gui = glade_xml_new (EVOLUTION_GLADEDIR "/mail-config.glade", NULL);
    providers_config = glade_xml_get_widget (gui, "dialog");

    gtk_widget_set_name (providers_config, "providers_config");
    gtk_object_set_data (GTK_OBJECT (providers_config), 
                 "providers_config", providers_config);

    dialog_vbox1 = glade_xml_get_widget (gui, "dialog_vbox1");
    gtk_object_set_data (GTK_OBJECT (providers_config), 
                 "dialog_vbox1", dialog_vbox1);

    notebook = glade_xml_get_widget (gui, "notebook");
    gtk_widget_ref (notebook);
    gtk_object_set_data_full (GTK_OBJECT (providers_config), 
                  "notebook", notebook,
                  (GtkDestroyNotify) gtk_widget_unref);

    clistIdentities = glade_xml_get_widget (gui, "clistIdentities");
    gtk_widget_ref (clistIdentities);
    gtk_object_set_data_full (GTK_OBJECT (providers_config), 
                  "clistIdentities", clistIdentities,
                  (GtkDestroyNotify) gtk_widget_unref);
    gtk_clist_set_column_width (GTK_CLIST (clistIdentities), 0, 80);

    /* Find out if stuff has been configured */
    path = g_strdup_printf ("=%s/config=/mail/configured", evolution_dir);
    configured = gnome_config_get_bool (path);
    g_free (path);

    identity_row = -1;
    if (configured) {
        char *text[] = { "", "", "", "" };
        struct identity_record *data;

        /* add an entry to the identity clist */
        gtk_clist_append (GTK_CLIST (clistIdentities), text);

        path = g_strdup_printf ("=%s/config=/mail/id_name", evolution_dir);
        idrec.name = gnome_config_get_string (path);
        gtk_clist_set_text (GTK_CLIST (clistIdentities), 0, 0, idrec.name);
        g_free (path);

        path = g_strdup_printf ("=%s/config=/mail/id_addr", evolution_dir);
        idrec.address = gnome_config_get_string (path);
        gtk_clist_set_text (GTK_CLIST (clistIdentities), 0, 1, idrec.address);
        g_free (path);

        path = g_strdup_printf ("=%s/config=/mail/id_org", evolution_dir);
        idrec.organization = gnome_config_get_string (path);
        gtk_clist_set_text (GTK_CLIST (clistIdentities), 0, 2, idrec.organization);
        g_free (path);

        path = g_strdup_printf ("=%s/config=/mail/id_sig", evolution_dir);
        idrec.sigfile = gnome_config_get_string (path);
        gtk_clist_set_text (GTK_CLIST (clistIdentities), 0, 3, idrec.sigfile);
        g_free (path);

        data = g_malloc0 (sizeof (struct identity_record));
        data->name = g_strdup (idrec.name);
        data->address = g_strdup (idrec.address);
        data->organization = g_strdup (idrec.organization);
        data->sigfile = g_strdup (idrec.sigfile);
        gtk_clist_set_row_data (GTK_CLIST (clistIdentities), 0, data);
    }

    cmdIdentityAdd = glade_xml_get_widget (gui, "cmdIdentityAdd");
    cmdIdentityEdit = glade_xml_get_widget (gui, "cmdIdentityEdit");
    cmdIdentityDelete = glade_xml_get_widget (gui, "cmdIdentityDelete");

    clistSources = glade_xml_get_widget (gui, "clistSources");
    gtk_widget_ref (clistSources);
    gtk_object_set_data_full (GTK_OBJECT (providers_config), 
                  "clistSources", clistSources,
                  (GtkDestroyNotify) gtk_widget_unref);
    gtk_clist_set_column_width (GTK_CLIST (clistSources), 0, 80);

    if (configured && !source) {
        path = g_strdup_printf ("=%s/config=/mail/source", evolution_dir);
        source = gnome_config_get_string (path);
        g_free (path);
    }

    source_row = -1;
    if (source) {
        char *text[] = { "" };

        gtk_clist_append (GTK_CLIST (clistSources), text);

        gtk_clist_set_text (GTK_CLIST (clistSources), 0, 0, source);
        gtk_clist_set_row_data (GTK_CLIST (clistSources), 0, g_strdup(source));
    }

    cmdSourcesAdd = glade_xml_get_widget (gui, "cmdSourcesAdd");
    cmdSourcesEdit = glade_xml_get_widget (gui, "cmdSourcesEdit");
    cmdSourcesDelete = glade_xml_get_widget (gui, "cmdSourcesDelete");

    /* Setup the transport page */
    transport_page_vbox = glade_xml_get_widget (gui, "transport_page_vbox");
    gtk_object_set_data (GTK_OBJECT (notebook), "transport_page_vbox", transport_page_vbox);
    gtk_widget_ref (transport_page_vbox);
    gtk_object_set_data_full (GTK_OBJECT (providers_config), "transport_page_vbox", transport_page_vbox,
                  (GtkDestroyNotify) gtk_widget_unref);

    if (configured && !transport) {
        path = g_strdup_printf ("=%s/config=/mail/transport", evolution_dir);
        transport = gnome_config_get_string (path);
        g_free (path);
    }
    create_transport_page (transport_page_vbox, transports, &transport);

    /* Set the data in the transports page */
    interior_notebook = gtk_object_get_data (GTK_OBJECT (transport_page_vbox), "notebook");
    page = gtk_notebook_get_current_page (GTK_NOTEBOOK (interior_notebook));
    if (transport != NULL && !strncasecmp(transport, "Sendmail", 8))
        page = 1;
    else
        page = 0;
    table = gtk_notebook_get_nth_page (GTK_NOTEBOOK (interior_notebook), page);
    set_service_url (GTK_OBJECT (table), transport);
    

    /* Lets make a page to mark Send HTML or text/plan...yay */
    chkFormat = glade_xml_get_widget (gui, "chkFormat");
    gtk_object_set_data (GTK_OBJECT (notebook), "chkFormat", chkFormat);
    gtk_widget_ref (chkFormat);
    gtk_object_set_data_full (GTK_OBJECT (providers_config), "chkFormat", chkFormat,
                  (GtkDestroyNotify) gtk_widget_unref);

    if (configured) {
        char *buf;

        path = g_strdup_printf ("=%s/config=/mail/msg_format", evolution_dir);
        buf = gnome_config_get_string (path);
        g_free (path);

        if (!buf || !strcmp(buf, "alternative"))
            format = TRUE;
        else
            format = FALSE;

        g_free (buf);
    }
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkFormat), format);

    cmdCamelServicesOK = glade_xml_get_widget (gui, "cmdCamelServicesOK");
    cmdCamelServicesCancel = glade_xml_get_widget (gui, "cmdCamelServicesCancel");

    gtk_signal_connect (GTK_OBJECT (cmdIdentityAdd), "clicked",
                GTK_SIGNAL_FUNC (on_cmdIdentityAdd_clicked),
                clistIdentities);
    gtk_signal_connect (GTK_OBJECT (cmdIdentityEdit), "clicked",
                GTK_SIGNAL_FUNC (on_cmdIdentityEdit_clicked),
                clistIdentities);
    gtk_signal_connect (GTK_OBJECT (cmdIdentityDelete), "clicked",
                GTK_SIGNAL_FUNC (on_cmdIdentityDelete_clicked),
                clistIdentities);
    
    gtk_signal_connect (GTK_OBJECT (cmdSourcesAdd), "clicked",
                GTK_SIGNAL_FUNC (on_cmdSourcesAdd_clicked),
                clistSources);
    gtk_signal_connect (GTK_OBJECT (cmdSourcesEdit), "clicked",
                GTK_SIGNAL_FUNC (on_cmdSourcesEdit_clicked),
                clistSources);
    gtk_signal_connect (GTK_OBJECT (cmdSourcesDelete), "clicked",
                GTK_SIGNAL_FUNC (on_cmdSourcesDelete_clicked),
                clistSources);
    
    gtk_signal_connect (GTK_OBJECT (cmdCamelServicesOK), "clicked",
                GTK_SIGNAL_FUNC (on_cmdCamelServicesOK_clicked),
                providers_config);
    gtk_signal_connect (GTK_OBJECT (cmdCamelServicesCancel), "clicked",
                GTK_SIGNAL_FUNC (on_cmdCamelServicesCancel_clicked),
                providers_config);
    
    gtk_signal_connect (GTK_OBJECT (clistIdentities), "select_row",
                GTK_SIGNAL_FUNC (on_clistIdentities_select_row),
                NULL);
    gtk_signal_connect (GTK_OBJECT (clistSources), "select_row",
                GTK_SIGNAL_FUNC (on_clistSources_select_row),
                NULL);

    gtk_signal_connect (GTK_OBJECT (chkFormat), "toggled",
                GTK_SIGNAL_FUNC (on_chkFormat_toggled),
                NULL);

    return providers_config;
}