Sylpheed

/*

 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client

 * Copyright (C) 1999-2009 Hiroyuki Yamamoto

 *

 * 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.

 */

#ifdef HAVE_CONFIG_H

#  include "config.h"

#endif

#include "defs.h"

#include <glib.h>

#include <glib/gi18n.h>

#include <gdk/gdkkeysyms.h>

#include <gtk/gtk.h>

#include <string.h>

#include <setjmp.h>

#include "main.h"

#include "addressbook.h"

#include "manage_window.h"

#include "prefs_common.h"

#include "alertpanel.h"

#include "inputdialog.h"

#include "menu.h"

#include "stock_pixmap.h"

#include "xml.h"

#include "prefs.h"

#include "procmime.h"

#include "utils.h"

#include "gtkutils.h"

#include "codeconv.h"

#include "about.h"

#include "addr_compl.h"

#include "mgutils.h"

#include "addressitem.h"

#include "addritem.h"

#include "addrcache.h"

#include "addrbook.h"

#include "addrindex.h"

#include "addressadd.h"

#include "vcard.h"

#include "editvcard.h"

#include "editgroup.h"

#include "editaddress.h"

#include "editbook.h"

#include "ldif.h"

#include "importldif.h"

#include "importcsv.h"

#ifdef USE_JPILOT

#include "jpilot.h"

#include "editjpilot.h"

#endif

#ifdef USE_LDAP

#include <pthread.h>

#include "syldap.h"

#include "editldap.h"

#define ADDRESSBOOK_LDAP_BUSYMSG "Busy"

#endif

typedef enum

{

        COL_FOLDER_NAME,

        COL_OBJ,

        COL_PIXBUF,

        COL_PIXBUF_OPEN,

        N_TREE_COLS

} AddressBookTreeColumnPos;

typedef enum

{

        COL_NAME,

        COL_ADDRESS,

        COL_REMARKS,

        COL_L_OBJ,

        COL_L_PIXBUF,

        N_LIST_COLS

} AddressBookListColumnPos;

#define COL_NAME_WIDTH                164

#define COL_ADDRESS_WIDTH        156

#define COL_FOLDER_WIDTH        170

#define ADDRESSBOOK_MSGBUF_SIZE 2048

static GdkPixbuf *folderpix;

static GdkPixbuf *folderopenpix;

static GdkPixbuf *grouppix;

static GdkPixbuf *interfacepix;

static GdkPixbuf *bookpix;

static GdkPixbuf *addresspix;

static GdkPixbuf *vcardpix;

static GdkPixbuf *jpilotpix;

static GdkPixbuf *categorypix;

static GdkPixbuf *ldappix;

static GdkPixmap *folderxpm;

static GdkBitmap *folderxpmmask;

static GdkPixmap *folderopenxpm;

static GdkBitmap *folderopenxpmmask;

static GdkPixmap *groupxpm;

static GdkBitmap *groupxpmmask;

static GdkPixmap *interfacexpm;

static GdkBitmap *interfacexpmmask;

static GdkPixmap *bookxpm;

static GdkBitmap *bookxpmmask;

static GdkPixmap *addressxpm;

static GdkBitmap *addressxpmmask;

static GdkPixmap *vcardxpm;

static GdkBitmap *vcardxpmmask;

static GdkPixmap *jpilotxpm;

static GdkBitmap *jpilotxpmmask;

static GdkPixmap *categoryxpm;

static GdkBitmap *categoryxpmmask;

static GdkPixmap *ldapxpm;

static GdkBitmap *ldapxpmmask;

/* Message buffer */

static gchar addressbook_msgbuf[ADDRESSBOOK_MSGBUF_SIZE];

/* Address list selection */

static GList *_addressListSelection_ = NULL;

/* Address index file and interfaces */

static AddressIndex *_addressIndex_ = NULL;

static GList *_addressInterfaceList_ = NULL;

static GList *_addressIFaceSelection_ = NULL;

#define ADDRESSBOOK_IFACE_SELECTION "1/y,3/y,4/y,2/n"

/* Address clipboard */

static GList *_clipObjectList_ = NULL;

static AddressBook_win addrbook;

static GHashTable *_addressBookTypeHash_ = NULL;

static GList *_addressBookTypeList_ = NULL;

static void addressbook_refresh                        (void);

static void addressbook_reopen                        (void);

static void addressbook_create                        (void);

static gint addressbook_close                        (void);

static void addressbook_menuitem_set_sensitive        (void);

/* callback functions */

static void addressbook_del_clicked                (GtkButton        *button,

                                                 gpointer         data);

static void addressbook_reg_clicked                (GtkButton        *button,

                                                 gpointer         data);

static void addressbook_to_clicked                (GtkButton        *button,

                                                 gpointer         data);

static void addressbook_lup_clicked                (GtkButton        *button,

                                                 gpointer        data);

static void addressbook_close_clicked                (GtkButton        *button,

                                                 gpointer        data);

static void addressbook_tree_selection_changed        (GtkTreeSelection *selection,

                                                 gpointer         data);

static void addressbook_list_selection_changed        (GtkTreeSelection *selection,

                                                 gpointer         data);

static void addressbook_person_expand_node        (GtkTreeView        *treeview,

                                                 GtkTreeIter        *iter,

                                                 GtkTreePath        *path,

                                                 gpointer        *data);

static void addressbook_person_collapse_node        (GtkTreeView        *treeview,

                                                 GtkTreeIter        *iter,

                                                 GtkTreePath        *path,

                                                 gpointer        *data);

#if 0

static void addressbook_entry_changed                (GtkWidget        *widget);

#endif

static void addressbook_entry_activated                (GtkWidget        *widget,

                                                 gpointer         data);

static gboolean addressbook_list_button_pressed        (GtkWidget        *widget,

                                                 GdkEventButton        *event,

                                                 gpointer         data);

static gboolean addressbook_list_button_released(GtkWidget        *widget,

                                                 GdkEventButton        *event,

                                                 gpointer         data);

static gboolean addressbook_tree_button_pressed        (GtkWidget        *ctree,

                                                 GdkEventButton        *event,

                                                 gpointer         data);

static gboolean addressbook_tree_button_released(GtkWidget        *ctree,

                                                 GdkEventButton        *event,

                                                 gpointer         data);

static void addressbook_popup_close                (GtkMenuShell        *menu_shell,

                                                 gpointer         data);

static void addressbook_new_folder_cb                (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_new_group_cb                (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_treenode_edit_cb        (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_treenode_delete_cb        (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_change_node_name        (GtkTreeIter        *iter,

                                                 const gchar        *name);

static void addressbook_new_address_cb                (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_edit_address_cb                (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_delete_address_cb        (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_copy_address_cb                (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_paste_address_cb        (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void close_cb                                (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_file_save_cb                (gpointer         data,

                                                 guint                 action,

                                                 GtkWidget        *widget);

/* Data source edit stuff */

static void addressbook_new_book_cb                (gpointer         data,

                                                        guint                 action,

                                                 GtkWidget        *widget);

static void addressbook_new_vcard_cb                (gpointer         data,

                                                        guint                 action,

                                                 GtkWidget        *widget);

#ifdef USE_JPILOT

static void addressbook_new_jpilot_cb                (gpointer         data,

                                                        guint                 action,

                                                 GtkWidget        *widget);

#endif

#ifdef USE_LDAP

static void addressbook_new_ldap_cb                (gpointer         data,

                                                        guint                 action,

                                                 GtkWidget        *widget);

#endif

static void addressbook_set_list                (AddressObject        *obj);

static void addressbook_load_tree                (void);

void addressbook_read_file                        (void);

static gboolean addressbook_add_object                (GtkTreeIter        *iter,

                                                 GtkTreeIter        *new_iter,

                                                 AddressObject        *obj);

static AddressDataSource *addressbook_find_datasource

                                                (GtkTreeIter        *iter);

static AddressBookFile *addressbook_get_book_file();

static gboolean addressbook_node_add_folder        (GtkTreeIter        *iter,

                                                 AddressDataSource *ds,

                                                 ItemFolder        *itemFolder,

                                                 AddressObjectType otype,

                                                 GtkTreeIter        *new_iter);

static gboolean addressbook_node_add_group        (GtkTreeIter        *iter,

                                                 AddressDataSource *ds,

                                                 ItemGroup        *itemGroup,

                                                 GtkTreeIter        *new_iter);

static void addressbook_tree_remove_children        (GtkTreeModel        *model,

                                                 GtkTreeIter        *parent);

static void addressbook_move_nodes_up                (GtkTreeIter        *iter);

static gboolean addressbook_find_group_node        (GtkTreeIter        *parent,

                                                 GtkTreeIter        *iter,

                                                 ItemGroup        *group);

/* static void addressbook_delete_object        (AddressObject        *obj); */

static gboolean key_pressed                        (GtkWidget        *widget,

                                                 GdkEventKey        *event,

                                                 gpointer         data);

static void size_allocated                        (GtkWidget        *widget,

                                                 GtkAllocation        *allocation,

                                                 gpointer         data);

static gint addressbook_tree_compare                (GtkTreeModel        *model,

                                                 GtkTreeIter        *a,

                                                 GtkTreeIter        *b,

                                                 gpointer         data);

static gint addressbook_list_name_compare        (GtkTreeModel        *model,

                                                 GtkTreeIter        *a,

                                                 GtkTreeIter        *b,

                                                 gpointer         data);

static gint addressbook_list_address_compare        (GtkTreeModel        *model,

                                                 GtkTreeIter        *a,

                                                 GtkTreeIter        *b,

                                                 gpointer         data);

static gint addressbook_list_remarks_compare        (GtkTreeModel        *model,

                                                 GtkTreeIter        *a,

                                                 GtkTreeIter        *b,

                                                 gpointer         data);

/* static void addressbook_book_show_message        (AddressBookFile *book); */

/* static void addressbook_vcard_show_message        (VCardFile *vcf); */

#ifdef USE_JPILOT

/* static void addressbook_jpilot_show_message        (JPilotFile *jpf); */

#endif

#ifdef USE_LDAP

static void addressbook_ldap_show_message        (SyldapServer *server);

#endif

/* LUT's and IF stuff */

static void addressbook_free_adapter                (GtkTreeIter        *iter);

static void addressbook_free_child_adapters        (GtkTreeIter        *iter);

AddressTypeControlItem *addrbookctl_lookup        (gint                 ot);

AddressTypeControlItem *addrbookctl_lookup_iface(AddressIfType         ifType);

void addrbookctl_build_map                        (GtkWidget        *window);

void addrbookctl_build_iflist                        (void);

AdapterInterface *addrbookctl_find_interface        (AddressIfType         ifType);

void addrbookctl_build_ifselect                        (void);

static void addrbookctl_free_interface                (AdapterInterface *adapter);

static void addrbookctl_free_datasource                (AdapterDSource          *adapter);

static void addrbookctl_free_folder                (AdapterFolder          *adapter);

static void addrbookctl_free_group                (AdapterGroup          *adapter);

static void addressbook_list_select_clear        (void);

static void addressbook_list_select_remove        (AddressObject        *obj);

static void addressbook_list_select_set                (GList                *row_list);

static void addressbook_import_ldif_cb                (void);

static void addressbook_import_csv_cb                (void);

static GtkItemFactoryEntry addressbook_entries[] =

{

        {N_("/_File"),                        NULL,        NULL, 0, "<Branch>"},

        {N_("/_File/New _Book"),        NULL,        addressbook_new_book_cb,        0, NULL},

        {N_("/_File/New _vCard"),        NULL,        addressbook_new_vcard_cb,       0, NULL},

#ifdef USE_JPILOT

        {N_("/_File/New _JPilot"),        NULL,        addressbook_new_jpilot_cb,      0, NULL},

#endif

#ifdef USE_LDAP

        {N_("/_File/New _LDAP Server"),        NULL,        addressbook_new_ldap_cb,        0, NULL},

#endif

        {N_("/_File/---"),                NULL,                NULL, 0, "<Separator>"},

        {N_("/_File/_Edit"),                NULL,                addressbook_treenode_edit_cb,   0, NULL},

        {N_("/_File/_Delete"),                NULL,                addressbook_treenode_delete_cb, 0, NULL},

        {N_("/_File/---"),                NULL,                NULL, 0, "<Separator>"},

        {N_("/_File/_Save"),                "<control>S",        addressbook_file_save_cb,       0, NULL},

        {N_("/_File/_Close"),                "<control>W",        close_cb, 0, NULL},

        {N_("/_Edit"),                        NULL,                NULL, 0, "<Branch>"},

        {N_("/_Edit/_Copy"),                "<control>C",        addressbook_copy_address_cb,    0, NULL},

        {N_("/_Edit/_Paste"),                "<control>V",        addressbook_paste_address_cb,    0, NULL},

        {N_("/_Address"),                NULL,                NULL, 0, "<Branch>"},

        {N_("/_Address/New _Address"),        "<control>N",        addressbook_new_address_cb,     0, NULL},

        {N_("/_Address/New _Group"),        "<control>G",        addressbook_new_group_cb,       0, NULL},

        {N_("/_Address/New _Folder"),        "<control>F",        addressbook_new_folder_cb,      0, NULL},

        {N_("/_Address/---"),                NULL,                NULL, 0, "<Separator>"},

        {N_("/_Address/_Edit"),                "<control>Return",        addressbook_edit_address_cb,    0, NULL},

        {N_("/_Address/_Delete"),        "Delete",        addressbook_delete_address_cb,  0, NULL},

        {N_("/_Tools"),                        NULL,                NULL, 0, "<Branch>"},

        {N_("/_Tools/Import _LDIF file"), NULL,                addressbook_import_ldif_cb,        0, NULL},

        {N_("/_Tools/Import _CSV file"), NULL,                addressbook_import_csv_cb,        0, NULL},

        {N_("/_Help"),                        NULL,                NULL, 0, "<Branch>"},

        {N_("/_Help/_About"),                NULL,                about_show, 0, NULL}

};

/* New options to be added. */

/*

        {N_("/_Edit"),                        NULL,                NULL, 0, "<Branch>"},

        {N_("/_Edit/C_ut"),                "<control>X",        NULL,                                0, NULL},

        {N_("/_Edit/_Copy"),                "<control>C",        NULL,                           0, NULL},

        {N_("/_Edit/_Paste"),                "<control>V",        NULL,                           0, NULL},

        {N_("/_Tools"),                        NULL,                NULL, 0, "<Branch>"},

        {N_("/_Tools/Import _Mozilla"),        NULL,           NULL,                                0, NULL},

        {N_("/_Tools/Import _vCard"),        NULL,           NULL,                                0, NULL},

        {N_("/_Tools/---"),                NULL,                NULL, 0, "<Separator>"},

        {N_("/_Tools/Export _LDIF file"), NULL,                NULL,                                0, NULL},

        {N_("/_Tools/Export v_Card"),        NULL,           NULL,                                0, NULL},

*/

static GtkItemFactoryEntry addressbook_tree_popup_entries[] =

{

        {N_("/New _Address"),        NULL, addressbook_new_address_cb, 0, NULL},

        {N_("/New _Group"),        NULL, addressbook_new_group_cb,   0, NULL},

        {N_("/New _Folder"),        NULL, addressbook_new_folder_cb,  0, NULL},

        {N_("/---"),                NULL, NULL, 0, "<Separator>"},

        {N_("/_Edit"),                NULL, addressbook_treenode_edit_cb,   0, NULL},

        {N_("/_Delete"),        NULL, addressbook_treenode_delete_cb, 0, NULL}

};

static GtkItemFactoryEntry addressbook_list_popup_entries[] =

{

        {N_("/New _Address"),        NULL, addressbook_new_address_cb,  0, NULL},

        {N_("/New _Group"),        NULL, addressbook_new_group_cb,    0, NULL},

        {N_("/New _Folder"),        NULL, addressbook_new_folder_cb,   0, NULL},

        {N_("/---"),                NULL, NULL, 0, "<Separator>"},

        {N_("/_Edit"),                NULL, addressbook_edit_address_cb,   0, NULL},

        {N_("/_Delete"),        NULL, addressbook_delete_address_cb, 0, NULL},

        {N_("/---"),                NULL, NULL, 0, "<Separator>"},

        {N_("/_Copy"),                NULL, addressbook_copy_address_cb,  0, NULL},

        {N_("/_Paste"),                NULL, addressbook_paste_address_cb, 0, NULL}

};

void addressbook_open(Compose *target)

{

        if (!addrbook.window) {

                GtkTreeView *treeview;

                GtkTreeModel *model;

                GtkTreeIter iter;

                GtkTreePath *path;

                addressbook_read_file();

                addressbook_create();

                addressbook_load_tree();

                treeview = GTK_TREE_VIEW(addrbook.treeview);

                model = gtk_tree_view_get_model(treeview);

                if (gtk_tree_model_get_iter_first(model, &iter)) {

                        path = gtk_tree_model_get_path(model, &iter);

                        gtk_tree_view_set_cursor(treeview, path, NULL, FALSE);

                        gtk_tree_path_free(path);

                }

                addressbook_menuitem_set_sensitive();

                gtk_widget_show_all(addrbook.window);

        } 

        gtk_window_present(GTK_WINDOW(addrbook.window));

        addressbook_set_target_compose(target);

}

void addressbook_set_target_compose(Compose *target)

{

        addrbook.target_compose = target;

}

Compose *addressbook_get_target_compose(void)

{

        return addrbook.target_compose;

}

static void addressbook_refresh(void)

{

        if (addrbook.window) {

                if (addrbook.tree_opened) {

                        addressbook_reopen();

                }

        }

        addressbook_export_to_file();

}

static void addressbook_reopen(void)

{

        GtkTreePath *path;

        if (addrbook.tree_selected) {

                gtk_tree_row_reference_free(addrbook.tree_selected);

                addrbook.tree_selected = NULL;

        }

        if (addrbook.tree_opened) {

                path = gtk_tree_row_reference_get_path(addrbook.tree_opened);

                gtk_tree_view_set_cursor(GTK_TREE_VIEW(addrbook.treeview), path, NULL, FALSE);

                gtk_tree_path_free(path);

        }

}

/*

* Create the address book widgets. The address book contains two CTree widgets: the

* address index tree on the left and the address list on the right.

*

* The address index tree displays a hierarchy of interfaces and groups. Each node in

* this tree is linked to an address Adapter. Adapters have been created for interfaces,

* data sources and folder objects.

*

* The address list displays group, person and email objects. These items are linked

* directly to ItemGroup, ItemPerson and ItemEMail objects inside the address book data

* sources.

*

* In the tradition of MVC architecture, the data stores have been separated from the

* GUI components. The addrindex.c file provides the interface to all data stores.

*/

static void addressbook_create(void)

{

        GtkWidget *window;

        GtkWidget *vbox;

        GtkWidget *menubar;

        GtkWidget *spc_hbox;

        GtkWidget *vbox2;

        GtkWidget *tree_swin;

        GtkWidget *treeview;

        GtkTreeStore *tree_store;

        GtkTreeSelection *selection;

        GtkTreeViewColumn *column;

        GtkCellRenderer *renderer;

        GtkWidget *list_vbox;

        GtkWidget *list_swin;

        GtkWidget *listview;

        GtkTreeStore *list_store;

        GtkWidget *paned;

        GtkWidget *hbox;

        GtkWidget *entry;

        GtkWidget *statusbar;

        GtkWidget *hbbox;

        GtkWidget *hbbox1;

        GtkWidget *hbbox2;

        GtkWidget *hsbox;

        GtkWidget *to_btn;

        GtkWidget *cc_btn;

        GtkWidget *bcc_btn;

        GtkWidget *del_btn;

        GtkWidget *reg_btn;

        GtkWidget *lup_btn;

        GtkWidget *close_btn;

        GtkWidget *tree_popup;

        GtkWidget *list_popup;

        GtkItemFactory *tree_factory;

        GtkItemFactory *list_factory;

        GtkItemFactory *menu_factory;

        gint n_entries;

        GList *nodeIf;

        debug_print("Creating addressbook window...\n");

        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

        gtk_window_set_title(GTK_WINDOW(window), _("Address book"));

        gtk_window_set_wmclass(GTK_WINDOW(window), "addressbook", "Sylpheed");

        gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, TRUE);

        gtk_widget_set_size_request(window, 620, 360);

        gtk_window_set_default_size(GTK_WINDOW(window),

                                    prefs_common.addressbook_width,

                                    prefs_common.addressbook_height);

        gtk_window_move(GTK_WINDOW(window), prefs_common.addressbook_x,

                        prefs_common.addressbook_y);

        gtk_widget_realize(window);

        g_signal_connect(G_OBJECT(window), "delete_event",

                         G_CALLBACK(addressbook_close), NULL);

        g_signal_connect(G_OBJECT(window), "key_press_event",

                         G_CALLBACK(key_pressed), NULL);

        g_signal_connect(G_OBJECT(window), "size_allocate",

                         G_CALLBACK(size_allocated), NULL);

        MANAGE_WINDOW_SIGNALS_CONNECT(window);

        vbox = gtk_vbox_new(FALSE, 0);

        gtk_container_add(GTK_CONTAINER(window), vbox);

        n_entries = sizeof(addressbook_entries) /

                sizeof(addressbook_entries[0]);

        menubar = menubar_create(window, addressbook_entries, n_entries,

                                 "<AddressBook>", NULL);

        gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);

        menu_factory = gtk_item_factory_from_widget(menubar);

        spc_hbox = gtk_hbox_new(FALSE, 0);

        gtk_widget_set_size_request(spc_hbox, -1, BORDER_WIDTH);

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

        vbox2 = gtk_vbox_new(FALSE, 4);

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

        tree_swin = gtk_scrolled_window_new(NULL, NULL);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tree_swin),

                                       GTK_POLICY_AUTOMATIC,

                                       GTK_POLICY_AUTOMATIC);

        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(tree_swin),

                                            GTK_SHADOW_IN);

        gtk_widget_set_size_request(tree_swin, COL_FOLDER_WIDTH + 40, -1);

        /* Address index */

        tree_store = gtk_tree_store_new(N_TREE_COLS, G_TYPE_STRING,

                                        G_TYPE_POINTER, GDK_TYPE_PIXBUF,

                                        GDK_TYPE_PIXBUF);

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(tree_store),

                                        COL_FOLDER_NAME,

                                        addressbook_tree_compare,

                                        NULL, NULL);

        treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_store));

        g_object_unref(G_OBJECT(tree_store));

        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));

        gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);

        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);

        gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), FALSE);

        gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview),

                                        COL_FOLDER_NAME);

        gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview), FALSE);

        gtk_container_add(GTK_CONTAINER(tree_swin), treeview);

        column = gtk_tree_view_column_new();

        gtk_tree_view_column_set_spacing(column, 2);

        gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);

        gtk_tree_view_column_set_fixed_width(column, COL_FOLDER_WIDTH);

        gtk_tree_view_column_set_resizable(column, TRUE);

        renderer = gtk_cell_renderer_pixbuf_new();

        g_object_set(renderer, "ypad", 0, NULL);

        gtk_tree_view_column_pack_start(column, renderer, FALSE);

        gtk_tree_view_column_set_title(column, _("Folder"));

        gtk_tree_view_column_set_attributes

                (column, renderer, "pixbuf", COL_PIXBUF,

                 "pixbuf-expander-open", COL_PIXBUF_OPEN,

                 "pixbuf-expander-closed", COL_PIXBUF, NULL);

        renderer = gtk_cell_renderer_text_new();

        g_object_set(renderer,

#if GTK_CHECK_VERSION(2, 6, 0)

                     "ellipsize", PANGO_ELLIPSIZE_END,

#endif

                     "ypad", 0, NULL);

        gtk_tree_view_column_pack_start(column, renderer, TRUE);

        gtk_tree_view_column_set_attributes(column, renderer,

                                            "text", COL_FOLDER_NAME, NULL);

        gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);

        gtk_tree_view_set_expander_column(GTK_TREE_VIEW(treeview), column);

        gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(tree_store),

                                             COL_FOLDER_NAME,

                                             GTK_SORT_ASCENDING);

        g_signal_connect(G_OBJECT(selection), "changed",

                         G_CALLBACK(addressbook_tree_selection_changed), NULL);

        g_signal_connect(G_OBJECT(treeview), "button_press_event",

                         G_CALLBACK(addressbook_tree_button_pressed),

                         NULL);

        g_signal_connect(G_OBJECT(treeview), "button_release_event",

                         G_CALLBACK(addressbook_tree_button_released),

                         NULL);

        list_vbox = gtk_vbox_new(FALSE, 4);

        list_swin = gtk_scrolled_window_new(NULL, NULL);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(list_swin),

                                       GTK_POLICY_AUTOMATIC,

                                       GTK_POLICY_AUTOMATIC);

        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(list_swin),

                                            GTK_SHADOW_IN);

        gtk_box_pack_start(GTK_BOX(list_vbox), list_swin, TRUE, TRUE, 0);

        /* Address list */

        list_store = gtk_tree_store_new(N_LIST_COLS, G_TYPE_STRING,

                                        G_TYPE_STRING, G_TYPE_STRING,

                                        G_TYPE_POINTER, GDK_TYPE_PIXBUF);

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list_store),

                                        COL_NAME,

                                        addressbook_list_name_compare,

                                        NULL, NULL);

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list_store),

                                        COL_ADDRESS,

                                        addressbook_list_address_compare,

                                        NULL, NULL);

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list_store),

                                        COL_REMARKS,

                                        addressbook_list_remarks_compare,

                                        NULL, NULL);

        listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store));

        g_object_unref(G_OBJECT(list_store));

        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listview));

        gtk_tree_selection_set_mode(selection, GTK_SELECTION_EXTENDED);

        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(listview), TRUE);

        gtk_tree_view_set_search_column(GTK_TREE_VIEW(listview), COL_NAME);

        gtk_tree_view_set_reorderable(GTK_TREE_VIEW(listview), FALSE);

        gtk_container_add(GTK_CONTAINER(list_swin), listview);

        column = gtk_tree_view_column_new();

        gtk_tree_view_column_set_spacing(column, 2);

        gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);

        gtk_tree_view_column_set_fixed_width(column, COL_NAME_WIDTH);

        gtk_tree_view_column_set_resizable(column, TRUE);

        gtk_tree_view_column_set_title(column, _("Name"));

        renderer = gtk_cell_renderer_pixbuf_new();

        g_object_set(renderer, "ypad", 0, NULL);

        gtk_tree_view_column_pack_start(column, renderer, FALSE);

        gtk_tree_view_column_set_attributes(column, renderer,

                                            "pixbuf", COL_L_PIXBUF, NULL);

        renderer = gtk_cell_renderer_text_new();

        g_object_set(renderer,

#if GTK_CHECK_VERSION(2, 6, 0)

                     "ellipsize", PANGO_ELLIPSIZE_END,

#endif

                     "ypad", 0, NULL);

        gtk_tree_view_column_pack_start(column, renderer, TRUE);

        gtk_tree_view_column_set_attributes(column, renderer,

                                            "text", COL_NAME, NULL);

        gtk_tree_view_column_set_sort_column_id(column, COL_NAME);

        gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column);

        gtk_tree_view_set_expander_column(GTK_TREE_VIEW(listview), column);

        renderer = gtk_cell_renderer_text_new();

        g_object_set(renderer,

#if GTK_CHECK_VERSION(2, 6, 0)

                     "ellipsize", PANGO_ELLIPSIZE_END,

#endif

                     "ypad", 0, NULL);

        column = gtk_tree_view_column_new_with_attributes

                (_("E-Mail address"), renderer, "text", COL_ADDRESS, NULL);

        gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);

        gtk_tree_view_column_set_fixed_width(column, COL_ADDRESS_WIDTH);

        gtk_tree_view_column_set_resizable(column, TRUE);

        gtk_tree_view_column_set_sort_column_id(column, COL_ADDRESS);

        gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column);

        renderer = gtk_cell_renderer_text_new();

        g_object_set(renderer,

#if GTK_CHECK_VERSION(2, 6, 0)

                     "ellipsize", PANGO_ELLIPSIZE_END,

#endif

                     "ypad", 0, NULL);

        column = gtk_tree_view_column_new_with_attributes

                (_("Remarks"), renderer, "text", COL_REMARKS, NULL);

        gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);

        gtk_tree_view_column_set_resizable(column, TRUE);

        gtk_tree_view_column_set_sort_column_id(column, COL_REMARKS);

        gtk_tree_view_append_column(GTK_TREE_VIEW(listview), column);

        gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list_store),

                                             COL_NAME, GTK_SORT_ASCENDING);

        g_signal_connect(G_OBJECT(selection), "changed",

                         G_CALLBACK(addressbook_list_selection_changed), NULL);

        g_signal_connect(G_OBJECT(listview), "button_press_event",

                         G_CALLBACK(addressbook_list_button_pressed),

                         NULL);

        g_signal_connect(G_OBJECT(listview), "button_release_event",

                         G_CALLBACK(addressbook_list_button_released),

                         NULL);

        g_signal_connect(G_OBJECT(listview), "row_expanded",

                         G_CALLBACK(addressbook_person_expand_node), NULL);

        g_signal_connect(G_OBJECT(listview), "row_collapsed",

                         G_CALLBACK(addressbook_person_collapse_node), NULL);

        hbox = gtk_hbox_new(FALSE, 4);

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

#if 0

        label = gtk_label_new(_("Name:"));

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

#endif

        entry = gtk_entry_new();

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

        address_completion_register_entry(GTK_ENTRY(entry));

#if 0

        g_signal_connect(G_OBJECT(entry), "changed",

                         G_CALLBACK(addressbook_entry_changed), NULL);

#endif

        g_signal_connect(G_OBJECT(entry), "activate",

                         G_CALLBACK(addressbook_entry_activated), NULL);

        paned = gtk_hpaned_new();

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

        gtk_paned_add1(GTK_PANED(paned), tree_swin);

        gtk_paned_add2(GTK_PANED(paned), list_vbox);

        /* Status bar */

        hsbox = gtk_hbox_new(FALSE, 0);

        gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, 0);

        statusbar = gtk_statusbar_new();

        gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, 0);

        hbbox = gtk_hbox_new(FALSE, 4);

        gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);

        /* Button panel */

        hbbox1 = gtk_hbutton_box_new();

        gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox1), GTK_BUTTONBOX_END);

        gtk_box_set_spacing(GTK_BOX(hbbox1), 4);

        gtk_container_set_border_width(GTK_CONTAINER(hbbox1), 4);

        gtk_button_box_set_child_size(GTK_BUTTON_BOX(hbbox1), 64, -1);

        gtk_box_pack_end(GTK_BOX(hbbox), hbbox1, FALSE, FALSE, 0);

        to_btn = gtk_button_new_with_label

                (prefs_common.trans_hdr ? _("To:") : "To:");

        GTK_WIDGET_SET_FLAGS(to_btn, GTK_CAN_DEFAULT);

        gtk_box_pack_start(GTK_BOX(hbbox1), to_btn, TRUE, TRUE, 0);

        cc_btn = gtk_button_new_with_label

                (prefs_common.trans_hdr ? _("Cc:") : "Cc:");

        GTK_WIDGET_SET_FLAGS(cc_btn, GTK_CAN_DEFAULT);

        gtk_box_pack_start(GTK_BOX(hbbox1), cc_btn, TRUE, TRUE, 0);

        bcc_btn = gtk_button_new_with_label

                (prefs_common.trans_hdr ? _("Bcc:") : "Bcc:");

        GTK_WIDGET_SET_FLAGS(bcc_btn, GTK_CAN_DEFAULT);

        gtk_box_pack_start(GTK_BOX(hbbox1), bcc_btn, TRUE, TRUE, 0);

        g_signal_connect(G_OBJECT(to_btn), "clicked",

                         G_CALLBACK(addressbook_to_clicked),

                         GINT_TO_POINTER(COMPOSE_ENTRY_TO));

        g_signal_connect(G_OBJECT(cc_btn), "clicked",

                         G_CALLBACK(addressbook_to_clicked),

                         GINT_TO_POINTER(COMPOSE_ENTRY_CC));

        g_signal_connect(G_OBJECT(bcc_btn), "clicked",

                         G_CALLBACK(addressbook_to_clicked),

                         GINT_TO_POINTER(COMPOSE_ENTRY_BCC));

        hbbox2 = gtk_hbutton_box_new();

        gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox2), GTK_BUTTONBOX_END);

        gtk_box_set_spacing(GTK_BOX(hbbox2), 4);

        gtk_container_set_border_width(GTK_CONTAINER(hbbox2), 4);

        gtk_button_box_set_child_size(GTK_BUTTON_BOX(hbbox2), 64, -1);

        gtk_box_pack_end(GTK_BOX(hbbox), hbbox2, TRUE, TRUE, 0);

        del_btn = gtk_button_new_with_label(_("Delete"));

        GTK_WIDGET_SET_FLAGS(del_btn, GTK_CAN_DEFAULT);

        gtk_box_pack_start(GTK_BOX(hbbox2), del_btn, TRUE, TRUE, 0);

        reg_btn = gtk_button_new_with_label(_("Add"));

        GTK_WIDGET_SET_FLAGS(reg_btn, GTK_CAN_DEFAULT);

        gtk_box_pack_start(GTK_BOX(hbbox2), reg_btn, TRUE, TRUE, 0);

        lup_btn = gtk_button_new_with_label(_("Lookup"));

        GTK_WIDGET_SET_FLAGS(lup_btn, GTK_CAN_DEFAULT);

        gtk_box_pack_start(GTK_BOX(hbbox2), lup_btn, TRUE, TRUE, 0);

        close_btn = gtk_button_new_with_mnemonic(_("_Close"));

        GTK_WIDGET_SET_FLAGS(close_btn, GTK_CAN_DEFAULT);

        gtk_box_pack_start(GTK_BOX(hbbox2), close_btn, TRUE, TRUE, 0);

        gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(hbbox2), close_btn,

                                           TRUE);

        g_signal_connect(G_OBJECT(del_btn), "clicked",

                         G_CALLBACK(addressbook_del_clicked), NULL);

        g_signal_connect(G_OBJECT(reg_btn), "clicked",

                         G_CALLBACK(addressbook_reg_clicked), NULL);

        g_signal_connect(G_OBJECT(lup_btn), "clicked",

                         G_CALLBACK(addressbook_lup_clicked), NULL);

        g_signal_connect(G_OBJECT(close_btn), "clicked",

                         G_CALLBACK(addressbook_close_clicked), NULL);

        /* Build icons for interface */

        stock_pixbuf_gdk(window, STOCK_PIXMAP_INTERFACE, &interfacepix);

        stock_pixmap_gdk(window, STOCK_PIXMAP_INTERFACE,

                         &interfacexpm, &interfacexpmmask);

        /* Build control tables */

        addrbookctl_build_map(window);

        addrbookctl_build_iflist();

        addrbookctl_build_ifselect();

        /* Add each interface into the tree as a root level folder */

        nodeIf = _addressInterfaceList_;

        while( nodeIf ) {

                AdapterInterface *adapter = nodeIf->data;

                AddressInterface *iface = adapter->interface;

                nodeIf = g_list_next(nodeIf);

                if(iface->useInterface) {

                        AddressTypeControlItem *atci = adapter->atci;

                        gchar *text = atci->displayName;

                        GtkTreeIter iter;

                        GtkTreePath *path;

                        debug_print("addressbook_create: adapter: %s\n", text);

                        gtk_tree_store_append(tree_store, &iter, NULL);

                        gtk_tree_store_set(tree_store, &iter,

                                           COL_FOLDER_NAME, text,

                                           COL_OBJ, adapter,

                                           COL_PIXBUF, interfacepix,

                                           COL_PIXBUF_OPEN, interfacepix, -1);

                        path = gtk_tree_model_get_path(GTK_TREE_MODEL(tree_store), &iter);

                        adapter->tree_row = gtk_tree_row_reference_new(GTK_TREE_MODEL(tree_store), path);

                        gtk_tree_path_free(path);

                }

        }

        /* Popup menu */

        n_entries = sizeof(addressbook_tree_popup_entries) /

                sizeof(addressbook_tree_popup_entries[0]);

        tree_popup = menu_create_items(addressbook_tree_popup_entries,

                                       n_entries,

                                       "<AddressBookTree>", &tree_factory,

                                       NULL);

        g_signal_connect(G_OBJECT(tree_popup), "selection_done",

                         G_CALLBACK(addressbook_popup_close), NULL);

        n_entries = sizeof(addressbook_list_popup_entries) /

                sizeof(addressbook_list_popup_entries[0]);

        list_popup = menu_create_items(addressbook_list_popup_entries,

                                       n_entries,

                                       "<AddressBookList>", &list_factory,

                                       NULL);

        addrbook.window     = window;

        addrbook.menubar    = menubar;

        addrbook.treeview   = treeview;

        addrbook.listview   = listview;

        addrbook.entry      = entry;

        addrbook.statusbar  = statusbar;

        addrbook.status_cid = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "Address Book Window");

        addrbook.to_btn  = to_btn;

        addrbook.cc_btn  = cc_btn;

        addrbook.bcc_btn = bcc_btn;

        addrbook.del_btn = del_btn;

        addrbook.reg_btn = reg_btn;

        addrbook.lup_btn = lup_btn;

        addrbook.close_btn = close_btn;

        addrbook.tree_popup   = tree_popup;

        addrbook.list_popup   = list_popup;

        addrbook.tree_factory = tree_factory;

        addrbook.list_factory = list_factory;

        addrbook.menu_factory = menu_factory;

        addrbook.tree_selected = NULL;

        addrbook.list_selected = NULL;

        address_completion_start(window);

        gtk_widget_show_all(window);

}

static gint addressbook_close(void)

{

        gtkut_widget_get_uposition(addrbook.window,

                                   &prefs_common.addressbook_x,

                                   &prefs_common.addressbook_y);

        gtk_widget_hide(addrbook.window);

        addressbook_export_to_file();

        return TRUE;

}

static void addressbook_status_show(const gchar *msg)

{

        if (addrbook.statusbar != NULL) {

                gtk_statusbar_pop(GTK_STATUSBAR(addrbook.statusbar), addrbook.status_cid);

                if (msg) {

                        gtk_statusbar_push(GTK_STATUSBAR(addrbook.statusbar), addrbook.status_cid, msg);

                }

        }

}

static void addressbook_ds_show_message(AddressDataSource *ds)

{

        gint retVal;

        gchar *name;

        *addressbook_msgbuf = '\0';

        if (ds) {

                name = addrindex_ds_get_name(ds);

                retVal = addrindex_ds_get_status_code(ds);

                if (retVal == MGU_SUCCESS) {

                        if (ds) {

                                g_snprintf(addressbook_msgbuf, sizeof(addressbook_msgbuf), "%s", name);

                        }

                } else {

                        if (ds == NULL) {

                                g_snprintf(addressbook_msgbuf, sizeof(addressbook_msgbuf), "%s", mgu_error2string(retVal));

                        } else {

                                g_snprintf(addressbook_msgbuf, sizeof(addressbook_msgbuf), "%s: %s", name, mgu_error2string(retVal));

                        }

                }

        }

        addressbook_status_show(addressbook_msgbuf);

}

/*

* Delete one or more objects from address list.

*/

static void addressbook_del_clicked(GtkButton *button, gpointer data)

{

        GtkTreeView *treeview = GTK_TREE_VIEW(addrbook.treeview);

        GtkTreeSelection *selection;

        GtkTreeModel *model;

        GtkTreeIter iter;

        GtkTreeView *listview = GTK_TREE_VIEW(addrbook.listview);

        GtkTreeModel *lmodel;

        GtkTreeIter list_sel;

        AddressObject *pobj = NULL;

        AddressObject *obj = NULL;

        AdapterDSource *ads = NULL;

        gboolean procFlag;

        AlertValue aval;

        AddressBookFile *abf = NULL;

        AddressDataSource *ds = NULL;

        if (!addrbook.tree_opened)

                return;

        model = gtk_tree_view_get_model(treeview);

        lmodel = gtk_tree_view_get_model(listview);

        selection = gtk_tree_view_get_selection(treeview);

        gtkut_tree_row_reference_get_iter(model, addrbook.tree_opened, &iter);

        gtk_tree_model_get(model, &iter, COL_OBJ, &pobj, -1);

        g_return_if_fail(pobj != NULL);

        gtkut_tree_row_reference_get_iter(lmodel, addrbook.list_selected,

                                          &list_sel);

        gtk_tree_model_get(lmodel, &list_sel, COL_L_OBJ, &obj, -1);

        if (obj == NULL)

                return;

        if (!gtk_tree_selection_get_selected(selection, NULL, &iter))

                return;

        ds = addressbook_find_datasource(&iter);

        if (ds == NULL)

                return;

        procFlag = FALSE;

        if (pobj->type == ADDR_DATASOURCE) {

                ads = ADAPTER_DSOURCE(pobj);

                if(ads->subType == ADDR_BOOK)

                        procFlag = TRUE;

        }

        else if (pobj->type == ADDR_ITEM_FOLDER) {

                procFlag = TRUE;

        } else if (pobj->type == ADDR_ITEM_GROUP) {

                procFlag = TRUE;

        }

        if (!procFlag)

                return;

        abf = ds->rawDataSource;

        if (abf == NULL)

                return;

        /* Confirm deletion */

        aval = alertpanel(_("Delete address(es)"),

                          _("Really delete the address(es)?"),

                          GTK_STOCK_YES, GTK_STOCK_NO, NULL);

        if (aval != G_ALERTDEFAULT)

                return;

        /* Process deletions */

        if (pobj->type == ADDR_DATASOURCE || pobj->type == ADDR_ITEM_FOLDER) {

                /* Items inside folders */

                GList *node;

                node = _addressListSelection_;

                while (node) {

                        AddrItemObject *aio = node->data;

                        node = g_list_next(node);

                        if (aio->type == ADDR_ITEM_GROUP) {

                                ItemGroup *item = (ItemGroup *)aio;

                                GtkTreeIter giter;

                                addressbook_find_group_node(&iter, &giter, item);

                                item = addrbook_remove_group(abf, item);

                                if (item) {

                                        addritem_free_item_group(item);

                                        item = NULL;

                                }

                                /* Remove group from parent node */

                                gtk_tree_store_remove(GTK_TREE_STORE(model), &giter);

                        } else if (aio->type == ADDR_ITEM_PERSON) {

                                ItemPerson *item = (ItemPerson *)aio;

                                if (_clipObjectList_) {

                                        _clipObjectList_ = g_list_remove(_clipObjectList_, item);

                                }

                                item = addrbook_remove_person(abf, item);

                                if (item) {

                                        addritem_free_item_person(item);

                                        item = NULL;

                                }

                        } else if (aio->type == ADDR_ITEM_EMAIL) {

                                ItemEMail *item = (ItemEMail *)aio;

                                ItemPerson *person = (ItemPerson *)ADDRITEM_PARENT(item);

                                item = addrbook_person_remove_email(abf, person, item);

                                if (item) {

                                        addritem_free_item_email(item);

                                        item = NULL;

                                }

                        }

                }

                addressbook_list_select_clear();

                addressbook_reopen();

                return;

        } else if (pobj->type == ADDR_ITEM_GROUP) {

                /* Items inside groups */

                GList *node;

                ItemGroup *group = ADAPTER_GROUP(pobj)->itemGroup;

                node = _addressListSelection_;

                while (node) {

                        AddrItemObject *aio = node->data;

                        node = g_list_next(node);

                        if (aio->type == ADDR_ITEM_EMAIL) {

                                ItemEMail *item = (ItemEMail *)aio;

                                item = addrbook_group_remove_email(abf, group, item);

                        }

                }

                addressbook_list_select_clear();

                addressbook_reopen();

                return;

        }

        gtk_tree_store_remove(GTK_TREE_STORE(lmodel), &list_sel);

        addressbook_list_select_remove(obj);

}

static void addressbook_reg_clicked(GtkButton *button, gpointer data)

{

        addressbook_new_address_cb(NULL, 0, NULL);

}

gchar *addressbook_format_address(AddressObject *obj)

{

        gchar *buf = NULL;

        gchar *name = NULL;

        gchar *address = NULL;

        if( obj->type == ADDR_ITEM_EMAIL ) {

                ItemPerson *person = NULL;

                ItemEMail *email = ( ItemEMail * ) obj;

                person = ( ItemPerson * ) ADDRITEM_PARENT(email);

                if( email->address ) {

                        if( ADDRITEM_NAME(email) ) {

                                name = ADDRITEM_NAME(email);

                                if( *name == '\0' ) {

                                        name = ADDRITEM_NAME(person);

                                }

                        }

                        else if( person && ADDRITEM_NAME(person) ) {

                                name = ADDRITEM_NAME(person);

                        }

                        else {

                                buf = g_strdup( email->address );

                        }

                        address = email->address;

                }

        }

        else if( obj->type == ADDR_ITEM_PERSON ) {

                ItemPerson *person = ( ItemPerson * ) obj;

                GList *node = person->listEMail;

                name = ADDRITEM_NAME(person);

                if( node ) {

                        ItemEMail *email = ( ItemEMail * ) node->data;

                        address = email->address;

                }

        }

        if( address ) {

                if( name && name[0] != '\0' ) {

                        if( name[0] != '"' && strpbrk( name, ",.[]<>" ) != NULL )

                                buf = g_strdup_printf( "\"%s\" <%s>", name, address );

                        else

                                buf = g_strdup_printf( "%s <%s>", name, address );

                }

                else {

                        buf = g_strdup( address );

                }

        }

        return buf;

}

static void addressbook_to_clicked(GtkButton *button, gpointer data)

{

        GList *node = _addressListSelection_;

        if (!addrbook.target_compose) {

                addrbook.target_compose = compose_new(NULL, NULL, NULL, NULL);

                if (!addrbook.target_compose)

                        return;

        }

        while( node ) {

                AddressObject *obj = node->data;

                Compose *compose = addrbook.target_compose;

                node = g_list_next( node );

                if( obj->type == ADDR_ITEM_PERSON || obj->type == ADDR_ITEM_EMAIL ) {

                        gchar *addr = addressbook_format_address( obj );

                        compose_entry_append( compose, addr, (ComposeEntryType) data );

                        g_free( addr );

                        addr = NULL;

                }

                else if( obj->type == ADDR_ITEM_GROUP ) {

                        ItemGroup *group = ( ItemGroup * ) obj;

                        GList *nodeMail = group->listEMail;

                        while( nodeMail ) {

                                ItemEMail *email = nodeMail->data;

                                gchar *addr = addressbook_format_address( ( AddressObject * ) email );

                                compose_entry_append( compose, addr, (ComposeEntryType) data );

                                g_free( addr );

                                nodeMail = g_list_next( nodeMail );

                        }

                }

        }

}

static void addressbook_menuitem_set_sensitive(void)

{

        GtkTreeView *treeview = GTK_TREE_VIEW(addrbook.treeview);

        GtkTreeView *listview = GTK_TREE_VIEW(addrbook.listview);

        GtkTreeSelection *selection;

        GtkTreeSelection *lselection;

        GtkTreeModel *model;

        GtkTreeModel *lmodel;

        GtkTreeIter iter;

        GtkTreeIter liter;

        gboolean canAdd = FALSE;

        gboolean canEditTree = TRUE;

        gboolean canEditAddress = FALSE;

        gboolean canDelete = FALSE;

        gboolean canLookup = FALSE;

        gboolean canCopy = FALSE;

        gboolean canPaste = FALSE;

        AddressTypeControlItem *atci = NULL;

        AddressDataSource *ds = NULL;

        AddressInterface *iface = NULL;

        AddressObject *pobj = NULL;

        AddressObject *obj = NULL;

        menu_set_sensitive(addrbook.menu_factory, "/File/New Book", FALSE);

        menu_set_sensitive(addrbook.menu_factory, "/File/New vCard", FALSE);

#ifdef USE_JPILOT

        menu_set_sensitive(addrbook.menu_factory, "/File/New JPilot", FALSE);

#endif

#ifdef USE_LDAP

        menu_set_sensitive(addrbook.menu_factory, "/File/New LDAP Server", FALSE);

#endif

        menu_set_insensitive_all(GTK_MENU_SHELL(addrbook.tree_popup));

        menu_set_insensitive_all(GTK_MENU_SHELL(addrbook.list_popup));

        selection = gtk_tree_view_get_selection(treeview);

        if (!gtk_tree_selection_get_selected(selection, &model, &iter))

                return;

        gtk_tree_model_get(model, &iter, COL_OBJ, &pobj, -1);

        if (pobj == NULL)

                return;

        lmodel = gtk_tree_view_get_model(listview);

        lselection = gtk_tree_view_get_selection(listview);

        if (addrbook.list_selected) {

                if (gtkut_tree_row_reference_get_iter(lmodel, addrbook.list_selected, &liter))

                        gtk_tree_model_get(lmodel, &liter, COL_L_OBJ, &obj, -1);

        }

        if (pobj->type == ADDR_INTERFACE) {

                AdapterInterface *adapter = ADAPTER_INTERFACE(pobj);

                iface = adapter->interface;

                if (iface && iface->haveLibrary) {

                        /* Enable appropriate File / New command */

                        atci = adapter->atci;

                        menu_set_sensitive(addrbook.menu_factory, atci->menuCommand, TRUE);

                }

                canEditTree = FALSE;

        } else if (pobj->type == ADDR_DATASOURCE) {

                AdapterDSource *ads = ADAPTER_DSOURCE(pobj);

                ds = ads->dataSource;

                iface = ds->interface;

                if (!iface->readOnly) {

                        canAdd = canEditAddress = TRUE;

                }

                if (!iface->haveLibrary) {

                        canAdd = canEditAddress = FALSE;

                }

#ifdef USE_LDAP

                if (ads->subType == ADDR_LDAP) {

                        if (iface->haveLibrary && ds->rawDataSource)

                                canLookup = TRUE;

                } else

#endif

                        canLookup = TRUE;

        } else if (pobj->type == ADDR_ITEM_FOLDER) {

                ds = addressbook_find_datasource(&iter);

                if (ds) {

                        iface = ds->interface;

                        if (!iface->readOnly) {

                                canAdd = canEditAddress = TRUE;

                        }

                        canLookup = TRUE;

                }

        } else if (pobj->type == ADDR_ITEM_GROUP) {

                ds = addressbook_find_datasource(&iter);

                if (ds) {

                        iface = ds->interface;

                        if (!iface->readOnly) {

                                canEditAddress = TRUE;

                        }

                        canLookup = TRUE;

                }

        }

        if (obj == NULL)

                canEditAddress = FALSE;

        canDelete = canEditAddress;

        if (gtk_tree_selection_count_selected_rows(lselection) > 1)

                canEditAddress = FALSE;

        if (_addressListSelection_) {

                GList *cur;

                AddressObject *item;

                for (cur = _addressListSelection_; cur != NULL; cur = cur->next) {

                        item = cur->data;

                        if (item->type == ADDR_ITEM_PERSON) {