Sylpheed

/*

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

 * Copyright (C) 1999-2002 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 <gdk/gdkkeysyms.h>

#include <gtk/gtkwindow.h>

#include <gtk/gtksignal.h>

#include <gtk/gtkvbox.h>

#include <gtk/gtkscrolledwindow.h>

#include <gtk/gtkhpaned.h>

#include <gtk/gtkhbox.h>

#include <gtk/gtklabel.h>

#include <gtk/gtkentry.h>

#include <gtk/gtkctree.h>

#include <gtk/gtkclist.h>

#include <gtk/gtktable.h>

#include <gtk/gtkhbbox.h>

#include <gtk/gtkbutton.h>

#include <gtk/gtkmenu.h>

#include <gtk/gtkmenuitem.h>

#include <gtk/gtkitemfactory.h>

#include <string.h>

#include <setjmp.h>

#include "intl.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"

#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_NAME        = 0,

        COL_ADDRESS        = 1,

        COL_REMARKS        = 2

} AddressBookColumnPos;

#define N_COLS        3

#define COL_NAME_WIDTH                164

#define COL_ADDRESS_WIDTH        156

#define COL_FOLDER_WIDTH        170

#define ADDRESSBOOK_WIDTH        640

#define ADDRESSBOOK_HEIGHT        360

#define ADDRESSBOOK_MSGBUF_SIZE 2048

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"

static AddressBook_win addrbook;

static GHashTable *_addressBookTypeHash_ = NULL;

static GList *_addressBookTypeList_ = NULL;

static void addressbook_create                        (void);

static gint addressbook_close                        (void);

static void addressbook_button_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_tree_selected                (GtkCTree        *ctree,

                                                 GtkCTreeNode        *node,

                                                 gint                 column,

                                                 gpointer         data);

static void addressbook_list_selected                (GtkCList        *clist,

                                                 gint                 row,

                                                 gint                 column,

                                                 GdkEvent        *event,

                                                 gpointer         data);

static void addressbook_list_row_selected        (GtkCTree        *clist,

                                                 GtkCTreeNode        *node,

                                                 gint                 column,

                                                 gpointer         data);

static void addressbook_list_row_unselected        (GtkCTree        *clist,

                                                 GtkCTreeNode        *node,

                                                 gint                 column,

                                                 gpointer         data);

static void addressbook_person_expand_node        (GtkCTree        *ctree,

                                                 GList                *node,

                                                 gpointer        *data );

static void addressbook_person_collapse_node        (GtkCTree        *ctree,

                                                 GList                *node,

                                                 gpointer        *data );

static void addressbook_entry_gotfocus                (GtkWidget        *widget);

#if 0

static void addressbook_entry_changed                (GtkWidget        *widget);

#endif

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        (GtkCTreeNode        *node,

                                                 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 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_clist                (AddressObject        *obj);

static void addressbook_load_tree                (void);

void addressbook_read_file                        (void);

static GtkCTreeNode *addressbook_add_object        (GtkCTreeNode        *node,

                                                 AddressObject        *obj);

static AddressDataSource *addressbook_find_datasource

                                                (GtkCTreeNode        *node );

static AddressBookFile *addressbook_get_book_file();

static GtkCTreeNode *addressbook_node_add_folder

                                                (GtkCTreeNode        *node,

                                                AddressDataSource *ds,

                                                ItemFolder        *itemFolder,

                                                AddressObjectType otype);

static GtkCTreeNode *addressbook_node_add_group (GtkCTreeNode        *node,

                                                AddressDataSource *ds,

                                                ItemGroup        *itemGroup);

/* static GtkCTreeNode *addressbook_node_add_category */

/*                                                (GtkCTreeNode        *node, */

/*                                                 AddressDataSource *ds, */

/*                                                 ItemFolder        *itemFolder); */

static void addressbook_tree_remove_children        (GtkCTree        *ctree,

                                                GtkCTreeNode        *parent);

static void addressbook_move_nodes_up                (GtkCTree        *ctree,

                                                GtkCTreeNode        *node);

static GtkCTreeNode *addressbook_find_group_node (GtkCTreeNode        *parent,

                                                ItemGroup        *group);

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

static gboolean key_pressed                        (GtkWidget        *widget,

                                                 GdkEventKey        *event,

                                                 gpointer         data);

static gint addressbook_list_compare_func        (GtkCList        *clist,

                                                 gconstpointer         ptr1,

                                                 gconstpointer         ptr2);

/* static gint addressbook_obj_name_compare        (gconstpointer         a, */

/*                                                 gconstpointer         b); */

/* 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                (GtkCTreeNode        *node);

static void addressbook_free_child_adapters        (GtkCTreeNode        *node);

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_add                (AddressObject *obj);

static void addressbook_list_select_remove        (AddressObject *obj);

static void addressbook_import_ldif_cb                (void);

static GtkItemFactoryEntry addressbook_entries[] =

{

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

        {N_("/_File/New _Book"),        "<alt>B",        addressbook_new_book_cb,        0, NULL},

        {N_("/_File/New _vCard"),        "<alt>D",        addressbook_new_vcard_cb,       0, NULL},

#ifdef USE_JPILOT

        {N_("/_File/New _JPilot"),        "<alt>J",        addressbook_new_jpilot_cb,      0, NULL},

#endif

#ifdef USE_LDAP

        {N_("/_File/New _Server"),        "<alt>S",        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"),                "<alt>S",        addressbook_file_save_cb,       0, NULL},

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

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

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

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

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

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

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

        {N_("/_Address/_Delete"),        NULL,                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_("/_Help"),                        NULL,                NULL, 0, "<LastBranch>"},

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

};

/* New options to be added. */

/*

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

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

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

        {N_("/_Edit/_Paste"),                "<ctl>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}

};

void addressbook_open(Compose *target)

{

        if (!addrbook.window) {

                addressbook_read_file();

                addressbook_create();

                addressbook_load_tree();

                gtk_ctree_select(GTK_CTREE(addrbook.ctree),

                                 GTK_CTREE_NODE(GTK_CLIST(addrbook.ctree)->row_list));

        } else

                gtk_widget_hide(addrbook.window);

        gtk_widget_show_all(addrbook.window);

        addressbook_set_target_compose(target);

}

void addressbook_set_target_compose(Compose *target)

{

        addrbook.target_compose = target;

        addressbook_button_set_sensitive();

}

Compose *addressbook_get_target_compose(void)

{

        return addrbook.target_compose;

}

void addressbook_refresh(void)

{

        if (addrbook.window) {

                if (addrbook.treeSelected) {

                        gtk_ctree_select(GTK_CTREE(addrbook.ctree),

                                         addrbook.treeSelected);

                }

        }

        addressbook_export_to_file();

}

/*

* 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 *vbox2;

        GtkWidget *ctree_swin;

        GtkWidget *ctree;

        GtkWidget *clist_vbox;

        GtkWidget *clist_swin;

        GtkWidget *clist;

        GtkWidget *paned;

        GtkWidget *hbox;

        GtkWidget *label;

        GtkWidget *entry;

        GtkWidget *statusbar;

        GtkWidget *hbbox;

        GtkWidget *hsbox;

        GtkWidget *del_btn;

        GtkWidget *reg_btn;

        GtkWidget *lup_btn;

        GtkWidget *to_btn;

        GtkWidget *cc_btn;

        GtkWidget *bcc_btn;

        GtkWidget *tree_popup;

        GtkWidget *list_popup;

        GtkItemFactory *tree_factory;

        GtkItemFactory *list_factory;

        GtkItemFactory *menu_factory;

        gint n_entries;

        GList *nodeIf;

        gchar *titles[N_COLS];

        gchar *text;

        gint i;

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

        titles[COL_NAME]    = _("Name");

        titles[COL_ADDRESS] = _("E-Mail address");

        titles[COL_REMARKS] = _("Remarks");

        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

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

        gtk_widget_set_size_request

                (window, ADDRESSBOOK_WIDTH, ADDRESSBOOK_HEIGHT);

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

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

        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);

        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);

        vbox2 = gtk_vbox_new(FALSE, 4);

        gtk_container_set_border_width(GTK_CONTAINER(vbox2), BORDER_WIDTH);

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

        ctree_swin = gtk_scrolled_window_new(NULL, NULL);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ctree_swin),

                                       GTK_POLICY_AUTOMATIC,

                                       GTK_POLICY_ALWAYS);

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

        /* Address index */

        ctree = gtk_ctree_new(1, 0);

        gtk_container_add(GTK_CONTAINER(ctree_swin), ctree);

        gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE);

        gtk_clist_set_column_width(GTK_CLIST(ctree), 0, COL_FOLDER_WIDTH);

        gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_DOTTED);

        gtk_ctree_set_expander_style(GTK_CTREE(ctree),

                                     GTK_CTREE_EXPANDER_SQUARE);

        gtk_ctree_set_indent(GTK_CTREE(ctree), CTREE_INDENT);

        gtk_clist_set_compare_func(GTK_CLIST(ctree),

                                   addressbook_list_compare_func);

        g_signal_connect(G_OBJECT(ctree), "tree_select_row",

                         G_CALLBACK(addressbook_tree_selected), NULL);

        g_signal_connect(G_OBJECT(ctree), "button_press_event",

                         G_CALLBACK(addressbook_tree_button_pressed),

                         NULL);

        g_signal_connect(G_OBJECT(ctree), "button_release_event",

                         G_CALLBACK(addressbook_tree_button_released),

                         NULL);

        clist_vbox = gtk_vbox_new(FALSE, 4);

        clist_swin = gtk_scrolled_window_new(NULL, NULL);

        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin),

                                       GTK_POLICY_AUTOMATIC,

                                       GTK_POLICY_ALWAYS);

        gtk_box_pack_start(GTK_BOX(clist_vbox), clist_swin, TRUE, TRUE, 0);

        /* Address list */

        clist = gtk_ctree_new_with_titles(N_COLS, 0, titles);

        gtk_container_add(GTK_CONTAINER(clist_swin), clist);

        gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_EXTENDED);

        gtk_ctree_set_line_style(GTK_CTREE(clist), GTK_CTREE_LINES_NONE);

        gtk_ctree_set_expander_style(GTK_CTREE(clist), GTK_CTREE_EXPANDER_SQUARE);

        gtk_ctree_set_indent(GTK_CTREE(clist), CTREE_INDENT);

        gtk_clist_set_column_width(GTK_CLIST(clist), COL_NAME,

                                   COL_NAME_WIDTH);

        gtk_clist_set_column_width(GTK_CLIST(clist), COL_ADDRESS,

                                   COL_ADDRESS_WIDTH);

        gtk_clist_set_compare_func(GTK_CLIST(clist),

                                   addressbook_list_compare_func);

        for (i = 0; i < N_COLS; i++)

                GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[i].button,

                                       GTK_CAN_FOCUS);

        g_signal_connect(G_OBJECT(clist), "tree_select_row",

                         G_CALLBACK(addressbook_list_row_selected), NULL);

        g_signal_connect(G_OBJECT(clist), "tree_unselect_row",

                         G_CALLBACK(addressbook_list_row_unselected), NULL);

        g_signal_connect(G_OBJECT(clist), "button_press_event",

                         G_CALLBACK(addressbook_list_button_pressed),

                         NULL);

        g_signal_connect(G_OBJECT(clist), "button_release_event",

                         G_CALLBACK(addressbook_list_button_released),

                         NULL);

        g_signal_connect(G_OBJECT(clist), "select_row",

                         G_CALLBACK(addressbook_list_selected), NULL);

        g_signal_connect(G_OBJECT(clist), "tree_expand",

                         G_CALLBACK(addressbook_person_expand_node), NULL);

        g_signal_connect(G_OBJECT(clist), "tree_collapse",

                         G_CALLBACK(addressbook_person_collapse_node), NULL);

        hbox = gtk_hbox_new(FALSE, 4);

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

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

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

        entry = gtk_entry_new();

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

        address_completion_register_entry(GTK_ENTRY(entry));

        g_signal_connect(G_OBJECT(entry), "focus_in_event",

                         G_CALLBACK(addressbook_entry_gotfocus), NULL);

#if 0

        g_signal_connect(G_OBJECT(entry), "changed",

                         G_CALLBACK(addressbook_entry_changed), NULL);

#endif

        paned = gtk_hpaned_new();

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

        gtk_paned_add1(GTK_PANED(paned), ctree_swin);

        gtk_paned_add2(GTK_PANED(paned), clist_vbox);

        /* Status bar */

        hsbox = gtk_hbox_new(FALSE, 0);

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

        statusbar = gtk_statusbar_new();

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

        /* Button panel */

        hbbox = gtk_hbutton_box_new();

        gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);

        gtk_box_set_spacing(GTK_BOX(hbbox), 2);

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

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

        GTK_WIDGET_SET_FLAGS(del_btn, GTK_CAN_DEFAULT);

        gtk_box_pack_start(GTK_BOX(hbbox), 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(hbbox), 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(hbbox), lup_btn, TRUE, TRUE, 0);

        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);

        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(hbbox), 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(hbbox), 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(hbbox), 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));

        /* Build icons for interface */

        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;

                        text = atci->displayName;

                        adapter->treeNode =

                                gtk_ctree_insert_node( GTK_CTREE(ctree),

                                        NULL, NULL, &text, FOLDER_SPACING,

                                        interfacexpm, interfacexpmmask,

                                        interfacexpm, interfacexpmmask,

                                        FALSE, FALSE );

                        menu_set_sensitive( menu_factory, atci->menuCommand, adapter->haveLibrary );

                        gtk_ctree_node_set_row_data( GTK_CTREE(ctree), adapter->treeNode, adapter );

                }

        }

        /* 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.ctree   = ctree;

        addrbook.clist   = clist;

        addrbook.entry   = entry;

        addrbook.statusbar = statusbar;

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

        addrbook.del_btn = del_btn;

        addrbook.reg_btn = reg_btn;

        addrbook.lup_btn = lup_btn;

        addrbook.to_btn  = to_btn;

        addrbook.cc_btn  = cc_btn;

        addrbook.bcc_btn = bcc_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.listSelected = NULL;

        address_completion_start(window);

        gtk_widget_show_all(window);

}

static gint addressbook_close(void)

{

        gtk_widget_hide(addrbook.window);

        addressbook_export_to_file();

        return TRUE;

}

static void addressbook_status_show( 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 ) {

                                sprintf( addressbook_msgbuf, "%s", name );

                        }

                }

                else {

                        if( ds == NULL ) {

                                sprintf( addressbook_msgbuf, "%s", mgu_error2string( retVal ) );

                        }

                        else {

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

                        }

                }

        }

        addressbook_status_show( addressbook_msgbuf );

}

static void addressbook_button_set_sensitive(void)

{

        gboolean to_sens  = FALSE;

        gboolean cc_sens  = FALSE;

        gboolean bcc_sens = FALSE;

        if (!addrbook.window) return;

        if (addrbook.target_compose) {

                to_sens = TRUE;

                cc_sens = TRUE;

                if (addrbook.target_compose->use_bcc)

                        bcc_sens = TRUE;

        }

        gtk_widget_set_sensitive(addrbook.to_btn, to_sens);

        gtk_widget_set_sensitive(addrbook.cc_btn, cc_sens);

        gtk_widget_set_sensitive(addrbook.bcc_btn, bcc_sens);

}

/*

* Delete one or more objects from address list.

*/

static void addressbook_del_clicked(GtkButton *button, gpointer data)

{

        GtkCTree *clist = GTK_CTREE(addrbook.clist);

        GtkCTree *ctree = GTK_CTREE(addrbook.ctree);

        AddressObject *pobj, *obj;

        AdapterDSource *ads = NULL;

        GtkCTreeNode *nodeList;

        gboolean procFlag;

        AlertValue aval;

        AddressBookFile *abf = NULL;

        AddressDataSource *ds = NULL;

        pobj = gtk_ctree_node_get_row_data(ctree, addrbook.opened );

        g_return_if_fail(pobj != NULL);

        nodeList = addrbook.listSelected;

        obj = gtk_ctree_node_get_row_data( clist, nodeList );

        if( obj == NULL) return;

        ds = addressbook_find_datasource( addrbook.treeSelected );

        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)?"),

                        _("Yes"), _("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;

                                GtkCTreeNode *nd = NULL;

                                nd = addressbook_find_group_node( addrbook.opened, item );

                                item = addrbook_remove_group( abf, item );

                                if( item ) {

                                        addritem_free_item_group( item );

                                        item = NULL;

                                }

                                /* Remove group from parent node */

                                gtk_ctree_remove_node( ctree, nd );

                        }

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

                                ItemPerson *item = ( ItemPerson * ) aio;

                                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();

                gtk_ctree_select( ctree, addrbook.opened);

                return;

        }

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

                /* Items inside groups */

                GList *node;

                node = _addressListSelection_;

                while( node ) {

                        AddrItemObject *aio = node->data;

                        node = g_list_next( node );

                        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_print_item_email( item, stdout );

                                        addritem_free_item_email( item );

                                        item = NULL;

                                }

                        }

                }

                addressbook_list_select_clear();

                gtk_ctree_select( ctree, addrbook.opened);

                return;

        }

        gtk_ctree_node_set_row_data( clist, nodeList, NULL );

        gtk_ctree_remove_node( clist, nodeList );

        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( 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) 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_menubar_set_sensitive( gboolean sensitive ) {

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

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

#ifdef USE_JPILOT

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

#endif

#ifdef USE_LDAP

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

#endif

        menu_set_sensitive( addrbook.menu_factory, "/File/Edit",        sensitive );

        menu_set_sensitive( addrbook.menu_factory, "/File/Delete",      sensitive );

        menu_set_sensitive( addrbook.menu_factory, "/Address/New Address", sensitive );

        menu_set_sensitive( addrbook.menu_factory, "/Address/New Group",   sensitive );

        menu_set_sensitive( addrbook.menu_factory, "/Address/New Folder",  sensitive );

        gtk_widget_set_sensitive( addrbook.reg_btn, sensitive );

        gtk_widget_set_sensitive( addrbook.del_btn, sensitive );

}

static void addressbook_menuitem_set_sensitive( AddressObject *obj, GtkCTreeNode *node ) {

        gboolean canEdit = FALSE;

        gboolean canAdd = FALSE;

        gboolean canEditTr = TRUE;

        gboolean editAddress = FALSE;

        AddressTypeControlItem *atci = NULL;

        AddressDataSource *ds = NULL;

        AddressInterface *iface = NULL;

        if( obj == NULL ) return;

        if( obj->type == ADDR_INTERFACE ) {

                AdapterInterface *adapter = ADAPTER_INTERFACE(obj);

                iface = adapter->interface;

                if( iface ) {

                        if( iface->haveLibrary ) {

                                /* Enable appropriate File / New command */

                                atci = adapter->atci;

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

                        }

                }

                canEditTr = FALSE;

        }

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

                AdapterDSource *ads = ADAPTER_DSOURCE(obj);

                ds = ads->dataSource;

                iface = ds->interface;

                if( ! iface->readOnly ) {

                        canAdd = canEdit = editAddress = TRUE;

                }

                if( ! iface->haveLibrary ) {

                        canAdd = canEdit = editAddress = FALSE;

                }

        }

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

                ds = addressbook_find_datasource( addrbook.treeSelected );

                if( ds ) {

                        iface = ds->interface;

                        if( ! iface->readOnly ) {

                                canAdd = editAddress = TRUE;

                        }

                }

        }

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

                ds = addressbook_find_datasource( addrbook.treeSelected );

                if( ds ) {

                        iface = ds->interface;

                        if( ! iface->readOnly ) {

                                editAddress = TRUE;

                        }

                }

        }

        if( addrbook.listSelected == NULL ) canEdit = FALSE;

        /* Enable add */

        menu_set_sensitive( addrbook.menu_factory, "/Address/New Address", editAddress );

        menu_set_sensitive( addrbook.menu_factory, "/Address/New Group",   canAdd );

        menu_set_sensitive( addrbook.menu_factory, "/Address/New Folder",  canAdd );

        gtk_widget_set_sensitive( addrbook.reg_btn, editAddress );

        /* Enable edit */

        menu_set_sensitive( addrbook.menu_factory, "/Address/Edit",   canEdit );

        menu_set_sensitive( addrbook.menu_factory, "/Address/Delete", canEdit );

        gtk_widget_set_sensitive( addrbook.del_btn, canEdit );

        menu_set_sensitive( addrbook.menu_factory, "/File/Edit",      canEditTr );

        menu_set_sensitive( addrbook.menu_factory, "/File/Delete",    canEditTr );

}

static void addressbook_tree_selected(GtkCTree *ctree, GtkCTreeNode *node,

                                      gint column, gpointer data)

{

        AddressObject *obj = NULL;

        AdapterDSource *ads = NULL;

        AddressDataSource *ds = NULL;

        ItemFolder *rootFolder = NULL;

        addrbook.treeSelected = node;

        addrbook.listSelected = NULL;

        addressbook_status_show( "" );

        if( addrbook.entry != NULL ) gtk_entry_set_text(GTK_ENTRY(addrbook.entry), "");

        if( addrbook.clist ) gtk_clist_clear( GTK_CLIST(addrbook.clist) );

        if( node ) obj = gtk_ctree_node_get_row_data( ctree, node );

        if( obj == NULL ) return;

        addrbook.opened = node;

        if( obj->type == ADDR_DATASOURCE ) {

                /* Read from file */

                static gboolean tVal = TRUE;

                ads = ADAPTER_DSOURCE(obj);

                if( ads == NULL ) return;

                ds = ads->dataSource;

                if( ds == NULL ) return;                

                if( addrindex_ds_get_modify_flag( ds ) ) {

                        addrindex_ds_read_data( ds );

                }

                if( ! addrindex_ds_get_read_flag( ds ) ) {

                        addrindex_ds_read_data( ds );

                }

                addressbook_ds_show_message( ds );

                if( ! addrindex_ds_get_access_flag( ds ) ) {

                        /* Remove existing folders and groups */

                        gtk_clist_freeze( GTK_CLIST(ctree) );

                        addressbook_tree_remove_children( ctree, node );

                        gtk_clist_thaw( GTK_CLIST(ctree) );

                        /* Load folders into the tree */

                        rootFolder = addrindex_ds_get_root_folder( ds );

                        if( ds->type == ADDR_IF_JPILOT ) {

                                addressbook_node_add_folder( node, ds, rootFolder, ADDR_CATEGORY );

                        }

                        else {

                                addressbook_node_add_folder( node, ds, rootFolder, ADDR_ITEM_FOLDER );

                        }

                        addrindex_ds_set_access_flag( ds, &tVal );

                        gtk_ctree_expand( ctree, node );

                }

        }

        /* Update address list */

        addressbook_set_clist( obj );

        /* Setup main menu selections */

        addressbook_menubar_set_sensitive( FALSE );

        addressbook_menuitem_set_sensitive( obj, node );

        addressbook_list_select_clear();

}

static void addressbook_list_selected(GtkCList *clist, gint row, gint column,

                                      GdkEvent *event, gpointer data)

{

        if (event && event->type == GDK_2BUTTON_PRESS) {

                /* Handle double click */

                if (prefs_common.add_address_by_click &&

                    addrbook.target_compose)

                        addressbook_to_clicked(NULL, GINT_TO_POINTER(COMPOSE_ENTRY_TO));

                else

                        addressbook_edit_address_cb(NULL, 0, NULL);

        }

}

#if 0

static void addressbook_list_select_show() {

        GList *node = _addressListSelection_;

        gchar *addr = NULL;

        printf( "show selection...>>>\n" );

        while( node != NULL ) {

                AddressObject *obj = ( AddressObject * ) node->data;

                if( obj ) {

                        printf( "- %d : '%s'\n", obj->type, obj->name );

                        if( obj->type == ADDR_ITEM_GROUP ) {

                                ItemGroup *group = ( ItemGroup * ) obj;

                                GList *node = group->listEMail;

                                while( node ) {

                                        ItemEMail *email = node->data;

                                        addr = addressbook_format_address( ( AddressObject * ) email );

                                        if( addr ) {

                                                printf( "\tgrp >%s<\n", addr );

                                                g_free( addr );

                                        }

                                        node = g_list_next( node );

                                }

                        }

                        else {

                                addr = addressbook_format_address( obj );

                                if( addr ) {

                                        printf( "\t>%s<\n", addr );

                                        g_free( addr );

                                }

                        }

                }

                else {

                        printf( "- NULL" );

                }

                node = g_list_next( node );

        }

        printf( "show selection...<<<\n" );

}

#endif

static void addressbook_list_select_clear() {

        if( _addressListSelection_ ) {

                g_list_free( _addressListSelection_ );

        }

        _addressListSelection_ = NULL;

}

static void addressbook_list_select_add( AddressObject *obj ) {

        if( obj ) {

                if(     obj->type == ADDR_ITEM_PERSON ||

                        obj->type == ADDR_ITEM_EMAIL ||

                        obj->type == ADDR_ITEM_GROUP ) {

                        if( ! g_list_find( _addressListSelection_, obj ) ) {

                                _addressListSelection_ = g_list_append( _addressListSelection_, obj );

                        }

                }

        }

        /* addressbook_list_select_show(); */

}

static void addressbook_list_select_remove( AddressObject *obj ) {

        if( obj == NULL ) return;

        if( _addressListSelection_ ) {

                _addressListSelection_ = g_list_remove(        _addressListSelection_, obj );

        }

        /* addressbook_list_select_show(); */

}

static void addressbook_list_row_selected( GtkCTree *clist, GtkCTreeNode *node, gint column, gpointer data ) {

        GtkEntry *entry = GTK_ENTRY(addrbook.entry);

        AddressObject *obj = NULL;

        AddressObject *pobj = NULL;

        AdapterDSource *ads = NULL;

        AddressInterface *iface = NULL;

        AddressDataSource *ds = NULL;

        gboolean canEdit = FALSE;

        gboolean canDelete = FALSE;

        gtk_entry_set_text( entry, "" );

        addrbook.listSelected = node;

        obj = gtk_ctree_node_get_row_data( clist, node );

        if( obj != NULL ) {

                /* printf( "list select: %d : '%s'\n", obj->type, obj->name ); */

                addressbook_list_select_add( obj );

        }

        pobj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), addrbook.treeSelected );

        if( pobj == NULL ) return;

        menu_set_insensitive_all( GTK_MENU_SHELL(addrbook.list_popup) );

        if( pobj->type == ADDR_DATASOURCE ) {

                ads = ADAPTER_DSOURCE(pobj);

                ds = ads->dataSource;

                iface = ds->interface;

                if( ! iface->readOnly ) {

                        canEdit = TRUE;

                        menu_set_sensitive( addrbook.list_factory, "/New Address", TRUE );

                        menu_set_sensitive( addrbook.list_factory, "/New Folder", TRUE );

                        menu_set_sensitive( addrbook.list_factory, "/New Group", TRUE );

                        gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );

                }

        }

        else if( pobj->type != ADDR_INTERFACE ) {

                ds = addressbook_find_datasource( addrbook.treeSelected );

                iface = ds->interface;

                if( ! iface->readOnly ) {

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

                                canEdit = TRUE;

                                menu_set_sensitive( addrbook.list_factory, "/New Address", TRUE );

                                gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );

                        }

                        if( pobj->type == ADDR_ITEM_FOLDER ) {

                                canEdit = TRUE;

                                menu_set_sensitive( addrbook.list_factory, "/New Folder", TRUE );

                                menu_set_sensitive( addrbook.list_factory, "/New Group", TRUE );

                        }

                }

        }

        if( obj == NULL ) canEdit = FALSE;

        canDelete = canEdit;

        if( GTK_CLIST(clist)->selection && GTK_CLIST(clist)->selection->next ) canEdit = FALSE;

        menu_set_sensitive( addrbook.list_factory, "/Edit",   canEdit );

        menu_set_sensitive( addrbook.list_factory, "/Delete", canDelete );

        menu_set_sensitive( addrbook.menu_factory, "/Address/Edit",   canEdit );

        menu_set_sensitive( addrbook.menu_factory, "/Address/Delete", canDelete );

        gtk_widget_set_sensitive( addrbook.del_btn, canDelete );

}

static void addressbook_list_row_unselected( GtkCTree *ctree, GtkCTreeNode *node, gint column, gpointer data ) {

        AddressObject *obj;

        obj = gtk_ctree_node_get_row_data( ctree, node );

        if( obj != NULL ) {

                /* g_print( "list unselect: %d : '%s'\n", obj->type, obj->name ); */

                addressbook_list_select_remove( obj );

        }

}

static void addressbook_entry_gotfocus( GtkWidget *widget ) {

        gtk_editable_select_region( GTK_EDITABLE(addrbook.entry), 0, -1 );

}

static gboolean addressbook_list_button_pressed(GtkWidget *widget,

                                                GdkEventButton *event,

                                                gpointer data)

{

        if( ! event ) return FALSE;

        if( event->button == 3 ) {

                gtk_menu_popup( GTK_MENU(addrbook.list_popup), NULL, NULL, NULL, NULL,

                       event->button, event->time );

        }

        return FALSE;

}

static gboolean addressbook_list_button_released(GtkWidget *widget,