src/addressbook.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2003 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <gdk/gdkkeysyms.h>
  28 #include <gtk/gtkwindow.h>
  29 #include <gtk/gtksignal.h>
  30 #include <gtk/gtkvbox.h>
  31 #include <gtk/gtkscrolledwindow.h>
  32 #include <gtk/gtkhpaned.h>
  33 #include <gtk/gtkhbox.h>
  34 #include <gtk/gtklabel.h>
  35 #include <gtk/gtkentry.h>
  36 #include <gtk/gtkctree.h>
  37 #include <gtk/gtkclist.h>
  38 #include <gtk/gtktable.h>
  39 #include <gtk/gtkhbbox.h>
  40 #include <gtk/gtkbutton.h>
  41 #include <gtk/gtkmenu.h>
  42 #include <gtk/gtkmenuitem.h>
  43 #include <gtk/gtkitemfactory.h>
  44 #include <string.h>
  45 #include <setjmp.h>
  46
  47 #include "intl.h"
  48 #include "main.h"
  49 #include "addressbook.h"
  50 #include "manage_window.h"
  51 #include "prefs_common.h"
  52 #include "alertpanel.h"
  53 #include "inputdialog.h"
  54 #include "menu.h"
  55 #include "stock_pixmap.h"
  56 #include "xml.h"
  57 #include "prefs_gtk.h"
  58 #include "procmime.h"
  59 #include "utils.h"
  60 #include "gtkutils.h"
  61 #include "codeconv.h"
  62 #include "about.h"
  63 #include "addr_compl.h"
  64
  65 #include "mgutils.h"
  66 #include "addressitem.h"
  67 #include "addritem.h"
  68 #include "addrcache.h"
  69 #include "addrbook.h"
  70 #include "addrindex.h"
  71 #include "addressadd.h"
  72 #include "vcard.h"
  73 #include "editvcard.h"
  74 #include "editgroup.h"
  75 #include "editaddress.h"
  76 #include "editbook.h"
  77 #include "importldif.h"
  78 #include "importmutt.h"
  79 #include "importpine.h"
  80
  81 #ifdef USE_JPILOT
  82 #include "jpilot.h"
  83 #include "editjpilot.h"
  84 #endif
  85
  86 #ifdef USE_LDAP
  87 #include <pthread.h>
  88 #include "syldap.h"
  89 #include "editldap.h"
  90
  91 #define ADDRESSBOOK_LDAP_BUSYMSG "Busy"
  92 #endif
  93
  94 #include "addrselect.h"
  95 #include "addrclip.h"
  96 #include "addrgather.h"
  97 #include "adbookbase.h"
  98 #include "exphtmldlg.h"
  99
 100 typedef enum
 101 {
 102         COL_NAME        = 0,
 103         COL_ADDRESS     = 1,
 104         COL_REMARKS     = 2
 105 } AddressBookColumnPos;
 106
 107 #define N_COLS  3
 108 #define COL_NAME_WIDTH          164
 109 #define COL_ADDRESS_WIDTH       156
 110
 111 #define COL_FOLDER_WIDTH        170
 112 #define ADDRESSBOOK_WIDTH       640
 113 #define ADDRESSBOOK_HEIGHT      360
 114
 115 #define ADDRESSBOOK_MSGBUF_SIZE 2048
 116
 117 static GdkPixmap *folderxpm;
 118 static GdkBitmap *folderxpmmask;
 119 static GdkPixmap *folderopenxpm;
 120 static GdkBitmap *folderopenxpmmask;
 121 static GdkPixmap *groupxpm;
 122 static GdkBitmap *groupxpmmask;
 123 static GdkPixmap *interfacexpm;
 124 static GdkBitmap *interfacexpmmask;
 125 static GdkPixmap *bookxpm;
 126 static GdkBitmap *bookxpmmask;
 127 static GdkPixmap *addressxpm;
 128 static GdkBitmap *addressxpmmask;
 129 static GdkPixmap *vcardxpm;
 130 static GdkBitmap *vcardxpmmask;
 131 static GdkPixmap *jpilotxpm;
 132 static GdkBitmap *jpilotxpmmask;
 133 static GdkPixmap *categoryxpm;
 134 static GdkBitmap *categoryxpmmask;
 135 static GdkPixmap *ldapxpm;
 136 static GdkBitmap *ldapxpmmask;
 137
 138 /* Message buffer */
 139 static gchar addressbook_msgbuf[ ADDRESSBOOK_MSGBUF_SIZE ];
 140
 141 /* Address list selection */
 142 static AddrSelectList *_addressSelect_ = NULL;
 143 static AddressClipboard *_clipBoard_ = NULL;
 144
 145 /* Address index file and interfaces */
 146 static AddressIndex *_addressIndex_ = NULL;
 147 static GList *_addressInterfaceList_ = NULL;
 148 static GList *_addressIFaceSelection_ = NULL;
 149 #define ADDRESSBOOK_IFACE_SELECTION "1/y,3/y,4/y,2/n"
 150
 151 static AddressBook_win addrbook;
 152
 153 static GHashTable *_addressBookTypeHash_ = NULL;
 154 static GList *_addressBookTypeList_ = NULL;
 155
 156 static void addressbook_create                  (void);
 157 static gint addressbook_close                   (void);
 158 static void addressbook_button_set_sensitive    (void);
 159
 160 /* callback functions */
 161 static void addressbook_del_clicked             (GtkButton      *button,
 162                                                  gpointer        data);
 163 static void addressbook_reg_clicked             (GtkButton      *button,
 164                                                  gpointer        data);
 165 static void addressbook_to_clicked              (GtkButton      *button,
 166                                                  gpointer        data);
 167 static void addressbook_lup_clicked             (GtkButton      *button,
 168                                                  gpointer       data);
 169
 170 static void addressbook_tree_selected           (GtkCTree       *ctree,
 171                                                  GtkCTreeNode   *node,
 172                                                  gint            column,
 173                                                  gpointer        data);
 174 static void addressbook_list_selected           (GtkCList       *clist,
 175                                                  gint            row,
 176                                                  gint            column,
 177                                                  GdkEvent       *event,
 178                                                  gpointer        data);
 179 static void addressbook_list_row_selected       (GtkCTree       *clist,
 180                                                  GtkCTreeNode   *node,
 181                                                  gint            column,
 182                                                  gpointer        data);
 183 static void addressbook_list_row_unselected     (GtkCTree       *clist,
 184                                                  GtkCTreeNode   *node,
 185                                                  gint            column,
 186                                                  gpointer        data);
 187 static void addressbook_person_expand_node      (GtkCTree       *ctree,
 188                                                  GList          *node,
 189                                                  gpointer       *data );
 190 static void addressbook_person_collapse_node    (GtkCTree       *ctree,
 191                                                  GList          *node,
 192                                                  gpointer       *data );
 193 static void addressbook_entry_gotfocus          (GtkWidget      *widget);
 194
 195 #if 0
 196 static void addressbook_entry_changed           (GtkWidget      *widget);
 197 #endif
 198
 199 static void addressbook_list_button_pressed     (GtkWidget      *widget,
 200                                                  GdkEventButton *event,
 201                                                  gpointer        data);
 202 static void addressbook_list_button_released    (GtkWidget      *widget,
 203                                                  GdkEventButton *event,
 204                                                  gpointer        data);
 205 static void addressbook_tree_button_pressed     (GtkWidget      *ctree,
 206                                                  GdkEventButton *event,
 207                                                  gpointer        data);
 208 static void addressbook_tree_button_released    (GtkWidget      *ctree,
 209                                                  GdkEventButton *event,
 210                                                  gpointer        data);
 211 static void addressbook_popup_close             (GtkMenuShell   *menu_shell,
 212                                                  gpointer        data);
 213
 214 static void addressbook_new_folder_cb           (gpointer        data,
 215                                                  guint           action,
 216                                                  GtkWidget      *widget);
 217 static void addressbook_new_group_cb            (gpointer        data,
 218                                                  guint           action,
 219                                                  GtkWidget      *widget);
 220 static void addressbook_treenode_edit_cb        (gpointer        data,
 221                                                  guint           action,
 222                                                  GtkWidget      *widget);
 223 static void addressbook_treenode_delete_cb      (gpointer        data,
 224                                                  guint           action,
 225                                                  GtkWidget      *widget);
 226
 227 static void addressbook_change_node_name        (GtkCTreeNode   *node,
 228                                                  const gchar    *name);
 229
 230 static void addressbook_new_address_cb          (gpointer        data,
 231                                                  guint           action,
 232                                                  GtkWidget      *widget);
 233 static void addressbook_edit_address_cb         (gpointer        data,
 234                                                  guint           action,
 235                                                  GtkWidget      *widget);
 236 static void addressbook_delete_address_cb       (gpointer        data,
 237                                                  guint           action,
 238                                                  GtkWidget      *widget);
 239
 240 static void close_cb                            (gpointer        data,
 241                                                  guint           action,
 242                                                  GtkWidget      *widget);
 243 static void addressbook_file_save_cb            (gpointer        data,
 244                                                  guint           action,
 245                                                  GtkWidget      *widget);
 246
 247 /* Data source edit stuff */
 248 static void addressbook_new_book_cb             (gpointer        data,
 249                                                  guint           action,
 250                                                  GtkWidget      *widget);
 251 static void addressbook_new_vcard_cb            (gpointer        data,
 252                                                  guint           action,
 253                                                  GtkWidget      *widget);
 254
 255 #ifdef USE_JPILOT
 256 static void addressbook_new_jpilot_cb           (gpointer        data,
 257                                                  guint           action,
 258                                                  GtkWidget      *widget);
 259 #endif
 260
 261 #ifdef USE_LDAP
 262 static void addressbook_new_ldap_cb             (gpointer        data,
 263                                                  guint           action,
 264                                                  GtkWidget      *widget);
 265 #endif
 266
 267 static void addressbook_set_clist               (AddressObject  *obj);
 268
 269 static void addressbook_load_tree               (void);
 270 void addressbook_read_file                      (void);
 271
 272 static GtkCTreeNode *addressbook_add_object     (GtkCTreeNode   *node,
 273                                                  AddressObject  *obj);
 274 static void addressbook_treenode_remove_item    ( void );
 275
 276 static AddressDataSource *addressbook_find_datasource
 277                                                 (GtkCTreeNode   *node );
 278
 279 static AddressBookFile *addressbook_get_book_file(void);
 280
 281 static GtkCTreeNode *addressbook_node_add_folder
 282                                                 (GtkCTreeNode   *node,
 283                                                 AddressDataSource *ds,
 284                                                 ItemFolder      *itemFolder,
 285                                                 AddressObjectType otype);
 286 static GtkCTreeNode *addressbook_node_add_group (GtkCTreeNode   *node,
 287                                                 AddressDataSource *ds,
 288                                                 ItemGroup       *itemGroup);
 289 static void addressbook_tree_remove_children    (GtkCTree       *ctree,
 290                                                 GtkCTreeNode    *parent);
 291 static void addressbook_move_nodes_up           (GtkCTree       *ctree,
 292                                                 GtkCTreeNode    *node);
 293 static GtkCTreeNode *addressbook_find_group_node (GtkCTreeNode  *parent,
 294                                                    ItemGroup    *group);
 295 static void key_pressed                         (GtkWidget      *widget,
 296                                                  GdkEventKey    *event,
 297                                                  gpointer        data);
 298 static gint addressbook_treenode_compare_func   (GtkCList       *clist,
 299                                                  gconstpointer   ptr1,
 300                                                  gconstpointer   ptr2);
 301 static gint addressbook_list_compare_func       (GtkCList       *clist,
 302                                                  gconstpointer   ptr1,
 303                                                  gconstpointer   ptr2);
 304
 305 #ifdef USE_LDAP
 306 static void addressbook_ldap_show_message       (SyldapServer *server);
 307 #endif
 308
 309 /* LUT's and IF stuff */
 310 static void addressbook_free_treenode           ( gpointer data );
 311 AddressTypeControlItem *addrbookctl_lookup      (gint            ot);
 312 AddressTypeControlItem *addrbookctl_lookup_iface(AddressIfType   ifType);
 313
 314 void addrbookctl_build_map                      (GtkWidget      *window);
 315 void addrbookctl_build_iflist                   (void);
 316 AdapterInterface *addrbookctl_find_interface    (AddressIfType   ifType);
 317 void addrbookctl_build_ifselect                 (void);
 318
 319 static void addrbookctl_free_interface          (AdapterInterface *adapter);
 320 static void addrbookctl_free_datasource         (AdapterDSource   *adapter);
 321 static void addrbookctl_free_folder             (AdapterFolder    *adapter);
 322 static void addrbookctl_free_group              (AdapterGroup     *adapter);
 323
 324 static void addressbook_list_select_clear       ( void );
 325 static void addressbook_list_select_add         ( AddrItemObject    *aio,
 326                                                   AddressDataSource *ds );
 327 static void addressbook_list_select_remove      ( AddrItemObject    *aio );
 328
 329 static void addressbook_import_ldif_cb          ( void );
 330 static void addressbook_import_mutt_cb          ( void );
 331 static void addressbook_import_pine_cb          ( void );
 332 static void addressbook_export_html_cb          ( void );
 333 static void addressbook_clip_cut_cb             ( void );
 334 static void addressbook_clip_copy_cb            ( void );
 335 static void addressbook_clip_paste_cb           ( void );
 336 static void addressbook_clip_paste_address_cb   ( void );
 337 static void addressbook_treenode_cut_cb         ( void );
 338 static void addressbook_treenode_copy_cb        ( void );
 339 static void addressbook_treenode_paste_cb       ( void );
 340
 341 static GtkItemFactoryEntry addressbook_entries[] =
 342 {
 343         {N_("/_File"),                  NULL,           NULL, 0, "<Branch>"},
 344         {N_("/_File/New _Book"),        "<alt>B",       addressbook_new_book_cb,        0, NULL},
 345         {N_("/_File/New _vCard"),       "<alt>D",       addressbook_new_vcard_cb,       0, NULL},
 346 #ifdef USE_JPILOT
 347         {N_("/_File/New _JPilot"),      "<alt>J",       addressbook_new_jpilot_cb,      0, NULL},
 348 #endif
 349 #ifdef USE_LDAP
 350         {N_("/_File/New _Server"),      "<alt>S",       addressbook_new_ldap_cb,        0, NULL},
 351 #endif
 352         {N_("/_File/---"),              NULL,           NULL, 0, "<Separator>"},
 353         {N_("/_File/_Edit"),            NULL,           addressbook_treenode_edit_cb,   0, NULL},
 354         {N_("/_File/_Delete"),          NULL,           addressbook_treenode_delete_cb, 0, NULL},
 355         {N_("/_File/---"),              NULL,           NULL, 0, "<Separator>"},
 356         {N_("/_File/_Save"),            "<alt>S",       addressbook_file_save_cb,       0, NULL},
 357         {N_("/_File/_Close"),           "<alt>W",       close_cb,                       0, NULL},
 358         {N_("/_Edit"),                  NULL,           NULL, 0, "<Branch>"},
 359         {N_("/_Edit/C_ut"),             "<ctl>X",       addressbook_clip_cut_cb,        0, NULL},
 360         {N_("/_Edit/_Copy"),            "<ctl>C",       addressbook_clip_copy_cb,       0, NULL},
 361         {N_("/_Edit/_Paste"),           "<ctl>V",       addressbook_clip_paste_cb,      0, NULL},
 362         {N_("/_Edit/---"),              NULL,           NULL, 0, "<Separator>"},
 363         {N_("/_Edit/Pa_ste Address"),   NULL,           addressbook_clip_paste_address_cb, 0, NULL},
 364         {N_("/_Address"),               NULL,           NULL, 0, "<Branch>"},
 365         {N_("/_Address/New _Address"),  "<alt>N",       addressbook_new_address_cb,     0, NULL},
 366         {N_("/_Address/New _Group"),    "<alt>G",       addressbook_new_group_cb,       0, NULL},
 367         {N_("/_Address/New _Folder"),   "<alt>R",       addressbook_new_folder_cb,      0, NULL},
 368         {N_("/_Address/---"),           NULL,           NULL, 0, "<Separator>"},
 369         {N_("/_Address/_Edit"),         "<alt>Return",  addressbook_edit_address_cb,    0, NULL},
 370         {N_("/_Address/_Delete"),       NULL,           addressbook_delete_address_cb,  0, NULL},
 371         {N_("/_Tools/---"),             NULL,           NULL, 0, "<Separator>"},
 372         {N_("/_Tools/Import _LDIF file..."), NULL,      addressbook_import_ldif_cb,     0, NULL},
 373         {N_("/_Tools/Import M_utt file..."), NULL,      addressbook_import_mutt_cb,     0, NULL},
 374         {N_("/_Tools/Import _Pine file..."), NULL,      addressbook_import_pine_cb,     0, NULL},
 375         {N_("/_Tools/---"),             NULL,           NULL, 0, "<Separator>"},
 376         {N_("/_Tools/Export _HTML..."), NULL,           addressbook_export_html_cb,     0, NULL},
 377         {N_("/_Help"),                  NULL,           NULL, 0, "<LastBranch>"},
 378         {N_("/_Help/_About"),           NULL,           about_show, 0, NULL}
 379 };
 380
 381 static GtkItemFactoryEntry addressbook_tree_popup_entries[] =
 382 {
 383         {N_("/New _Address"),   NULL, addressbook_new_address_cb, 0, NULL},
 384         {N_("/New _Group"),     NULL, addressbook_new_group_cb,   0, NULL},
 385         {N_("/New _Folder"),    NULL, addressbook_new_folder_cb,  0, NULL},
 386         {N_("/---"),            NULL, NULL, 0, "<Separator>"},
 387         {N_("/_Edit"),          NULL, addressbook_treenode_edit_cb,   0, NULL},
 388         {N_("/_Delete"),        NULL, addressbook_treenode_delete_cb, 0, NULL},
 389         {N_("/---"),            NULL, NULL, 0, "<Separator>"},
 390         {N_("/C_ut"),           NULL, addressbook_treenode_cut_cb,    0, NULL},
 391         {N_("/_Copy"),          NULL, addressbook_treenode_copy_cb,   0, NULL},
 392         {N_("/_Paste"),         NULL, addressbook_treenode_paste_cb,  0, NULL}
 393 };
 394
 395 static GtkItemFactoryEntry addressbook_list_popup_entries[] =
 396 {
 397         {N_("/New _Address"),   NULL, addressbook_new_address_cb,    0, NULL},
 398         {N_("/New _Group"),     NULL, addressbook_new_group_cb,      0, NULL},
 399         {N_("/New _Folder"),    NULL, addressbook_new_folder_cb,     0, NULL},
 400         {N_("/---"),            NULL, NULL, 0, "<Separator>"},
 401         {N_("/_Edit"),          NULL, addressbook_edit_address_cb,   0, NULL},
 402         {N_("/_Delete"),        NULL, addressbook_delete_address_cb, 0, NULL},
 403         {N_("/---"),            NULL, NULL, 0, "<Separator>"},
 404         {N_("/C_ut"),           NULL, addressbook_clip_cut_cb,       0, NULL},
 405         {N_("/_Copy"),          NULL, addressbook_clip_copy_cb,      0, NULL},
 406         {N_("/_Paste"),         NULL, addressbook_clip_paste_cb,     0, NULL},
 407         {N_("/---"),            NULL, NULL, 0, "<Separator>"},
 408         {N_("/Pa_ste Address"), NULL, addressbook_clip_paste_address_cb,     0, NULL}
 409 };
 410
 411 /**
 412  * Structure of error message table.
 413  */
 414 typedef struct _ErrMsgTableEntry ErrMsgTableEntry;
 415 struct _ErrMsgTableEntry {
 416         gint    code;
 417         gchar   *description;
 418 };
 419
 420 static gchar *_errMsgUnknown_ = N_( "Unknown" );
 421
 422 /**
 423  * Lookup table of error messages for general errors. Note that a NULL
 424  * description signifies the end of the table.
 425  */
 426 static ErrMsgTableEntry _lutErrorsGeneral_[] = {
 427         { MGU_SUCCESS,          N_("Success") },
 428         { MGU_BAD_ARGS,         N_("Bad arguments") },
 429         { MGU_NO_FILE,          N_("File not specified") },
 430         { MGU_OPEN_FILE,        N_("Error opening file") },
 431         { MGU_ERROR_READ,       N_("Error reading file") },
 432         { MGU_EOF,              N_("End of file encountered") },
 433         { MGU_OO_MEMORY,        N_("Error allocating memory") },
 434         { MGU_BAD_FORMAT,       N_("Bad file format") },
 435         { MGU_ERROR_WRITE,      N_("Error writing to file") },
 436         { MGU_OPEN_DIRECTORY,   N_("Error opening directory") },
 437         { MGU_NO_PATH,          N_("No path specified") },
 438         { 0,                    NULL }
 439 };
 440
 441 #ifdef USE_LDAP
 442 /**
 443  * Lookup table of error messages for LDAP errors.
 444  */
 445 static ErrMsgTableEntry _lutErrorsLDAP_[] = {
 446         { MGU_SUCCESS,          N_("Success") },
 447         { MGU_LDAP_CONNECT,     N_("Error connecting to LDAP server") },
 448         { MGU_LDAP_INIT,        N_("Error initializing LDAP") },
 449         { MGU_LDAP_BIND,        N_("Error binding to LDAP server") },
 450         { MGU_LDAP_SEARCH,      N_("Error searching LDAP database") },
 451         { MGU_LDAP_TIMEOUT,     N_("Timeout performing LDAP operation") },
 452         { MGU_LDAP_CRITERIA,    N_("Error in LDAP search criteria") },
 453         { MGU_LDAP_CRITERIA,    N_("Error in LDAP search criteria") },
 454         { MGU_LDAP_NOENTRIES,   N_("No LDAP entries found for search criteria") },
 455         { 0,                    NULL }
 456 };
 457 #endif
 458
 459 /**
 460  * Lookup message for specified error code.
 461  * \param lut  Lookup table.
 462  * \param code Code to lookup.
 463  * \return Description associated to code.
 464  */
 465 static gchar *addressbook_err2string( ErrMsgTableEntry lut[], gint code ) {
 466         gchar *desc = NULL;
 467         ErrMsgTableEntry entry;
 468         gint i;
 469
 470         for( i = 0; ; i++ ) {
 471                 entry = lut[ i ];
 472                 if( entry.description == NULL ) break;
 473                 if( entry.code == code ) {
 474                         desc = entry.description;
 475                         break;
 476                 }
 477         }
 478         if( ! desc ) {
 479                 desc = _errMsgUnknown_;
 480         }
 481         return desc;
 482 }
 483
 484 void addressbook_open(Compose *target)
 485 {
 486         /* Initialize all static members */
 487         if( _clipBoard_ == NULL ) {
 488                 _clipBoard_ = addrclip_create();
 489         }
 490         if( _addressIndex_ != NULL ) {
 491                 addrclip_set_index( _clipBoard_, _addressIndex_ );
 492         }
 493         if( _addressSelect_ == NULL ) {
 494                 _addressSelect_ = addrselect_list_create();
 495         }
 496         if (!addrbook.window) {
 497                 addressbook_read_file();
 498                 addressbook_create();
 499                 addressbook_load_tree();
 500                 gtk_ctree_select(GTK_CTREE(addrbook.ctree),
 501                                  GTK_CTREE_NODE(GTK_CLIST(addrbook.ctree)->row_list));
 502         }
 503         else {
 504                 gtk_widget_hide(addrbook.window);
 505         }
 506
 507         gtk_widget_show_all(addrbook.window);
 508         addressbook_set_target_compose(target);
 509 }
 510
 511 void addressbook_destroy() {
 512         /* Free up address stuff */
 513         if( _addressSelect_ != NULL ) {
 514                 addrselect_list_free( _addressSelect_ );
 515         }
 516         if( _clipBoard_ != NULL ) {
 517                 addrclip_free( _clipBoard_ );
 518         }
 519         if( _addressIndex_ != NULL ) {
 520                addrindex_free_index( _addressIndex_ );
 521         }
 522         _addressSelect_ = NULL;
 523         _clipBoard_ = NULL;
 524         _addressIndex_ = NULL;
 525 }
 526
 527 void addressbook_set_target_compose(Compose *target)
 528 {
 529         addrbook.target_compose = target;
 530         addressbook_button_set_sensitive();
 531 }
 532
 533 Compose *addressbook_get_target_compose(void)
 534 {
 535         return addrbook.target_compose;
 536 }
 537
 538 void addressbook_refresh(void)
 539 {
 540         if (addrbook.window) {
 541                 if (addrbook.treeSelected) {
 542                         gtk_ctree_select(GTK_CTREE(addrbook.ctree),
 543                                          addrbook.treeSelected);
 544                 }
 545         }
 546         addressbook_export_to_file();
 547 }
 548
 549 /*
 550 * Create the address book widgets. The address book contains two CTree widgets: the
 551 * address index tree on the left and the address list on the right.
 552 *
 553 * The address index tree displays a hierarchy of interfaces and groups. Each node in
 554 * this tree is linked to an address Adapter. Adapters have been created for interfaces,
 555 * data sources and folder objects.
 556 *
 557 * The address list displays group, person and email objects. These items are linked
 558 * directly to ItemGroup, ItemPerson and ItemEMail objects inside the address book data
 559 * sources.
 560 *
 561 * In the tradition of MVC architecture, the data stores have been separated from the
 562 * GUI components. The addrindex.c file provides the interface to all data stores.
 563 */
 564 static void addressbook_create(void)
 565 {
 566         GtkWidget *window;
 567         GtkWidget *vbox;
 568         GtkWidget *menubar;
 569         GtkWidget *vbox2;
 570         GtkWidget *ctree_swin;
 571         GtkWidget *ctree;
 572         GtkWidget *clist_vbox;
 573         GtkWidget *clist_swin;
 574         GtkWidget *clist;
 575         GtkWidget *paned;
 576         GtkWidget *hbox;
 577         GtkWidget *label;
 578         GtkWidget *entry;
 579         GtkWidget *statusbar;
 580         GtkWidget *hbbox;
 581         GtkWidget *hsbox;
 582         GtkWidget *del_btn;
 583         GtkWidget *reg_btn;
 584         GtkWidget *lup_btn;
 585         GtkWidget *to_btn;
 586         GtkWidget *cc_btn;
 587         GtkWidget *bcc_btn;
 588         GtkWidget *tree_popup;
 589         GtkWidget *list_popup;
 590         GtkItemFactory *tree_factory;
 591         GtkItemFactory *list_factory;
 592         GtkItemFactory *menu_factory;
 593         gint n_entries;
 594         GList *nodeIf;
 595
 596         gchar *titles[N_COLS];
 597         gchar *text;
 598         gint i;
 599
 600         debug_print("Creating addressbook window...\n");
 601
 602         titles[COL_NAME]    = _("Name");
 603         titles[COL_ADDRESS] = _("E-Mail address");
 604         titles[COL_REMARKS] = _("Remarks");
 605
 606         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 607         gtk_window_set_title(GTK_WINDOW(window), _("Address book"));
 608         gtk_widget_set_usize(window, ADDRESSBOOK_WIDTH, ADDRESSBOOK_HEIGHT);
 609         gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, TRUE);
 610         gtk_window_set_wmclass(GTK_WINDOW(window), "addressbook", "Sylpheed");
 611         gtk_widget_realize(window);
 612
 613         gtk_signal_connect(GTK_OBJECT(window), "delete_event",
 614                            GTK_SIGNAL_FUNC(addressbook_close), NULL);
 615         gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
 616                            GTK_SIGNAL_FUNC(key_pressed), NULL);
 617         MANAGE_WINDOW_SIGNALS_CONNECT(window);
 618
 619         vbox = gtk_vbox_new(FALSE, 0);
 620         gtk_container_add(GTK_CONTAINER(window), vbox);
 621
 622         n_entries = sizeof(addressbook_entries) /
 623                 sizeof(addressbook_entries[0]);
 624         menubar = menubar_create(window, addressbook_entries, n_entries,
 625                                  "<AddressBook>", NULL);
 626         gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
 627         menu_factory = gtk_item_factory_from_widget(menubar);
 628
 629         vbox2 = gtk_vbox_new(FALSE, 4);
 630         gtk_container_set_border_width(GTK_CONTAINER(vbox2), BORDER_WIDTH);
 631         gtk_box_pack_start(GTK_BOX(vbox), vbox2, TRUE, TRUE, 0);
 632
 633         ctree_swin = gtk_scrolled_window_new(NULL, NULL);
 634         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ctree_swin),
 635                                        GTK_POLICY_AUTOMATIC,
 636                                        GTK_POLICY_ALWAYS);
 637         gtk_widget_set_usize(ctree_swin, COL_FOLDER_WIDTH + 40, -1);
 638
 639         /* Address index */
 640         ctree = gtk_ctree_new(1, 0);
 641         gtk_container_add(GTK_CONTAINER(ctree_swin), ctree);
 642         gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE);
 643         gtk_clist_set_column_width(GTK_CLIST(ctree), 0, COL_FOLDER_WIDTH);
 644         gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_DOTTED);
 645         gtk_ctree_set_expander_style(GTK_CTREE(ctree),
 646                                      GTK_CTREE_EXPANDER_SQUARE);
 647         gtk_ctree_set_indent(GTK_CTREE(ctree), CTREE_INDENT);
 648         gtk_clist_set_compare_func(GTK_CLIST(ctree),
 649                                    addressbook_treenode_compare_func);
 650
 651         gtk_signal_connect(GTK_OBJECT(ctree), "tree_select_row",
 652                            GTK_SIGNAL_FUNC(addressbook_tree_selected), NULL);
 653         gtk_signal_connect(GTK_OBJECT(ctree), "button_press_event",
 654                            GTK_SIGNAL_FUNC(addressbook_tree_button_pressed),
 655                            NULL);
 656         gtk_signal_connect(GTK_OBJECT(ctree), "button_release_event",
 657                            GTK_SIGNAL_FUNC(addressbook_tree_button_released),
 658                            NULL);
 659
 660         clist_vbox = gtk_vbox_new(FALSE, 4);
 661
 662         clist_swin = gtk_scrolled_window_new(NULL, NULL);
 663         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin),
 664                                        GTK_POLICY_AUTOMATIC,
 665                                        GTK_POLICY_ALWAYS);
 666         gtk_box_pack_start(GTK_BOX(clist_vbox), clist_swin, TRUE, TRUE, 0);
 667
 668         /* Address list */
 669         clist = gtk_ctree_new_with_titles(N_COLS, 0, titles);
 670         gtk_container_add(GTK_CONTAINER(clist_swin), clist);
 671         gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_EXTENDED);
 672         gtk_ctree_set_line_style(GTK_CTREE(clist), GTK_CTREE_LINES_NONE);
 673         gtk_ctree_set_expander_style(GTK_CTREE(clist), GTK_CTREE_EXPANDER_SQUARE);
 674         gtk_ctree_set_indent(GTK_CTREE(clist), CTREE_INDENT);
 675         gtk_clist_set_column_width(GTK_CLIST(clist), COL_NAME,
 676                                    COL_NAME_WIDTH);
 677         gtk_clist_set_column_width(GTK_CLIST(clist), COL_ADDRESS,
 678                                    COL_ADDRESS_WIDTH);
 679         gtk_clist_set_compare_func(GTK_CLIST(clist),
 680                                    addressbook_list_compare_func);
 681
 682         for (i = 0; i < N_COLS; i++)
 683                 GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[i].button,
 684                                        GTK_CAN_FOCUS);
 685
 686         gtk_signal_connect(GTK_OBJECT(clist), "tree_select_row",
 687                            GTK_SIGNAL_FUNC(addressbook_list_row_selected), NULL);
 688         gtk_signal_connect(GTK_OBJECT(clist), "tree_unselect_row",
 689                            GTK_SIGNAL_FUNC(addressbook_list_row_unselected), NULL);
 690         gtk_signal_connect(GTK_OBJECT(clist), "button_press_event",
 691                            GTK_SIGNAL_FUNC(addressbook_list_button_pressed),
 692                            NULL);
 693         gtk_signal_connect(GTK_OBJECT(clist), "button_release_event",
 694                            GTK_SIGNAL_FUNC(addressbook_list_button_released),
 695                            NULL);
 696         gtk_signal_connect(GTK_OBJECT(clist), "select_row",
 697                            GTK_SIGNAL_FUNC(addressbook_list_selected), NULL);
 698         gtk_signal_connect(GTK_OBJECT(clist), "tree_expand",
 699                            GTK_SIGNAL_FUNC(addressbook_person_expand_node), NULL );
 700         gtk_signal_connect(GTK_OBJECT(clist), "tree_collapse",
 701                            GTK_SIGNAL_FUNC(addressbook_person_collapse_node), NULL );
 702
 703         hbox = gtk_hbox_new(FALSE, 4);
 704         gtk_box_pack_start(GTK_BOX(clist_vbox), hbox, FALSE, FALSE, 0);
 705
 706         label = gtk_label_new(_("Name:"));
 707         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 708
 709         entry = gtk_entry_new();
 710         gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
 711
 712         address_completion_register_entry(GTK_ENTRY(entry));
 713         gtk_signal_connect(GTK_OBJECT(entry), "focus_in_event",
 714                            GTK_SIGNAL_FUNC(addressbook_entry_gotfocus), NULL);
 715
 716 #if 0
 717         gtk_signal_connect(GTK_OBJECT(entry), "changed",
 718                            GTK_SIGNAL_FUNC(addressbook_entry_changed), NULL);
 719 #endif
 720
 721         paned = gtk_hpaned_new();
 722         gtk_box_pack_start(GTK_BOX(vbox2), paned, TRUE, TRUE, 0);
 723         gtk_paned_add1(GTK_PANED(paned), ctree_swin);
 724         gtk_paned_add2(GTK_PANED(paned), clist_vbox);
 725
 726         /* Status bar */
 727         hsbox = gtk_hbox_new(FALSE, 0);
 728         gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
 729         statusbar = gtk_statusbar_new();
 730         gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
 731
 732         /* Button panel */
 733         hbbox = gtk_hbutton_box_new();
 734         gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);
 735         gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 2);
 736         gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
 737
 738         del_btn = gtk_button_new_with_label(_("Delete"));
 739         GTK_WIDGET_SET_FLAGS(del_btn, GTK_CAN_DEFAULT);
 740         gtk_box_pack_start(GTK_BOX(hbbox), del_btn, TRUE, TRUE, 0);
 741         reg_btn = gtk_button_new_with_label(_("Add"));
 742         GTK_WIDGET_SET_FLAGS(reg_btn, GTK_CAN_DEFAULT);
 743         gtk_box_pack_start(GTK_BOX(hbbox), reg_btn, TRUE, TRUE, 0);
 744         lup_btn = gtk_button_new_with_label(_("Lookup"));
 745         GTK_WIDGET_SET_FLAGS(lup_btn, GTK_CAN_DEFAULT);
 746         gtk_box_pack_start(GTK_BOX(hbbox), lup_btn, TRUE, TRUE, 0);
 747
 748         gtk_signal_connect(GTK_OBJECT(del_btn), "clicked",
 749                            GTK_SIGNAL_FUNC(addressbook_del_clicked), NULL);
 750         gtk_signal_connect(GTK_OBJECT(reg_btn), "clicked",
 751                            GTK_SIGNAL_FUNC(addressbook_reg_clicked), NULL);
 752         gtk_signal_connect(GTK_OBJECT(lup_btn), "clicked",
 753                            GTK_SIGNAL_FUNC(addressbook_lup_clicked), NULL);
 754
 755         to_btn = gtk_button_new_with_label
 756                 (prefs_common.trans_hdr ? _("To:") : "To:");
 757         GTK_WIDGET_SET_FLAGS(to_btn, GTK_CAN_DEFAULT);
 758         gtk_box_pack_start(GTK_BOX(hbbox), to_btn, TRUE, TRUE, 0);
 759         cc_btn = gtk_button_new_with_label
 760                 (prefs_common.trans_hdr ? _("Cc:") : "Cc:");
 761         GTK_WIDGET_SET_FLAGS(cc_btn, GTK_CAN_DEFAULT);
 762         gtk_box_pack_start(GTK_BOX(hbbox), cc_btn, TRUE, TRUE, 0);
 763         bcc_btn = gtk_button_new_with_label
 764                 (prefs_common.trans_hdr ? _("Bcc:") : "Bcc:");
 765         GTK_WIDGET_SET_FLAGS(bcc_btn, GTK_CAN_DEFAULT);
 766         gtk_box_pack_start(GTK_BOX(hbbox), bcc_btn, TRUE, TRUE, 0);
 767
 768         gtk_signal_connect(GTK_OBJECT(to_btn), "clicked",
 769                            GTK_SIGNAL_FUNC(addressbook_to_clicked),
 770                            GINT_TO_POINTER(COMPOSE_TO));
 771         gtk_signal_connect(GTK_OBJECT(cc_btn), "clicked",
 772                            GTK_SIGNAL_FUNC(addressbook_to_clicked),
 773                            GINT_TO_POINTER(COMPOSE_CC));
 774         gtk_signal_connect(GTK_OBJECT(bcc_btn), "clicked",
 775                            GTK_SIGNAL_FUNC(addressbook_to_clicked),
 776                            GINT_TO_POINTER(COMPOSE_BCC));
 777
 778         /* Build icons for interface */
 779         stock_pixmap_gdk( window, STOCK_PIXMAP_INTERFACE,
 780                           &interfacexpm, &interfacexpmmask );
 781
 782         /* Build control tables */
 783         addrbookctl_build_map(window);
 784         addrbookctl_build_iflist();
 785         addrbookctl_build_ifselect();
 786
 787         /* Add each interface into the tree as a root level folder */
 788         nodeIf = _addressInterfaceList_;
 789         while( nodeIf ) {
 790                 AdapterInterface *adapter = nodeIf->data;
 791                 AddressInterface *iface = adapter->interface;
 792                 nodeIf = g_list_next(nodeIf);
 793
 794                 if(iface->useInterface) {
 795                         AddressTypeControlItem *atci = adapter->atci;
 796                         text = atci->displayName;
 797                         adapter->treeNode =
 798                                 gtk_ctree_insert_node( GTK_CTREE(ctree),
 799                                         NULL, NULL, &text, FOLDER_SPACING,
 800                                         interfacexpm, interfacexpmmask,
 801                                         interfacexpm, interfacexpmmask,
 802                                         FALSE, FALSE );
 803                         menu_set_sensitive( menu_factory, atci->menuCommand, adapter->haveLibrary );
 804                         gtk_ctree_node_set_row_data_full(
 805                                 GTK_CTREE(ctree), adapter->treeNode, adapter,
 806                                 addressbook_free_treenode );
 807                 }
 808         }
 809
 810         /* Popup menu */
 811         n_entries = sizeof(addressbook_tree_popup_entries) /
 812                 sizeof(addressbook_tree_popup_entries[0]);
 813         tree_popup = menu_create_items(addressbook_tree_popup_entries,
 814                                        n_entries,
 815                                        "<AddressBookTree>", &tree_factory,
 816                                        NULL);
 817         gtk_signal_connect(GTK_OBJECT(tree_popup), "selection_done",
 818                            GTK_SIGNAL_FUNC(addressbook_popup_close), NULL);
 819         n_entries = sizeof(addressbook_list_popup_entries) /
 820                 sizeof(addressbook_list_popup_entries[0]);
 821         list_popup = menu_create_items(addressbook_list_popup_entries,
 822                                        n_entries,
 823                                        "<AddressBookList>", &list_factory,
 824                                        NULL);
 825
 826         addrbook.window  = window;
 827         addrbook.menubar = menubar;
 828         addrbook.ctree   = ctree;
 829         addrbook.clist   = clist;
 830         addrbook.entry   = entry;
 831         addrbook.statusbar = statusbar;
 832         addrbook.status_cid = gtk_statusbar_get_context_id(
 833                         GTK_STATUSBAR(statusbar), "Addressbook Window" );
 834
 835         addrbook.del_btn = del_btn;
 836         addrbook.reg_btn = reg_btn;
 837         addrbook.lup_btn = lup_btn;
 838         addrbook.to_btn  = to_btn;
 839         addrbook.cc_btn  = cc_btn;
 840         addrbook.bcc_btn = bcc_btn;
 841
 842         addrbook.tree_popup   = tree_popup;
 843         addrbook.list_popup   = list_popup;
 844         addrbook.tree_factory = tree_factory;
 845         addrbook.list_factory = list_factory;
 846         addrbook.menu_factory = menu_factory;
 847
 848         addrbook.listSelected = NULL;
 849         address_completion_start(window);
 850         gtk_widget_show_all(window);
 851
 852 }
 853
 854 static gint addressbook_close( void ) {
 855         gtk_widget_hide(addrbook.window);
 856         addressbook_export_to_file();
 857         return TRUE;
 858 }
 859
 860 static void addressbook_status_show( gchar *msg ) {
 861         if( addrbook.statusbar != NULL ) {
 862                 gtk_statusbar_pop(
 863                         GTK_STATUSBAR(addrbook.statusbar),
 864                         addrbook.status_cid );
 865                 if( msg ) {
 866                         gtk_statusbar_push(
 867                                 GTK_STATUSBAR(addrbook.statusbar),
 868                                 addrbook.status_cid, msg );
 869                 }
 870         }
 871 }
 872
 873 static void addressbook_ds_status_message( AddressDataSource *ds, gchar *msg ) {
 874         *addressbook_msgbuf = '\0';
 875         if( ds ) {
 876                 gchar *name;
 877
 878                 name = addrindex_ds_get_name( ds );
 879                 g_snprintf( addressbook_msgbuf, sizeof(addressbook_msgbuf),
 880                             "%s: %s", name, msg );
 881         }
 882         else {
 883                 g_snprintf( addressbook_msgbuf, sizeof(addressbook_msgbuf),
 884                             "%s", msg );
 885         }
 886         addressbook_status_show( addressbook_msgbuf );
 887 }
 888
 889 static void addressbook_ds_show_message( AddressDataSource *ds ) {
 890         gint retVal;
 891         gchar *name;
 892         gchar *desc;
 893         *addressbook_msgbuf = '\0';
 894         if( ds ) {
 895                 name = addrindex_ds_get_name( ds );
 896                 retVal = addrindex_ds_get_status_code( ds );
 897                 if( retVal == MGU_SUCCESS ) {
 898                         g_snprintf( addressbook_msgbuf,
 899                                     sizeof(addressbook_msgbuf), "%s", name );
 900                 }
 901                 else {
 902                         desc = addressbook_err2string( _lutErrorsGeneral_, retVal );
 903                         g_snprintf( addressbook_msgbuf,
 904                             sizeof(addressbook_msgbuf), "%s: %s", name, desc );
 905                         }
 906         }
 907         addressbook_status_show( addressbook_msgbuf );
 908 }
 909
 910 static void addressbook_button_set_sensitive(void)
 911 {
 912         gboolean to_sens  = FALSE;
 913         gboolean cc_sens  = FALSE;
 914         gboolean bcc_sens = FALSE;
 915
 916         if (!addrbook.window) return;
 917
 918         if (addrbook.target_compose) {
 919                 to_sens = TRUE;
 920                 cc_sens = TRUE;
 921 #ifndef CLAWS
 922                 if (addrbook.target_compose->use_bcc)
 923 #endif
 924                         bcc_sens = TRUE;
 925         }
 926
 927         gtk_widget_set_sensitive(addrbook.to_btn, to_sens);
 928         gtk_widget_set_sensitive(addrbook.cc_btn, cc_sens);
 929         gtk_widget_set_sensitive(addrbook.bcc_btn, bcc_sens);
 930 }
 931
 932 /*
 933 * Delete one or more objects from address list.
 934 */
 935 static void addressbook_del_clicked(GtkButton *button, gpointer data)
 936 {
 937         GtkCTree *clist = GTK_CTREE(addrbook.clist);
 938         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
 939         AddressObject *pobj;
 940         AdapterDSource *ads = NULL;
 941         GtkCTreeNode *nodeList;
 942         gboolean procFlag;
 943         AlertValue aval;
 944         AddressBookFile *abf = NULL;
 945         AddressDataSource *ds = NULL;
 946         AddressInterface *iface;
 947         AddrItemObject *aio;
 948         AddrSelectItem *item;
 949         GList *list, *node;
 950
 951         pobj = gtk_ctree_node_get_row_data(ctree, addrbook.opened );
 952         g_return_if_fail(pobj != NULL);
 953
 954         /* Test whether anything selected for deletion */
 955         nodeList = addrbook.listSelected;
 956         aio = gtk_ctree_node_get_row_data( clist, nodeList );
 957         if( aio == NULL) return;
 958         ds = addressbook_find_datasource( addrbook.treeSelected );
 959         if( ds == NULL ) return;
 960
 961         /* Test for read only */
 962         iface = ds->interface;
 963         if( iface->readOnly ) {
 964                 alertpanel( _("Delete address(es)"),
 965                         _("This address data is readonly and cannot be deleted."),
 966                         _("Close"), NULL, NULL );
 967                 return;
 968         }
 969
 970         /* Test whether Ok to proceed */
 971         procFlag = FALSE;
 972         if( pobj->type == ADDR_DATASOURCE ) {
 973                 ads = ADAPTER_DSOURCE(pobj);
 974                 if( ads->subType == ADDR_BOOK ) procFlag = TRUE;
 975         }
 976         else if( pobj->type == ADDR_ITEM_FOLDER ) {
 977                 procFlag = TRUE;
 978         }
 979         else if( pobj->type == ADDR_ITEM_GROUP ) {
 980                 procFlag = TRUE;
 981         }
 982         if( ! procFlag ) return;
 983         abf = ds->rawDataSource;
 984         if( abf == NULL ) return;
 985
 986         /* Confirm deletion */
 987         aval = alertpanel( _("Delete address(es)"),
 988                         _("Really delete the address(es)?"),
 989                         _("Yes"), _("No"), NULL );
 990         if( aval != G_ALERTDEFAULT ) return;
 991
 992         /* Process deletions */
 993         if( pobj->type == ADDR_DATASOURCE || pobj->type == ADDR_ITEM_FOLDER ) {
 994                 /* Items inside folders */
 995                 list = addrselect_get_list( _addressSelect_ );
 996                 node = list;
 997                 while( node ) {
 998                         item = node->data;
 999                         node = g_list_next( node );
1000                         aio = ( AddrItemObject * ) item->addressItem;
1001                         if( aio->type == ADDR_ITEM_GROUP ) {
1002                                 ItemGroup *item = ( ItemGroup * ) aio;
1003                                 GtkCTreeNode *nd = NULL;
1004
1005                                 nd = addressbook_find_group_node( addrbook.opened, item );
1006                                 item = addrbook_remove_group( abf, item );
1007                                 if( item ) {
1008                                         addritem_free_item_group( item );
1009                                 }
1010                                 /* Remove group from parent node */
1011                                 gtk_ctree_remove_node( ctree, nd );
1012                         }
1013                         else if( aio->type == ADDR_ITEM_PERSON ) {
1014                                 ItemPerson *item = ( ItemPerson * ) aio;
1015                                 item = addrbook_remove_person( abf, item );
1016                                 if( item ) {
1017                                         addritem_free_item_person( item );
1018                                 }
1019                         }
1020                         else if( aio->type == ADDR_ITEM_EMAIL ) {
1021                                 ItemEMail *item = ( ItemEMail * ) aio;
1022                                 ItemPerson *person = ( ItemPerson * ) ADDRITEM_PARENT(item);
1023                                 item = addrbook_person_remove_email( abf, person, item );
1024                                 if( item ) {
1025                                         addritem_free_item_email( item );
1026                                 }
1027                         }
1028                 }
1029                 g_list_free( list );
1030                 addressbook_list_select_clear();
1031                 gtk_ctree_select( ctree, addrbook.opened);
1032                 return;
1033         }
1034         else if( pobj->type == ADDR_ITEM_GROUP ) {
1035                 /* Items inside groups */
1036                 list = addrselect_get_list( _addressSelect_ );
1037                 node = list;
1038                 while( node ) {
1039                         item = node->data;
1040                         node = g_list_next( node );
1041                         aio = ( AddrItemObject * ) item->addressItem;
1042                         if( aio->type == ADDR_ITEM_EMAIL ) {
1043                                 ItemEMail *item = ( ItemEMail * ) aio;
1044                                 ItemPerson *person = ( ItemPerson * ) ADDRITEM_PARENT(item);
1045                                 item = addrbook_person_remove_email( abf, person, item );
1046                                 if( item ) {
1047                                         addritem_free_item_email( item );
1048                                 }
1049                         }
1050                 }
1051                 g_list_free( list );
1052                 addressbook_list_select_clear();
1053                 gtk_ctree_select( ctree, addrbook.opened);
1054                 return;
1055         }
1056
1057         gtk_ctree_node_set_row_data( clist, nodeList, NULL );
1058         gtk_ctree_remove_node( clist, nodeList );
1059
1060 }
1061
1062 static void addressbook_reg_clicked(GtkButton *button, gpointer data)
1063 {
1064         addressbook_new_address_cb( NULL, 0, NULL );
1065 }
1066
1067 gchar *addressbook_format_address( AddrItemObject * aio ) {
1068         gchar *buf = NULL;
1069         gchar *name = NULL;
1070         gchar *address = NULL;
1071
1072         if( aio->type == ADDR_ITEM_EMAIL ) {
1073                 ItemPerson *person = NULL;
1074                 ItemEMail *email = ( ItemEMail * ) aio;
1075
1076                 person = ( ItemPerson * ) ADDRITEM_PARENT(email);
1077                 if( email->address ) {
1078                         if( ADDRITEM_NAME(email) ) {
1079                                 name = ADDRITEM_NAME(email);
1080                                 if( *name == '\0' ) {
1081                                         name = ADDRITEM_NAME(person);
1082                                 }
1083                         }
1084                         else if( ADDRITEM_NAME(person) ) {
1085                                 name = ADDRITEM_NAME(person);
1086                         }
1087                         else {
1088                                 buf = g_strdup( email->address );
1089                         }
1090                         address = email->address;
1091                 }
1092         }
1093         else if( aio->type == ADDR_ITEM_PERSON ) {
1094                 ItemPerson *person = ( ItemPerson * ) aio;
1095                 GList *node = person->listEMail;
1096
1097                 name = ADDRITEM_NAME(person);
1098                 if( node ) {
1099                         ItemEMail *email = ( ItemEMail * ) node->data;
1100                         address = email->address;
1101                 }
1102         }
1103         if( address ) {
1104                 if( name && name[0] != '\0' ) {
1105                         if( strchr_with_skip_quote( name, '"', ',' ) )
1106                                 buf = g_strdup_printf( "\"%s\" <%s>", name, address );
1107                         else
1108                                 buf = g_strdup_printf( "%s <%s>", name, address );
1109                 }
1110                 else {
1111                         buf = g_strdup( address );
1112                 }
1113         }
1114
1115         return buf;
1116 }
1117
1118 static void addressbook_to_clicked(GtkButton *button, gpointer data)
1119 {
1120         GList *list, *node;
1121         Compose *compose;
1122         AddrSelectItem *item;
1123         AddrItemObject *aio;
1124         gchar *addr;
1125
1126         compose = addrbook.target_compose;
1127         if( ! compose ) return;
1128
1129         /* Nothing selected, but maybe there is something in text entry */
1130         addr = gtk_entry_get_text( GTK_ENTRY( addrbook.entry) );
1131         if ( addr ) {
1132                 compose_entry_append(
1133                         compose, addr, (ComposeEntryType)data );
1134         }
1135
1136         /* Select from address list */
1137         list = addrselect_get_list( _addressSelect_ );
1138         node = list;
1139         while( node ) {
1140                 item = node->data;
1141                 node = g_list_next( node );
1142                 aio = item->addressItem;
1143                 if( aio->type == ADDR_ITEM_PERSON ||
1144                     aio->type == ADDR_ITEM_EMAIL ) {
1145                         addr = addressbook_format_address( aio );
1146                         compose_entry_append(
1147                                 compose, addr, (ComposeEntryType) data );
1148                         g_free( addr );
1149                 }
1150                 else if( aio->type == ADDR_ITEM_GROUP ) {
1151                         ItemGroup *group = ( ItemGroup * ) aio;
1152                         GList *nodeMail = group->listEMail;
1153                         while( nodeMail ) {
1154                                 ItemEMail *email = nodeMail->data;
1155
1156                                 addr = addressbook_format_address(
1157                                                 ( AddrItemObject * ) email );
1158                                 compose_entry_append(
1159                                         compose, addr, (ComposeEntryType) data );
1160                                 g_free( addr );
1161                                 nodeMail = g_list_next( nodeMail );
1162                         }
1163                 }
1164         }
1165         g_list_free( list );
1166 }
1167
1168 static void addressbook_menubar_set_sensitive( gboolean sensitive ) {
1169         menu_set_sensitive( addrbook.menu_factory, "/File/Edit",   sensitive );
1170         menu_set_sensitive( addrbook.menu_factory, "/File/Delete", sensitive );
1171
1172         menu_set_sensitive( addrbook.menu_factory, "/Edit/Cut",    sensitive );
1173         menu_set_sensitive( addrbook.menu_factory, "/Edit/Copy",   sensitive );
1174         menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste",  sensitive );
1175         menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste Address",  sensitive );
1176
1177         menu_set_sensitive( addrbook.menu_factory, "/Address/New Address", sensitive );
1178         menu_set_sensitive( addrbook.menu_factory, "/Address/New Group",   sensitive );
1179         menu_set_sensitive( addrbook.menu_factory, "/Address/New Folder",  sensitive );
1180         gtk_widget_set_sensitive( addrbook.reg_btn, sensitive );
1181         gtk_widget_set_sensitive( addrbook.del_btn, sensitive );
1182 }
1183
1184 static void addressbook_menuitem_set_sensitive( AddressObject *obj, GtkCTreeNode *node ) {
1185         gboolean canEdit = FALSE;
1186         gboolean canAdd = FALSE;
1187         gboolean canEditTr = TRUE;
1188         gboolean editAddress = FALSE;
1189         gboolean canExport = TRUE;
1190         AddressTypeControlItem *atci = NULL;
1191         AddressDataSource *ds = NULL;
1192         AddressInterface *iface = NULL;
1193
1194         if( obj == NULL ) return;
1195         if( obj->type == ADDR_INTERFACE ) {
1196                 AdapterInterface *adapter = ADAPTER_INTERFACE(obj);
1197                 iface = adapter->interface;
1198                 if( iface ) {
1199                         if( iface->haveLibrary ) {
1200                                 /* Enable appropriate File / New command */
1201                                 atci = adapter->atci;
1202                                 menu_set_sensitive( addrbook.menu_factory, atci->menuCommand, TRUE );
1203                         }
1204                 }
1205                 canEditTr = canExport = FALSE;
1206         }
1207         else if( obj->type == ADDR_DATASOURCE ) {
1208                 AdapterDSource *ads = ADAPTER_DSOURCE(obj);
1209                 ds = ads->dataSource;
1210                 iface = ds->interface;
1211                 if( ! iface->readOnly ) {
1212                         canAdd = canEdit = editAddress = TRUE;
1213                 }
1214                 if( ! iface->haveLibrary ) {
1215                         canAdd = canEdit = editAddress = canExport = FALSE;
1216                 }
1217         }
1218         else if( obj->type == ADDR_ITEM_FOLDER ) {
1219                 ds = addressbook_find_datasource( addrbook.treeSelected );
1220                 if( ds ) {
1221                         iface = ds->interface;
1222                         if( iface->readOnly ) {
1223                                 canEditTr = FALSE;
1224                         }
1225                         else {
1226                                 canAdd = editAddress = TRUE;
1227                         }
1228                 }
1229         }
1230         else if( obj->type == ADDR_ITEM_GROUP ) {
1231                 ds = addressbook_find_datasource( addrbook.treeSelected );
1232                 if( ds ) {
1233                         iface = ds->interface;
1234                         if( ! iface->readOnly ) {
1235                                 editAddress = TRUE;
1236                         }
1237                 }
1238         }
1239
1240         if( addrbook.listSelected == NULL ) canEdit = FALSE;
1241
1242         /* Enable add */
1243         menu_set_sensitive( addrbook.menu_factory, "/Address/New Address", editAddress );
1244         menu_set_sensitive( addrbook.menu_factory, "/Address/New Group",   canAdd );
1245         menu_set_sensitive( addrbook.menu_factory, "/Address/New Folder",  canAdd );
1246         gtk_widget_set_sensitive( addrbook.reg_btn, editAddress );
1247
1248         /* Enable edit */
1249         menu_set_sensitive( addrbook.menu_factory, "/Address/Edit",   canEdit );
1250         menu_set_sensitive( addrbook.menu_factory, "/Address/Delete", canEdit );
1251         gtk_widget_set_sensitive( addrbook.del_btn, canEdit );
1252
1253         menu_set_sensitive( addrbook.menu_factory, "/File/Edit",      canEditTr );
1254         menu_set_sensitive( addrbook.menu_factory, "/File/Delete",    canEditTr );
1255
1256         /* Export data */
1257         menu_set_sensitive( addrbook.menu_factory, "/Tools/Export HTML...", canExport );
1258 }
1259
1260 static void addressbook_tree_selected(GtkCTree *ctree, GtkCTreeNode *node,
1261                                       gint column, gpointer data)
1262 {
1263         AddressObject *obj = NULL;
1264         AdapterDSource *ads = NULL;
1265         AddressDataSource *ds = NULL;
1266         ItemFolder *rootFolder = NULL;
1267
1268         addrbook.treeSelected = node;
1269         addrbook.listSelected = NULL;
1270         addressbook_status_show( "" );
1271         if( addrbook.entry != NULL ) gtk_entry_set_text(GTK_ENTRY(addrbook.entry), "");
1272
1273         if( addrbook.clist ) gtk_clist_clear( GTK_CLIST(addrbook.clist) );
1274         if( node ) obj = gtk_ctree_node_get_row_data( ctree, node );
1275         if( obj == NULL ) return;
1276
1277         addrbook.opened = node;
1278
1279         if( obj->type == ADDR_DATASOURCE ) {
1280                 /* Read from file */
1281                 static gboolean tVal = TRUE;
1282
1283                 ads = ADAPTER_DSOURCE(obj);
1284                 if( ads == NULL ) return;
1285                 ds = ads->dataSource;
1286                 if( ds == NULL ) return;
1287
1288                 if( addrindex_ds_get_modify_flag( ds ) ) {
1289                         addrindex_ds_read_data( ds );
1290                 }
1291
1292                 if( ! addrindex_ds_get_read_flag( ds ) ) {
1293                         addrindex_ds_read_data( ds );
1294                 }
1295                 addressbook_ds_show_message( ds );
1296
1297                 if( ! addrindex_ds_get_access_flag( ds ) ) {
1298                         /* Remove existing folders and groups */
1299                         gtk_clist_freeze( GTK_CLIST(ctree) );
1300                         addressbook_tree_remove_children( ctree, node );
1301                         gtk_clist_thaw( GTK_CLIST(ctree) );
1302
1303                         /* Load folders into the tree */
1304                         rootFolder = addrindex_ds_get_root_folder( ds );
1305                         if( ds->type == ADDR_IF_JPILOT ) {
1306                                 addressbook_node_add_folder( node, ds, rootFolder, ADDR_CATEGORY );
1307                         }
1308                         else {
1309                                 addressbook_node_add_folder( node, ds, rootFolder, ADDR_ITEM_FOLDER );
1310                         }
1311                         addrindex_ds_set_access_flag( ds, &tVal );
1312                         gtk_ctree_expand( ctree, node );
1313                 }
1314         }
1315
1316         /* Update address list */
1317         addressbook_set_clist( obj );
1318
1319         /* Setup main menu selections */
1320         addressbook_menubar_set_sensitive( FALSE );
1321         addressbook_menuitem_set_sensitive( obj, node );
1322
1323         addressbook_list_select_clear();
1324 }
1325
1326 /*
1327 * Setup address list popup menu.
1328 * Enter: pobj  Parent address object in address tree.
1329 *        obj   Address object in address list.
1330 */
1331 static void addressbook_list_menu_setup( void ) {
1332         GtkCTree *clist = NULL;
1333         AddressObject *pobj = NULL;
1334         AddressObject *obj = NULL;
1335         AdapterDSource *ads = NULL;
1336         AddressInterface *iface = NULL;
1337         AddressDataSource *ds = NULL;
1338         gboolean canEdit = FALSE;
1339         gboolean canDelete = FALSE;
1340         gboolean canCut = FALSE;
1341         gboolean canCopy = FALSE;
1342         gboolean canPaste = FALSE;
1343
1344         pobj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), addrbook.treeSelected );
1345         if( pobj == NULL ) return;
1346
1347         clist = GTK_CTREE(addrbook.clist);
1348         obj = gtk_ctree_node_get_row_data( clist, addrbook.listSelected );
1349         if( obj == NULL ) canEdit = FALSE;
1350
1351         menu_set_insensitive_all( GTK_MENU_SHELL(addrbook.list_popup) );
1352
1353         if( pobj->type == ADDR_DATASOURCE ) {
1354                 ads = ADAPTER_DSOURCE(pobj);
1355                 ds = ads->dataSource;
1356                 iface = ds->interface;
1357                 if( ! iface->readOnly ) {
1358                         menu_set_sensitive( addrbook.list_factory, "/New Address", TRUE );
1359                         menu_set_sensitive( addrbook.list_factory, "/New Folder", TRUE );
1360                         menu_set_sensitive( addrbook.list_factory, "/New Group", TRUE );
1361                         gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1362                         if( ! addrclip_is_empty( _clipBoard_ ) ) canPaste = TRUE;
1363                         if( ! addrselect_test_empty( _addressSelect_ ) ) canCut = TRUE;
1364                         if( obj ) canEdit = TRUE;
1365                 }
1366         }
1367         else if( pobj->type != ADDR_INTERFACE ) {
1368                 ds = addressbook_find_datasource( addrbook.treeSelected );
1369                 iface = ds->interface;
1370                 if( ! iface->readOnly ) {
1371                         if( pobj->type == ADDR_ITEM_FOLDER || pobj->type == ADDR_ITEM_GROUP ) {
1372                                 menu_set_sensitive( addrbook.list_factory, "/New Address", TRUE );
1373                                 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1374                                 if( obj ) canEdit = TRUE;
1375                         }
1376                         if( pobj->type == ADDR_ITEM_FOLDER ) {
1377                                 menu_set_sensitive( addrbook.list_factory, "/New Folder", TRUE );
1378                                 menu_set_sensitive( addrbook.list_factory, "/New Group", TRUE );
1379                                 if( obj ) canEdit = TRUE;
1380                         }
1381                         if( ! addrclip_is_empty( _clipBoard_ ) ) canPaste = TRUE;
1382                         if( ! addrselect_test_empty( _addressSelect_ ) ) canCut = TRUE;
1383                 }
1384         }
1385         if( ! addrselect_test_empty( _addressSelect_ ) ) canCopy = TRUE;
1386
1387         canDelete = canEdit;
1388         canDelete = canEdit;
1389
1390         /* Disable edit if more than one row selected */
1391         if( GTK_CLIST(clist)->selection && GTK_CLIST(clist)->selection->next ) canEdit = FALSE;
1392
1393         menu_set_sensitive( addrbook.list_factory, "/Edit",   canEdit );
1394         menu_set_sensitive( addrbook.list_factory, "/Delete", canDelete );
1395
1396         menu_set_sensitive( addrbook.list_factory, "/Cut",           canCut );
1397         menu_set_sensitive( addrbook.list_factory, "/Copy",          canCopy );
1398         menu_set_sensitive( addrbook.list_factory, "/Paste",         canPaste );
1399         menu_set_sensitive( addrbook.list_factory, "/Paste Address", canPaste );
1400
1401         menu_set_sensitive( addrbook.menu_factory, "/Edit/Cut",           canCut );
1402         menu_set_sensitive( addrbook.menu_factory, "/Edit/Copy",          canCopy );
1403         menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste",         canPaste );
1404         menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste Address", canPaste );
1405
1406         menu_set_sensitive( addrbook.tree_factory, "/Cut",           canCut );
1407         menu_set_sensitive( addrbook.tree_factory, "/Copy",          canCopy );
1408         menu_set_sensitive( addrbook.tree_factory, "/Paste",         canPaste );
1409
1410         menu_set_sensitive( addrbook.menu_factory, "/Address/Edit",   canEdit );
1411         menu_set_sensitive( addrbook.menu_factory, "/Address/Delete", canDelete );
1412
1413         gtk_widget_set_sensitive( addrbook.del_btn, canDelete );
1414 }
1415
1416 static void addressbook_list_selected(GtkCList *clist, gint row, gint column,
1417                                       GdkEvent *event, gpointer data)
1418 {
1419         if (event && event->type == GDK_2BUTTON_PRESS) {
1420                 /* Handle double click */
1421                 if (prefs_common.add_address_by_click &&
1422                     addrbook.target_compose)
1423                         addressbook_to_clicked(NULL, NULL);
1424                 else
1425                         addressbook_edit_address_cb(NULL, 0, NULL);
1426         }
1427 }
1428
1429 /*
1430  * Add list of items into tree node below specified tree node.
1431  * Enter: treeNode  Tree node.
1432  *        ds        Data source.
1433  *        listItems List of items.
1434  */
1435 static void addressbook_treenode_add_list(
1436         GtkCTreeNode *treeNode, AddressDataSource *ds, GList *listItems )
1437 {
1438         GList *node;
1439
1440         node = listItems;
1441         while( node ) {
1442                 AddrItemObject *aio;
1443                 GtkCTreeNode *nn;
1444
1445                 aio = node->data;
1446                 if( ADDRESS_OBJECT_TYPE(aio) == ITEMTYPE_GROUP ) {
1447                         ItemGroup *group;
1448
1449                         group = ( ItemGroup * ) aio;
1450                         nn = addressbook_node_add_group( treeNode, ds, group );
1451                 }
1452                 else if( ADDRESS_OBJECT_TYPE(aio) == ITEMTYPE_FOLDER ) {
1453                         ItemFolder *folder;
1454
1455                         folder = ( ItemFolder * ) aio;
1456                         nn = addressbook_node_add_folder(
1457                                 treeNode, ds, folder, ADDR_ITEM_FOLDER );
1458                 }
1459                 node = g_list_next( node );
1460         }
1461 }
1462
1463 /*
1464 * Cut from address list widget.
1465 */
1466 static void addressbook_clip_cut_cb( void ) {
1467         _clipBoard_->cutFlag = TRUE;
1468         addrclip_clear( _clipBoard_ );
1469         addrclip_add( _clipBoard_, _addressSelect_ );
1470         /* addrclip_list_show( _clipBoard_, stdout ); */
1471 }
1472
1473 /*
1474 * Copy from address list widget.
1475 */
1476 static void addressbook_clip_copy_cb( void ) {
1477         _clipBoard_->cutFlag = FALSE;
1478         addrclip_clear( _clipBoard_ );
1479         addrclip_add( _clipBoard_, _addressSelect_ );
1480         /* addrclip_list_show( _clipBoard_, stdout ); */
1481 }
1482
1483 /*
1484 * Paste clipboard into address list widget.
1485 */
1486 static void addressbook_clip_paste_cb( void ) {
1487         GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
1488         AddressObject *pobj = NULL;
1489         AddressDataSource *ds = NULL;
1490         AddressBookFile *abf = NULL;
1491         ItemFolder *folder = NULL;
1492         GList *folderGroup = NULL;
1493
1494         ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
1495         if( ds == NULL ) return;
1496         if( addrindex_ds_get_readonly( ds ) ) {
1497                 addressbook_ds_status_message(
1498                         ds, _( "Cannot paste. Target address book is readonly." ) );
1499                 return;
1500         }
1501
1502         pobj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
1503         if( pobj ) {
1504                 if( pobj->type == ADDR_ITEM_FOLDER ) {
1505                         folder = ADAPTER_FOLDER(pobj)->itemFolder;
1506                 }
1507                 else if( pobj->type == ADDR_ITEM_GROUP ) {
1508                         addressbook_ds_status_message(
1509                                 ds, _( "Cannot paste into an address group." ) );
1510                         return;
1511                 }
1512         }
1513
1514         /* Get an address book */
1515         abf = addressbook_get_book_file();
1516         if( abf == NULL ) return;
1517
1518         if( _clipBoard_->cutFlag ) {
1519                 /* Paste/Cut */
1520                 folderGroup = addrclip_paste_cut( _clipBoard_, abf, folder );
1521
1522                 /* Remove all groups and folders in clipboard from tree node */
1523                 addressbook_treenode_remove_item();
1524
1525                 /* Remove all "cut" items */
1526                 addrclip_delete_item( _clipBoard_ );
1527
1528                 /* Clear clipboard - cut items??? */
1529                 addrclip_clear( _clipBoard_ );
1530         }
1531         else {
1532                 /* Paste/Copy */
1533                 folderGroup = addrclip_paste_copy( _clipBoard_, abf, folder );
1534         }
1535
1536         /* addrclip_list_show( _clipBoard_, stdout ); */
1537         if( folderGroup ) {
1538                 /* Update tree by inserting node for each folder or group */
1539                 addressbook_treenode_add_list(
1540                         addrbook.treeSelected, ds, folderGroup );
1541                 gtk_ctree_expand( ctree, addrbook.treeSelected );
1542                 g_list_free( folderGroup );
1543                 folderGroup = NULL;
1544         }
1545
1546         /* Display items pasted */
1547         gtk_ctree_select( ctree, addrbook.opened );
1548
1549 }
1550
1551 /*
1552 * Paste clipboard email addresses only into address list widget.
1553 */
1554 static void addressbook_clip_paste_address_cb( void ) {
1555         GtkCTree *clist = GTK_CTREE(addrbook.clist);
1556         GtkCTree *ctree;
1557         AddressObject *pobj = NULL;
1558         AddressDataSource *ds = NULL;
1559         AddressBookFile *abf = NULL;
1560         ItemFolder *folder = NULL;
1561         AddrItemObject *aio;
1562         gint cnt;
1563
1564         if( addrbook.listSelected == NULL ) return;
1565
1566         ctree = GTK_CTREE( addrbook.ctree );
1567         ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
1568         if( ds == NULL ) return;
1569         if( addrindex_ds_get_readonly( ds ) ) {
1570                 addressbook_ds_status_message(
1571                         ds, _( "Cannot paste. Target address book is readonly." ) );
1572                 return;
1573         }
1574
1575         pobj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
1576         if( pobj ) {
1577                 if( pobj->type == ADDR_ITEM_FOLDER ) {
1578                         folder = ADAPTER_FOLDER(pobj)->itemFolder;
1579                 }
1580         }
1581
1582         abf = addressbook_get_book_file();
1583         if( abf == NULL ) return;
1584
1585         cnt = 0;
1586         aio = gtk_ctree_node_get_row_data( clist, addrbook.listSelected );
1587         if( aio->type == ADDR_ITEM_PERSON ) {
1588                 ItemPerson *person;
1589
1590                 person = ( ItemPerson * ) aio;
1591                 if( _clipBoard_->cutFlag ) {
1592                         /* Paste/Cut */
1593                         cnt = addrclip_paste_person_cut( _clipBoard_, abf, person );
1594
1595                         /* Remove all "cut" items */
1596                         addrclip_delete_address( _clipBoard_ );
1597
1598                         /* Clear clipboard */
1599                         addrclip_clear( _clipBoard_ );
1600                 }
1601                 else {
1602                         /* Paste/Copy */
1603                         cnt = addrclip_paste_person_copy( _clipBoard_, abf, person );
1604                 }
1605                 if( cnt > 0 ) {
1606                         addritem_person_set_opened( person, TRUE );
1607                 }
1608         }
1609
1610         /* Display items pasted */
1611         if( cnt > 0 ) {
1612                 gtk_ctree_select( ctree, addrbook.opened );
1613         }
1614 }
1615
1616 /*
1617 * Add current treenode object to clipboard. Note that widget only allows
1618 * one entry from the tree list to be selected.
1619 */
1620 static void addressbook_treenode_to_clipboard( void ) {
1621         AddressObject *obj = NULL;
1622         AddressDataSource *ds = NULL;
1623         AddrSelectItem *item;
1624         GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
1625         GtkCTreeNode *node;
1626
1627         node = addrbook.treeSelected;
1628         if( node == NULL ) return;
1629         obj = gtk_ctree_node_get_row_data( ctree, node );
1630         if( obj == NULL ) return;
1631
1632         ds = addressbook_find_datasource( node );
1633         if( ds == NULL ) return;
1634
1635         item = NULL;
1636         if( obj->type == ADDR_ITEM_FOLDER ) {
1637                 AdapterFolder *adapter = ADAPTER_FOLDER(obj);
1638                 ItemFolder *folder = adapter->itemFolder;
1639
1640                 item = addrselect_create_node( obj );
1641                 item->uid = g_strdup( ADDRITEM_ID(folder) );
1642         }
1643         else if( obj->type == ADDR_ITEM_GROUP ) {
1644                 AdapterGroup *adapter = ADAPTER_GROUP(obj);
1645                 ItemGroup *group = adapter->itemGroup;
1646
1647                 item = addrselect_create_node( obj );
1648                 item->uid = g_strdup( ADDRITEM_ID(group) );
1649         }
1650         else if( obj->type == ADDR_DATASOURCE ) {
1651                 /* Data source */
1652                 item = addrselect_create_node( obj );
1653                 item->uid = NULL;
1654         }
1655
1656         if( item ) {
1657                 /* Clear existing list and add item into list */
1658                 gchar *cacheID;
1659
1660                 addressbook_list_select_clear();
1661                 cacheID = addrindex_get_cache_id( _addressIndex_, ds );
1662                 addrselect_list_add( _addressSelect_, item, cacheID );
1663                 g_free( cacheID );
1664         }
1665 }
1666
1667 /*
1668 * Cut from tree widget.
1669 */
1670 static void addressbook_treenode_cut_cb( void ) {
1671         _clipBoard_->cutFlag = TRUE;
1672         addressbook_treenode_to_clipboard();
1673         addrclip_clear( _clipBoard_ );
1674         addrclip_add( _clipBoard_, _addressSelect_ );
1675         /* addrclip_list_show( _clipBoard_, stdout ); */
1676 }
1677
1678 /*
1679 * Copy from tree widget.
1680 */
1681 static void addressbook_treenode_copy_cb( void ) {
1682         _clipBoard_->cutFlag = FALSE;
1683         addressbook_treenode_to_clipboard();
1684         addrclip_clear( _clipBoard_ );
1685         addrclip_add( _clipBoard_, _addressSelect_ );
1686         /* addrclip_list_show( _clipBoard_, stdout ); */
1687 }
1688
1689 /*
1690 * Paste clipboard into address tree widget.
1691 */
1692 static void addressbook_treenode_paste_cb( void ) {
1693         addressbook_clip_paste_cb();
1694 }
1695
1696 static void addressbook_list_select_clear( void ) {
1697         addrselect_list_clear( _addressSelect_ );
1698 }
1699
1700 static void addressbook_list_select_add( AddrItemObject *aio, AddressDataSource *ds ) {
1701         gchar *cacheID;
1702
1703         if( ds == NULL ) return;
1704         cacheID = addrindex_get_cache_id( _addressIndex_, ds );
1705         addrselect_list_add_obj( _addressSelect_, aio, cacheID );
1706         g_free( cacheID );
1707 }
1708
1709 static void addressbook_list_select_remove( AddrItemObject *aio ) {
1710         addrselect_list_remove( _addressSelect_, aio );
1711 }
1712
1713 static void addressbook_list_row_selected( GtkCTree *clist,
1714                                            GtkCTreeNode *node,
1715                                            gint column,
1716                                            gpointer data )
1717 {
1718         GtkEntry *entry = GTK_ENTRY(addrbook.entry);
1719         AddrItemObject *aio = NULL;
1720         AddressObject *pobj = NULL;
1721         AdapterDSource *ads = NULL;
1722         AddressDataSource *ds = NULL;
1723
1724         gtk_entry_set_text( entry, "" );
1725         addrbook.listSelected = node;
1726
1727         pobj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), addrbook.treeSelected );
1728         if( pobj == NULL ) return;
1729
1730         if( pobj->type == ADDR_DATASOURCE ) {
1731                 ads = ADAPTER_DSOURCE(pobj);
1732                 ds = ads->dataSource;
1733         }
1734         else if( pobj->type != ADDR_INTERFACE ) {
1735                 ds = addressbook_find_datasource( addrbook.treeSelected );
1736         }
1737
1738         aio = gtk_ctree_node_get_row_data( clist, node );
1739         if( aio ) {
1740                 /* printf( "list select: %d : '%s'\n", aio->type, aio->name ); */
1741                 addressbook_list_select_add( aio, ds );
1742         }
1743
1744         addressbook_list_menu_setup();
1745 }
1746
1747 static void addressbook_list_row_unselected( GtkCTree *ctree,
1748                                              GtkCTreeNode *node,
1749                                              gint column,
1750                                              gpointer data )
1751 {
1752         AddrItemObject *aio;
1753
1754         aio = gtk_ctree_node_get_row_data( ctree, node );
1755         if( aio != NULL ) {
1756                 /* printf( "list unselect: %d : '%s'\n", aio->type, aio->name ); */
1757                 addressbook_list_select_remove( aio );
1758         }
1759 }
1760
1761 static void addressbook_entry_gotfocus( GtkWidget *widget ) {
1762         gtk_editable_select_region( GTK_EDITABLE(addrbook.entry), 0, -1 );
1763 }
1764
1765 static void addressbook_list_button_pressed(GtkWidget *widget,
1766                                             GdkEventButton *event,
1767                                             gpointer data)
1768 {
1769         if( ! event ) return;
1770
1771         addressbook_list_menu_setup();
1772
1773         if( event->button == 3 ) {
1774                 gtk_menu_popup( GTK_MENU(addrbook.list_popup), NULL, NULL, NULL, NULL,
1775                        event->button, event->time );
1776         }
1777 }
1778
1779 static void addressbook_list_button_released(GtkWidget *widget,
1780                                              GdkEventButton *event,
1781                                              gpointer data)
1782 {
1783 }
1784
1785 static void addressbook_tree_button_pressed(GtkWidget *ctree,
1786                                             GdkEventButton *event,
1787                                             gpointer data)
1788 {
1789         GtkCList *clist = GTK_CLIST(ctree);
1790         gint row, column;
1791         AddressObject *obj = NULL;
1792         AdapterDSource *ads = NULL;
1793         AddressInterface *iface = NULL;
1794         AddressDataSource *ds = NULL;
1795         gboolean canEdit = FALSE;
1796         gboolean canCut = FALSE;
1797         gboolean canCopy = FALSE;
1798         gboolean canPaste = FALSE;
1799         gboolean canTreeCut = FALSE;
1800         gboolean canTreeCopy = FALSE;
1801         gboolean canTreePaste = FALSE;
1802
1803         if( ! event ) return;
1804         addressbook_menubar_set_sensitive( FALSE );
1805
1806         if( gtk_clist_get_selection_info( clist, event->x, event->y, &row, &column ) ) {
1807                 gtk_clist_select_row( clist, row, column );
1808                 gtkut_clist_set_focus_row(clist, row);
1809                 obj = gtk_clist_get_row_data( clist, row );
1810         }
1811
1812         menu_set_insensitive_all(GTK_MENU_SHELL(addrbook.tree_popup));
1813
1814         if( obj == NULL ) return;
1815
1816         if( ! addrclip_is_empty( _clipBoard_ ) ) {
1817                 canTreePaste = TRUE;
1818         }
1819
1820         if (obj->type == ADDR_DATASOURCE) {
1821                 ads = ADAPTER_DSOURCE(obj);
1822                 ds = ads->dataSource;
1823                 iface = ds->interface;
1824                 canEdit = TRUE;
1825                 if( iface->readOnly ) {
1826                         canTreePaste = FALSE;
1827                 }
1828                 else {
1829                         menu_set_sensitive( addrbook.tree_factory, "/New Address", TRUE );
1830                         menu_set_sensitive( addrbook.tree_factory, "/New Folder", TRUE );
1831                         menu_set_sensitive( addrbook.tree_factory, "/New Group", TRUE );
1832                         gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1833                 }
1834                 canTreeCopy = TRUE;
1835         }
1836         else if (obj->type == ADDR_ITEM_FOLDER) {
1837                 ds = addressbook_find_datasource( addrbook.treeSelected );
1838                 iface = ds->interface;
1839                 if( iface->readOnly ) {
1840                         canTreePaste = FALSE;
1841                 }
1842                 else {
1843                         canEdit = TRUE;
1844                         canTreeCut = TRUE;
1845                         menu_set_sensitive( addrbook.tree_factory, "/New Address", TRUE );
1846                         menu_set_sensitive( addrbook.tree_factory, "/New Folder", TRUE );
1847                         menu_set_sensitive( addrbook.tree_factory, "/New Group", TRUE );
1848                         gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1849                 }
1850                 canTreeCopy = TRUE;
1851         }
1852         else if (obj->type == ADDR_ITEM_GROUP) {
1853                 ds = addressbook_find_datasource( addrbook.treeSelected );
1854                 iface = ds->interface;
1855                 if( ! iface->readOnly ) {
1856                         canEdit = TRUE;
1857                         menu_set_sensitive( addrbook.tree_factory, "/New Address", TRUE );
1858                         gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1859                 }
1860         }
1861         else if (obj->type == ADDR_INTERFACE) {
1862                 canTreePaste = FALSE;
1863         }
1864
1865         if( canEdit ) {
1866                 if( ! addrselect_test_empty( _addressSelect_ ) ) canCut = TRUE;
1867         }
1868         if( ! addrselect_test_empty( _addressSelect_ ) ) canCopy = TRUE;
1869         if( ! addrclip_is_empty( _clipBoard_ ) ) canPaste = TRUE;
1870
1871         /* Enable edit */
1872         menu_set_sensitive( addrbook.tree_factory, "/Edit",   canEdit );
1873         menu_set_sensitive( addrbook.tree_factory, "/Delete", canEdit );
1874         menu_set_sensitive( addrbook.tree_factory, "/Cut",    canTreeCut );
1875         menu_set_sensitive( addrbook.tree_factory, "/Copy",   canTreeCopy );
1876         menu_set_sensitive( addrbook.tree_factory, "/Paste",  canTreePaste );
1877
1878         menu_set_sensitive( addrbook.menu_factory, "/File/Edit",          canEdit );
1879         menu_set_sensitive( addrbook.menu_factory, "/File/Delete",        canEdit );
1880         menu_set_sensitive( addrbook.menu_factory, "/Edit/Cut",           canCut );
1881         menu_set_sensitive( addrbook.menu_factory, "/Edit/Copy",          canCopy );
1882         menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste",         canPaste );
1883         menu_set_sensitive( addrbook.menu_factory, "/Edit/Paste Address", canPaste );
1884
1885         if( event->button == 3 ) {
1886                 gtk_menu_popup(GTK_MENU(addrbook.tree_popup), NULL, NULL, NULL, NULL,
1887                                event->button, event->time);
1888         }
1889
1890 }
1891
1892 static void addressbook_tree_button_released(GtkWidget *ctree,
1893                                              GdkEventButton *event,
1894                                              gpointer data)
1895 {
1896         gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
1897         gtkut_ctree_set_focus_row(GTK_CTREE(addrbook.ctree), addrbook.opened);
1898 }
1899
1900 static void addressbook_popup_close(GtkMenuShell *menu_shell, gpointer data)
1901 {
1902         if (!addrbook.opened) return;
1903
1904         gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
1905         gtkut_ctree_set_focus_row(GTK_CTREE(addrbook.ctree),
1906                                   addrbook.opened);
1907 }
1908
1909 static void addressbook_new_folder_cb(gpointer data, guint action,
1910                                       GtkWidget *widget)
1911 {
1912         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1913         AddressObject *obj = NULL;
1914         AddressDataSource *ds = NULL;
1915         AddressBookFile *abf = NULL;
1916         ItemFolder *parentFolder = NULL;
1917         ItemFolder *folder = NULL;
1918
1919         if( ! addrbook.treeSelected ) return;
1920         obj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
1921         if( obj == NULL ) return;
1922         ds = addressbook_find_datasource( addrbook.treeSelected );
1923         if( ds == NULL ) return;
1924
1925         if( obj->type == ADDR_DATASOURCE ) {
1926                 if( ADAPTER_DSOURCE(obj)->subType != ADDR_BOOK ) return;
1927         }
1928         else if( obj->type == ADDR_ITEM_FOLDER ) {
1929                 parentFolder = ADAPTER_FOLDER(obj)->itemFolder;
1930         }
1931         else {
1932                 return;
1933         }
1934
1935         abf = ds->rawDataSource;
1936         if( abf == NULL ) return;
1937         folder = addressbook_edit_folder( abf, parentFolder, NULL );
1938         if( folder ) {
1939                 GtkCTreeNode *nn;
1940                 nn = addressbook_node_add_folder( addrbook.treeSelected, ds, folder, ADDR_ITEM_FOLDER );
1941                 gtk_ctree_expand( ctree, addrbook.treeSelected );
1942                 if( addrbook.treeSelected == addrbook.opened ) addressbook_set_clist(obj);
1943         }
1944
1945 }
1946
1947 static void addressbook_new_group_cb(gpointer data, guint action,
1948                                      GtkWidget *widget)
1949 {
1950         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1951         AddressObject *obj = NULL;
1952         AddressDataSource *ds = NULL;
1953         AddressBookFile *abf = NULL;
1954         ItemFolder *parentFolder = NULL;
1955         ItemGroup *group = NULL;
1956
1957         if( ! addrbook.treeSelected ) return;
1958         obj = gtk_ctree_node_get_row_data(ctree, addrbook.treeSelected);
1959         if( obj == NULL ) return;
1960         ds = addressbook_find_datasource( addrbook.treeSelected );
1961         if( ds == NULL ) return;
1962
1963         if( obj->type == ADDR_DATASOURCE ) {
1964                 if( ADAPTER_DSOURCE(obj)->subType != ADDR_BOOK ) return;
1965         }
1966         else if( obj->type == ADDR_ITEM_FOLDER ) {
1967                 parentFolder = ADAPTER_FOLDER(obj)->itemFolder;
1968         }
1969         else {
1970                 return;
1971         }
1972
1973         abf = ds->rawDataSource;
1974         if( abf == NULL ) return;
1975         group = addressbook_edit_group( abf, parentFolder, NULL );
1976         if( group ) {
1977                 GtkCTreeNode *nn;
1978                 nn = addressbook_node_add_group( addrbook.treeSelected, ds, group );
1979                 gtk_ctree_expand( ctree, addrbook.treeSelected );
1980                 if( addrbook.treeSelected == addrbook.opened ) addressbook_set_clist(obj);
1981         }
1982
1983 }
1984
1985 static void addressbook_change_node_name(GtkCTreeNode *node, const gchar *name)
1986 {
1987         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1988         gchar *text[1];
1989         guint8 spacing;
1990         GdkPixmap *pix_cl, *pix_op;
1991         GdkBitmap *mask_cl, *mask_op;
1992         gboolean is_leaf, expanded;
1993
1994         gtk_ctree_get_node_info(ctree, node, text, &spacing,
1995                                 &pix_cl, &mask_cl, &pix_op, &mask_op,
1996                                 &is_leaf, &expanded);
1997         gtk_ctree_set_node_info(ctree, node, name, spacing,
1998                                 pix_cl, mask_cl, pix_op, mask_op,
1999                                 is_leaf, expanded);
2000 }
2001
2002 /*
2003 * Edit data source.
2004 * Enter: obj   Address object to edit.
2005 *        node  Node in tree.
2006 * Return: New name of data source.
2007 */
2008 static gchar *addressbook_edit_datasource( AddressObject *obj, GtkCTreeNode *node ) {
2009         gchar *newName = NULL;
2010         AddressDataSource *ds = NULL;
2011         AddressInterface *iface = NULL;
2012         AdapterDSource *ads = NULL;
2013
2014         ds = addressbook_find_datasource( node );
2015         if( ds == NULL ) return NULL;
2016         iface = ds->interface;
2017         if( ! iface->haveLibrary ) return NULL;
2018
2019         /* Read data from data source */
2020         if( addrindex_ds_get_modify_flag( ds ) ) {
2021                 addrindex_ds_read_data( ds );
2022         }
2023
2024         if( ! addrindex_ds_get_read_flag( ds ) ) {
2025                 addrindex_ds_read_data( ds );
2026         }
2027
2028         /* Handle edit */
2029         ads = ADAPTER_DSOURCE(obj);
2030         if( ads->subType == ADDR_BOOK ) {
2031                 if( addressbook_edit_book( _addressIndex_, ads ) == NULL ) return NULL;
2032         }
2033         else if( ads->subType == ADDR_VCARD ) {
2034                 if( addressbook_edit_vcard( _addressIndex_, ads ) == NULL ) return NULL;
2035         }
2036 #ifdef USE_JPILOT
2037         else if( ads->subType == ADDR_JPILOT ) {
2038                 if( addressbook_edit_jpilot( _addressIndex_, ads ) == NULL ) return NULL;
2039         }
2040 #endif
2041 #ifdef USE_LDAP
2042         else if( ads->subType == ADDR_LDAP ) {
2043                 if( addressbook_edit_ldap( _addressIndex_, ads ) == NULL ) return NULL;
2044         }
2045 #endif
2046         else {
2047                 return NULL;
2048         }
2049         newName = obj->name;
2050         return newName;
2051 }
2052
2053 /*
2054 * Edit an object that is in the address tree area.
2055 */
2056 static void addressbook_treenode_edit_cb(gpointer data, guint action,
2057                                        GtkWidget *widget)
2058 {
2059         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
2060         AddressObject *obj;
2061         AddressDataSource *ds = NULL;
2062         AddressBookFile *abf = NULL;
2063         GtkCTreeNode *node = NULL, *parentNode = NULL;
2064         gchar *name = NULL;
2065
2066         if( ! addrbook.treeSelected ) return;
2067         node = addrbook.treeSelected;
2068         if( GTK_CTREE_ROW(node)->level == 1 ) return;
2069         obj = gtk_ctree_node_get_row_data( ctree, node );
2070         if( obj == NULL ) return;
2071         parentNode = GTK_CTREE_ROW(node)->parent;
2072
2073         ds = addressbook_find_datasource( node );
2074         if( ds == NULL ) return;
2075
2076         if( obj->type == ADDR_DATASOURCE ) {
2077                 name = addressbook_edit_datasource( obj, node );
2078                 if( name == NULL ) return;
2079         }
2080         else {
2081                 abf = ds->rawDataSource;
2082                 if( abf == NULL ) return;
2083                 if( obj->type == ADDR_ITEM_FOLDER ) {
2084                         AdapterFolder *adapter = ADAPTER_FOLDER(obj);
2085                         ItemFolder *item = adapter->itemFolder;
2086                         ItemFolder *parentFolder = NULL;
2087                         parentFolder = ( ItemFolder * ) ADDRITEM_PARENT(item);
2088                         if( addressbook_edit_folder( abf, parentFolder, item ) == NULL ) return;
2089                         name = ADDRITEM_NAME(item);
2090                 }
2091                 else if( obj->type == ADDR_ITEM_GROUP ) {
2092                         AdapterGroup *adapter = ADAPTER_GROUP(obj);
2093                         ItemGroup *item = adapter->itemGroup;
2094                         ItemFolder *parentFolder = NULL;
2095                         parentFolder = ( ItemFolder * ) ADDRITEM_PARENT(item);
2096                         if( addressbook_edit_group( abf, parentFolder, item ) == NULL ) return;
2097                         name = ADDRITEM_NAME(item);
2098                 }
2099         }
2100         if( name && parentNode ) {
2101                 /* Update node in tree view */
2102                 addressbook_change_node_name( node, name );
2103                 gtk_sctree_sort_node(ctree, parentNode);
2104                 gtk_ctree_expand( ctree, node );
2105                 gtk_ctree_select( ctree, node );
2106         }
2107 }
2108
2109 /*
2110 * Delete an item from the tree widget.
2111 */
2112 static void addressbook_treenode_delete_cb(gpointer data, guint action,
2113                                          GtkWidget *widget)
2114 {
2115         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
2116         GtkCTreeNode *node = NULL;
2117         AddressObject *obj;
2118         gchar *message;
2119         AlertValue aval;
2120         AddressBookFile *abf = NULL;
2121         AdapterDSource *ads = NULL;
2122         AddressInterface *iface = NULL;
2123         AddressDataSource *ds = NULL;
2124         gboolean remFlag = FALSE;
2125
2126         if( ! addrbook.treeSelected ) return;
2127         node = addrbook.treeSelected;
2128         if( GTK_CTREE_ROW(node)->level == 1 ) return;
2129
2130         obj = gtk_ctree_node_get_row_data( ctree, node );
2131         g_return_if_fail(obj != NULL);
2132
2133         if( obj->type == ADDR_DATASOURCE ) {
2134                 ads = ADAPTER_DSOURCE(obj);
2135                 if( ads == NULL ) return;
2136                 ds = ads->dataSource;
2137                 if( ds == NULL ) return;
2138         }
2139         else {
2140                 /* Must be folder or something else */
2141                 ds = addressbook_find_datasource( node );
2142                 if( ds == NULL ) return;
2143
2144                 /* Only allow deletion from non-readOnly data sources */
2145                 iface = ds->interface;
2146                 if( iface->readOnly ) return;
2147         }
2148
2149         /* Confirm deletion */
2150         if( obj->type == ADDR_ITEM_FOLDER ) {
2151                 message = g_strdup_printf( _(
2152                         "Do you want to delete the folder AND all addresses in `%s' ? \n" \
2153                         "If deleting the folder only, addresses will be moved into parent folder." ),
2154                         obj->name );
2155                 aval = alertpanel( _("Delete"), message,
2156                         _("Folder only"), _("Folder and Addresses"), _("Cancel") );
2157                 g_free(message);
2158                 if( aval == G_ALERTOTHER ) return;
2159         }
2160         else {
2161                 message = g_strdup_printf(_("Really delete `%s' ?"), obj->name);
2162                 aval = alertpanel(_("Delete"), message, _("Yes"), _("No"), NULL);
2163                 g_free(message);
2164                 if (aval != G_ALERTDEFAULT) return;
2165         }
2166
2167         /* Proceed with deletion */
2168         if( obj->type == ADDR_DATASOURCE ) {
2169                 /* Remove data source. */
2170                 if( addrindex_index_remove_datasource( _addressIndex_, ds ) ) {
2171                         addrindex_free_datasource( ds );
2172                         remFlag = TRUE;
2173                 }
2174         }
2175         else {
2176                 abf = addressbook_get_book_file();
2177                 if( abf == NULL ) return;
2178         }
2179
2180         if( obj->type == ADDR_ITEM_FOLDER ) {
2181                 AdapterFolder *adapter = ADAPTER_FOLDER(obj);
2182                 ItemFolder *item = adapter->itemFolder;
2183                 if( aval == G_ALERTDEFAULT ) {
2184                         /* Remove folder only */
2185                         item = addrbook_remove_folder( abf, item );
2186                         if( item ) {
2187                                 addritem_free_item_folder( item );
2188                                 addressbook_move_nodes_up( ctree, node );
2189                                 remFlag = TRUE;
2190                         }
2191                 }
2192                 else if( aval == G_ALERTALTERNATE ) {
2193                         /* Remove folder and addresses */
2194                         item = addrbook_remove_folder_delete( abf, item );
2195                         if( item ) {
2196                                 addritem_free_item_folder( item );
2197                                 remFlag = TRUE;
2198                         }
2199                 }
2200         }
2201         else if( obj->type == ADDR_ITEM_GROUP ) {
2202                 AdapterGroup *adapter = ADAPTER_GROUP(obj);
2203                 ItemGroup *item = adapter->itemGroup;
2204
2205                 item = addrbook_remove_group( abf, item );
2206                 if( item ) {
2207                         addritem_free_item_group( item );
2208                         remFlag = TRUE;
2209                 }
2210         }
2211
2212         if( remFlag ) {
2213                 /* Remove node. */
2214                 gtk_ctree_remove_node(ctree, node );
2215         }
2216 }
2217
2218 static void addressbook_new_address_cb( gpointer data, guint action, GtkWidget *widget ) {
2219         AddressObject *pobj = NULL;
2220         AddressDataSource *ds = NULL;
2221         AddressBookFile *abf = NULL;
2222
2223         pobj = gtk_ctree_node_get_row_data(GTK_CTREE(addrbook.ctree), addrbook.treeSelected);
2224         if( pobj == NULL ) return;
2225         ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
2226         if( ds == NULL ) return;
2227
2228         abf = ds->rawDataSource;
2229         if( abf == NULL ) return;
2230
2231         if( pobj->type == ADDR_DATASOURCE ) {
2232                 if( ADAPTER_DSOURCE(pobj)->subType == ADDR_BOOK ) {
2233                         /* New address */
2234                         ItemPerson *person = addressbook_edit_person( abf, NULL, NULL, FALSE );
2235                         if( person ) {
2236                                 if( addrbook.treeSelected == addrbook.opened ) {
2237                                         gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
2238                                 }
2239                         }
2240                 }
2241         }
2242         else if( pobj->type == ADDR_ITEM_FOLDER ) {
2243                 /* New address */
2244                 ItemFolder *folder = ADAPTER_FOLDER(pobj)->itemFolder;
2245                 ItemPerson *person = addressbook_edit_person( abf, folder, NULL, FALSE );
2246                 if( person ) {
2247                         if (addrbook.treeSelected == addrbook.opened) {
2248                                 gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
2249                         }
2250                 }
2251         }
2252         else if( pobj->type == ADDR_ITEM_GROUP ) {
2253                 /* New address in group */
2254                 ItemGroup *group = ADAPTER_GROUP(pobj)->itemGroup;
2255                 if( addressbook_edit_group( abf, NULL, group ) == NULL ) return;
2256                 if (addrbook.treeSelected == addrbook.opened) {
2257                         /* Change node name in tree. */
2258                         addressbook_change_node_name( addrbook.treeSelected, ADDRITEM_NAME(group) );
2259                         gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
2260                 }
2261         }
2262 }
2263
2264 /*
2265 * Search for specified child group node in address index tree.
2266 * Enter: parent Parent node.
2267 *        group  Group to find.
2268 */
2269 static GtkCTreeNode *addressbook_find_group_node( GtkCTreeNode *parent, ItemGroup *group ) {
2270         GtkCTreeNode *node = NULL;
2271         GtkCTreeRow *currRow;
2272
2273         currRow = GTK_CTREE_ROW( parent );
2274         if( currRow ) {
2275                 node = currRow->children;
2276                 while( node ) {
2277                         AddressObject *obj;
2278
2279                         obj = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), node );
2280                         if( obj->type == ADDR_ITEM_GROUP ) {
2281                                 ItemGroup *g = ADAPTER_GROUP(obj)->itemGroup;
2282                                 if( g == group ) return node;
2283                         }
2284                         currRow = GTK_CTREE_ROW(node);
2285                         node = currRow->sibling;
2286                 }
2287         }
2288         return NULL;
2289 }
2290
2291 static AddressBookFile *addressbook_get_book_file() {
2292         AddressBookFile *abf = NULL;
2293         AddressDataSource *ds = NULL;
2294
2295         ds = addressbook_find_datasource( addrbook.treeSelected );
2296         if( ds == NULL ) return NULL;
2297         if( ds->type == ADDR_IF_BOOK ) abf = ds->rawDataSource;
2298         return abf;
2299 }
2300
2301 static void addressbook_tree_remove_children( GtkCTree *ctree, GtkCTreeNode *parent ) {
2302         GtkCTreeNode *node;
2303         GtkCTreeRow *row;
2304
2305         /* Remove existing folders and groups */
2306         row = GTK_CTREE_ROW( parent );
2307         if( row ) {
2308                 while( (node = row->children) ) {
2309                         gtk_ctree_remove_node( ctree, node );
2310                 }
2311         }
2312 }
2313
2314 static void addressbook_move_nodes_up( GtkCTree *ctree, GtkCTreeNode *node ) {
2315         GtkCTreeNode *parent, *child;
2316         GtkCTreeRow *currRow;
2317         currRow = GTK_CTREE_ROW( node );
2318         if( currRow ) {
2319                 parent = currRow->parent;
2320                 while( (child = currRow->children) ) {
2321                         gtk_ctree_move( ctree, child, parent, node );
2322                 }
2323                 gtk_sctree_sort_node( ctree, parent );
2324         }
2325 }
2326
2327 static void addressbook_edit_address_cb( gpointer data, guint action, GtkWidget *widget ) {
2328         GtkCTree *clist = GTK_CTREE(addrbook.clist);
2329         GtkCTree *ctree;
2330         AddressObject *obj = NULL, *pobj = NULL;
2331         AddressDataSource *ds = NULL;
2332         GtkCTreeNode *node = NULL, *parentNode = NULL;
2333         gchar *name = NULL;
2334         AddressBookFile *abf = NULL;
2335
2336         if( addrbook.listSelected == NULL ) return;
2337         obj = gtk_ctree_node_get_row_data( clist, addrbook.listSelected );
2338         g_return_if_fail(obj != NULL);
2339
2340         ctree = GTK_CTREE( addrbook.ctree );
2341         pobj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
2342         node = gtk_ctree_find_by_row_data( ctree, addrbook.treeSelected, obj );
2343
2344         ds = addressbook_find_datasource( GTK_CTREE_NODE(addrbook.treeSelected) );
2345         if( ds == NULL ) return;
2346
2347         abf = addressbook_get_book_file();
2348         if( abf == NULL ) return;
2349         if( obj->type == ADDR_ITEM_EMAIL ) {
2350                 ItemEMail *email = ( ItemEMail * ) obj;
2351                 if( email == NULL ) return;
2352                 if( pobj && pobj->type == ADDR_ITEM_GROUP ) {
2353                         /* Edit parent group */
2354                         AdapterGroup *adapter = ADAPTER_GROUP(pobj);
2355                         ItemGroup *itemGrp = adapter->itemGroup;
2356                         if( addressbook_edit_group( abf, NULL, itemGrp ) == NULL ) return;
2357                         name = ADDRITEM_NAME(itemGrp);
2358                         node = addrbook.treeSelected;
2359                         parentNode = GTK_CTREE_ROW(node)->parent;
2360                 }
2361                 else {
2362                         /* Edit person - email page */
2363                         ItemPerson *person;
2364                         person = ( ItemPerson * ) ADDRITEM_PARENT(email);
2365                         if( addressbook_edit_person( abf, NULL, person, TRUE ) == NULL ) return;
2366                         gtk_ctree_select( ctree, addrbook.opened );
2367                         invalidate_address_completion();
2368                         return;
2369                 }
2370         }
2371         else if( obj->type == ADDR_ITEM_PERSON ) {
2372                 /* Edit person - basic page */
2373                 ItemPerson *person = ( ItemPerson * ) obj;
2374                 if( addressbook_edit_person( abf, NULL, person, FALSE ) == NULL ) return;
2375                 gtk_ctree_select( ctree, addrbook.opened);
2376                 invalidate_address_completion();
2377                 return;
2378         }
2379         else if( obj->type == ADDR_ITEM_GROUP ) {
2380                 ItemGroup *itemGrp = ( ItemGroup * ) obj;
2381                 if( addressbook_edit_group( abf, NULL, itemGrp ) == NULL ) return;
2382                 parentNode = addrbook.treeSelected;
2383                 node = addressbook_find_group_node( parentNode, itemGrp );
2384                 name = ADDRITEM_NAME(itemGrp);
2385         }
2386         else {
2387                 return;
2388         }
2389
2390         /* Update tree node with node name */
2391         if( node == NULL ) return;
2392         addressbook_change_node_name( node, name );
2393         gtk_sctree_sort_node( ctree, parentNode );
2394         gtk_ctree_select( ctree, addrbook.opened );
2395 }
2396
2397 static void addressbook_delete_address_cb(gpointer data, guint action,
2398                                           GtkWidget *widget)
2399 {
2400         addressbook_del_clicked(NULL, NULL);
2401 }
2402
2403 static void close_cb(gpointer data, guint action, GtkWidget *widget)
2404 {
2405         addressbook_close();
2406 }
2407
2408 static void addressbook_file_save_cb( gpointer data, guint action, GtkWidget *widget ) {
2409         addressbook_export_to_file();
2410 }
2411
2412 static void addressbook_person_expand_node( GtkCTree *ctree, GList *node, gpointer *data ) {
2413         if( node ) {
2414                 ItemPerson *person = gtk_ctree_node_get_row_data( ctree, GTK_CTREE_NODE(node) );
2415                 if( person ) addritem_person_set_opened( person, TRUE );
2416         }
2417 }
2418
2419 static void addressbook_person_collapse_node( GtkCTree *ctree, GList *node, gpointer *data ) {
2420         if( node ) {
2421                 ItemPerson *person = gtk_ctree_node_get_row_data( ctree, GTK_CTREE_NODE(node) );
2422                 if( person ) addritem_person_set_opened( person, FALSE );
2423         }
2424 }
2425
2426 static gchar *addressbook_format_item_clist( ItemPerson *person, ItemEMail *email ) {
2427         gchar *str = NULL;
2428         gchar *eMailAlias = ADDRITEM_NAME(email);
2429         if( eMailAlias && *eMailAlias != '\0' ) {
2430                 if( person ) {
2431                         str = g_strdup_printf( "%s - %s", ADDRITEM_NAME(person), eMailAlias );
2432                 }
2433                 else {
2434                         str = g_strdup( eMailAlias );
2435                 }
2436         }
2437         return str;
2438 }
2439
2440 static void addressbook_load_group( GtkCTree *clist, ItemGroup *itemGroup ) {
2441         GList *items = itemGroup->listEMail;
2442         AddressTypeControlItem *atci = addrbookctl_lookup( ADDR_ITEM_EMAIL );
2443         for( ; items != NULL; items = g_list_next( items ) ) {
2444                 GtkCTreeNode *nodeEMail = NULL;
2445                 gchar *text[N_COLS];
2446                 ItemEMail *email = items->data;
2447                 ItemPerson *person;
2448                 gchar *str = NULL;
2449
2450                 if( ! email ) continue;
2451
2452                 person = ( ItemPerson * ) ADDRITEM_PARENT(email);
2453                 str = addressbook_format_item_clist( person, email );
2454                 if( str ) {
2455                         text[COL_NAME] = str;
2456                 }
2457                 else {
2458                         text[COL_NAME] = ADDRITEM_NAME(person);
2459                 }
2460                 text[COL_ADDRESS] = email->address;
2461                 text[COL_REMARKS] = email->remarks;
2462                 nodeEMail = gtk_ctree_insert_node(
2463                                 clist, NULL, NULL,
2464                                 text, FOLDER_SPACING,
2465                                 atci->iconXpm, atci->maskXpm,
2466                                 atci->iconXpmOpen, atci->maskXpmOpen,
2467                                 FALSE, FALSE );
2468                 gtk_ctree_node_set_row_data( clist, nodeEMail, email );
2469                 g_free( str );
2470                 str = NULL;
2471         }
2472 }
2473
2474 static void addressbook_folder_load_person( GtkCTree *clist, ItemFolder *itemFolder ) {
2475         GList *items;
2476         AddressTypeControlItem *atci = addrbookctl_lookup( ADDR_ITEM_PERSON );
2477         AddressTypeControlItem *atciMail = addrbookctl_lookup( ADDR_ITEM_EMAIL );
2478
2479         if( atci == NULL ) return;
2480         if( atciMail == NULL ) return;
2481
2482         /* Load email addresses */
2483         items = addritem_folder_get_person_list( itemFolder );
2484         for( ; items != NULL; items = g_list_next( items ) ) {
2485                 GtkCTreeNode *nodePerson = NULL;
2486                 GtkCTreeNode *nodeEMail = NULL;
2487                 gchar *text[N_COLS];
2488                 gboolean flgFirst = TRUE, haveAddr = FALSE;
2489                 ItemPerson *person;
2490                 GList *node;
2491
2492                 person = ( ItemPerson * ) items->data;
2493                 if( person == NULL ) continue;
2494
2495                 text[COL_NAME] = NULL;
2496                 node = person->listEMail;
2497                 while( node ) {
2498                         ItemEMail *email = node->data;
2499                         gchar *eMailAddr = NULL;
2500                         node = g_list_next( node );
2501
2502                         text[COL_ADDRESS] = email->address;
2503                         text[COL_REMARKS] = email->remarks;
2504                         eMailAddr = ADDRITEM_NAME(email);
2505                         if( eMailAddr && *eMailAddr == '\0' ) eMailAddr = NULL;
2506                         if( flgFirst ) {
2507                                 /* First email belongs with person */
2508                                 gchar *str = addressbook_format_item_clist( person, email );
2509                                 if( str ) {
2510                                         text[COL_NAME] = str;
2511                                 }
2512                                 else {
2513                                         text[COL_NAME] = ADDRITEM_NAME(person);
2514                                 }
2515                                 nodePerson = gtk_ctree_insert_node(
2516                                                 clist, NULL, NULL,
2517                                                 text, FOLDER_SPACING,
2518                                                 atci->iconXpm, atci->maskXpm,
2519                                                 atci->iconXpmOpen, atci->maskXpmOpen,
2520                                                 FALSE, person->isOpened );
2521                                 g_free( str );
2522                                 str = NULL;
2523                                 gtk_ctree_node_set_row_data(clist, nodePerson, person );
2524                         }
2525                         else {
2526                                 /* Subsequent email is a child node of person */
2527                                 text[COL_NAME] = ADDRITEM_NAME(email);
2528                                 nodeEMail = gtk_ctree_insert_node(
2529                                                 clist, nodePerson, NULL,
2530                                                 text, FOLDER_SPACING,
2531                                                 atciMail->iconXpm, atciMail->maskXpm,
2532                                                 atciMail->iconXpmOpen, atciMail->maskXpmOpen,
2533                                                 FALSE, TRUE );
2534                                 gtk_ctree_node_set_row_data(clist, nodeEMail, email );
2535                         }
2536                         flgFirst = FALSE;
2537                         haveAddr = TRUE;
2538                 }
2539                 if( ! haveAddr ) {
2540                         /* Have name without EMail */
2541                         text[COL_NAME] = ADDRITEM_NAME(person);
2542                         text[COL_ADDRESS] = NULL;
2543                         text[COL_REMARKS] = NULL;
2544                         nodePerson = gtk_ctree_insert_node(
2545                                         clist, NULL, NULL,
2546                                         text, FOLDER_SPACING,
2547                                         atci->iconXpm, atci->maskXpm,
2548                                         atci->iconXpmOpen, atci->maskXpmOpen,
2549                                         FALSE, person->isOpened );
2550                         gtk_ctree_node_set_row_data(clist, nodePerson, person );
2551                 }
2552                 gtk_sctree_sort_node(GTK_CTREE(clist), NULL);
2553         }
2554         /* Free up the list */
2555         mgu_clear_list( items );
2556         g_list_free( items );
2557 }
2558
2559 static void addressbook_folder_load_group( GtkCTree *clist, ItemFolder *itemFolder ) {
2560         GList *items;
2561         AddressTypeControlItem *atci =  addrbookctl_lookup( ADDR_ITEM_GROUP );
2562
2563         /* Load any groups */
2564         if( ! atci ) return;
2565         items = addritem_folder_get_group_list( itemFolder );
2566         for( ; items != NULL; items = g_list_next( items ) ) {
2567                 GtkCTreeNode *nodeGroup = NULL;
2568                 gchar *text[N_COLS];
2569                 ItemGroup *group = items->data;
2570                 if( group == NULL ) continue;
2571                 text[COL_NAME] = ADDRITEM_NAME(group);
2572                 text[COL_ADDRESS] = NULL;
2573                 text[COL_REMARKS] = NULL;
2574                 nodeGroup = gtk_ctree_insert_node(clist, NULL, NULL,
2575                                       text, FOLDER_SPACING,
2576                                       atci->iconXpm, atci->maskXpm,
2577                                       atci->iconXpmOpen, atci->maskXpmOpen,
2578                                       FALSE, FALSE);
2579                 gtk_ctree_node_set_row_data(clist, nodeGroup, group );
2580                 gtk_sctree_sort_node(clist, NULL);
2581         }
2582         /* Free up the list */
2583         mgu_clear_list( items );
2584         g_list_free( items );
2585 }
2586
2587 /*
2588 * Search ctree widget callback function.
2589 * Enter: pA Pointer to node.
2590 *        pB Pointer to data item being sought.
2591 * Return: Zero (0) if group found.
2592 */
2593 static int addressbook_treenode_find_group_cb( gconstpointer pA, gconstpointer pB ) {
2594         AddressObject *aoA;
2595
2596         aoA = ( AddressObject * ) pA;
2597         if( aoA->type == ADDR_ITEM_GROUP ) {
2598                 ItemGroup *group, *grp;
2599
2600                 grp = ADAPTER_GROUP(aoA)->itemGroup;
2601                 group = ( ItemGroup * ) pB;
2602                 if( grp == group ) return 0;    /* Found group */
2603         }
2604         return 1;
2605 }
2606
2607 /*
2608 * Search ctree widget callback function.
2609 * Enter: pA Pointer to node.
2610 *        pB Pointer to data item being sought.
2611 * Return: Zero (0) if folder found.
2612 */
2613 static int addressbook_treenode_find_folder_cb( gconstpointer pA, gconstpointer pB ) {
2614         AddressObject *aoA;
2615
2616         aoA = ( AddressObject * ) pA;
2617         if( aoA->type == ADDR_ITEM_FOLDER ) {
2618                 ItemFolder *folder, *fld;
2619
2620                 fld = ADAPTER_FOLDER(aoA)->itemFolder;
2621                 folder = ( ItemFolder * ) pB;
2622                 if( fld == folder ) return 0;   /* Found folder */
2623         }
2624         return 1;
2625 }
2626
2627 /*
2628 * Remove folder and group nodes from tree widget for items contained ("cut")
2629 * in clipboard.
2630 */
2631 static void addressbook_treenode_remove_item( void ) {
2632         GList *node;
2633         AddrSelectItem *cutItem;
2634         AddressCache *cache;
2635         AddrItemObject *aio;
2636         GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
2637         GtkCTreeNode *tn;
2638
2639         node = _clipBoard_->objectList;
2640         while( node ) {
2641                 cutItem = node->data;
2642                 node = g_list_next( node );
2643                 cache = addrindex_get_cache(
2644                         _clipBoard_->addressIndex, cutItem->cacheID );
2645                 if( cache == NULL ) continue;
2646                 aio = addrcache_get_object( cache, cutItem->uid );
2647                 if( aio ) {
2648                         tn = NULL;
2649                         if( ADDRITEM_TYPE(aio) == ITEMTYPE_FOLDER ) {
2650                                 ItemFolder *folder;
2651
2652                                 folder = ( ItemFolder * ) aio;
2653                                 tn = gtk_ctree_find_by_row_data_custom(
2654                                         ctree, NULL, folder,
2655                                         addressbook_treenode_find_folder_cb );
2656                         }
2657                         else if( ADDRITEM_TYPE(aio) == ITEMTYPE_GROUP ) {
2658                                 ItemGroup *group;
2659
2660                                 group = ( ItemGroup * ) aio;
2661                                 tn = gtk_ctree_find_by_row_data_custom(
2662                                         ctree, NULL, group,
2663                                         addressbook_treenode_find_group_cb );
2664                         }
2665
2666                         if( tn ) {
2667                                 /* Free up adapter and remove node. */
2668                                 gtk_ctree_remove_node( ctree, tn );
2669                         }
2670                 }
2671         }
2672 }
2673
2674 /*
2675 * Find parent datasource for specified tree node.
2676 * Enter: node Node to test.
2677 * Return: Data source, or NULL if not found.
2678 */
2679 static AddressDataSource *addressbook_find_datasource( GtkCTreeNode *node ) {
2680         AddressDataSource *ds = NULL;
2681         AddressObject *ao;
2682
2683         g_return_val_if_fail(addrbook.ctree != NULL, NULL);
2684
2685         while( node ) {
2686                 if( GTK_CTREE_ROW(node)->level < 2 ) return NULL;
2687                 ao = gtk_ctree_node_get_row_data( GTK_CTREE(addrbook.ctree), node );
2688                 if( ao ) {
2689                         /* printf( "ao->type = %d\n", ao->type ); */
2690                         if( ao->type == ADDR_DATASOURCE ) {
2691                                 AdapterDSource *ads = ADAPTER_DSOURCE(ao);
2692                                 /* printf( "found it\n" ); */
2693                                 ds = ads->dataSource;
2694                                 break;
2695                         }
2696                 }
2697                 node = GTK_CTREE_ROW(node)->parent;
2698         }
2699         return ds;
2700 }
2701
2702 /*
2703 * Load address list widget with children of specified object.
2704 * Enter: obj    Parent object to be loaded.
2705 */
2706 static void addressbook_set_clist( AddressObject *obj ) {
2707         GtkCTree *ctreelist = GTK_CTREE(addrbook.clist);
2708         GtkCList *clist = GTK_CLIST(addrbook.clist);
2709         AddressDataSource *ds = NULL;
2710         AdapterDSource *ads = NULL;
2711
2712         if( obj == NULL ) {
2713                 gtk_clist_clear(clist);
2714                 return;
2715         }
2716
2717         if( obj->type == ADDR_INTERFACE ) {
2718                 /* printf( "set_clist: loading datasource...\n" ); */
2719                 /* addressbook_node_load_datasource( GTK_CTREE(clist), obj ); */
2720                 return;
2721         }
2722
2723         gtk_clist_freeze(clist);
2724         gtk_clist_clear(clist);
2725
2726         if( obj->type == ADDR_DATASOURCE ) {
2727                 ads = ADAPTER_DSOURCE(obj);
2728                 ds = ADAPTER_DSOURCE(obj)->dataSource;
2729                 if( ds ) {
2730                         /* Load root folder */
2731                         ItemFolder *rootFolder = NULL;
2732                         rootFolder = addrindex_ds_get_root_folder( ds );
2733                         addressbook_folder_load_person( ctreelist, addrindex_ds_get_root_folder( ds ) );
2734                         addressbook_folder_load_group( ctreelist, addrindex_ds_get_root_folder( ds ) );
2735                 }
2736         }
2737         else {
2738                 if( obj->type == ADDR_ITEM_GROUP ) {
2739                         /* Load groups */
2740                         ItemGroup *itemGroup = ADAPTER_GROUP(obj)->itemGroup;
2741                         addressbook_load_group( ctreelist, itemGroup );
2742                 }
2743                 else if( obj->type == ADDR_ITEM_FOLDER ) {
2744                         /* Load folders */
2745                         ItemFolder *itemFolder = ADAPTER_FOLDER(obj)->itemFolder;
2746                         addressbook_folder_load_person( ctreelist, itemFolder );
2747                         addressbook_folder_load_group( ctreelist, itemFolder );
2748                 }
2749         }
2750         /* gtk_clist_sort(clist); */
2751         gtk_clist_thaw(clist);
2752 }
2753
2754 /*
2755 * Call back function to free adaptor. Call back is setup by function
2756 * gtk_ctree_node_set_row_data_full() when node is populated. This function is
2757 * called when the address book tree widget node is removed by calling
2758 * function gtk_ctree_remove_node().
2759 * Enter: data Tree node's row data.
2760 */
2761 static void addressbook_free_treenode( gpointer data ) {
2762         AddressObject *ao;
2763
2764         ao = ( AddressObject * ) data;
2765         if( ao == NULL ) return;
2766         if( ao->type == ADDR_INTERFACE ) {
2767                 AdapterInterface *ai = ADAPTER_INTERFACE(ao);
2768                 addrbookctl_free_interface( ai );
2769         }
2770         else if( ao->type == ADDR_DATASOURCE ) {
2771                 AdapterDSource *ads = ADAPTER_DSOURCE(ao);
2772                 addrbookctl_free_datasource( ads );
2773         }
2774         else if( ao->type == ADDR_ITEM_FOLDER ) {
2775                 AdapterFolder *af = ADAPTER_FOLDER(ao);
2776                 addrbookctl_free_folder( af );
2777         }
2778         else if( ao->type == ADDR_ITEM_GROUP ) {
2779                 AdapterGroup *ag = ADAPTER_GROUP(ao);
2780                 addrbookctl_free_group( ag );
2781         }
2782 }
2783
2784 /*
2785 * Create new adaptor for specified data source.
2786 */
2787 AdapterDSource *addressbook_create_ds_adapter( AddressDataSource *ds,
2788                                 AddressObjectType otype, gchar *name )
2789 {
2790         AdapterDSource *adapter = g_new0( AdapterDSource, 1 );
2791         ADDRESS_OBJECT(adapter)->type = ADDR_DATASOURCE;
2792         ADDRESS_OBJECT_NAME(adapter) = g_strdup( name );
2793         adapter->dataSource = ds;
2794         adapter->subType = otype;
2795         return adapter;
2796 }
2797
2798 void addressbook_ads_set_name( AdapterDSource *adapter, gchar *value ) {
2799         ADDRESS_OBJECT_NAME(adapter) = mgu_replace_string( ADDRESS_OBJECT_NAME(adapter), value );
2800 }
2801
2802 /*
2803  * Load tree from address index with the initial data.
2804  */
2805 static void addressbook_load_tree( void ) {
2806         GtkCTree *ctree = GTK_CTREE( addrbook.ctree );
2807         GList *nodeIf, *nodeDS;
2808         AdapterInterface *adapter;
2809         AddressInterface *iface;
2810         AddressTypeControlItem *atci;
2811         AddressDataSource *ds;
2812         AdapterDSource *ads;
2813         GtkCTreeNode *node, *newNode;
2814         gchar *name;
2815
2816         nodeIf = _addressInterfaceList_;
2817         while( nodeIf ) {
2818                 adapter = nodeIf->data;
2819                 node = adapter->treeNode;
2820                 iface = adapter->interface;
2821                 atci = adapter->atci;
2822                 if( iface ) {
2823                         if( iface->useInterface ) {
2824                                 /* Load data sources below interface node */
2825                                 nodeDS = iface->listSource;
2826                                 while( nodeDS ) {
2827                                         ds = nodeDS->data;
2828                                         newNode = NULL;
2829                                         name = addrindex_ds_get_name( ds );
2830                                         ads = addressbook_create_ds_adapter( ds, atci->objectType, name );
2831                                         newNode = addressbook_add_object( node, ADDRESS_OBJECT(ads) );
2832                                         nodeDS = g_list_next( nodeDS );
2833                                 }
2834                                 gtk_ctree_expand( ctree, node );
2835                         }
2836                 }
2837                 nodeIf = g_list_next( nodeIf );
2838         }
2839 }
2840
2841 /*
2842  * Convert the old address book to new format.
2843  */
2844 static gboolean addressbook_convert( AddressIndex *addrIndex ) {
2845         gboolean retVal = FALSE;
2846         gboolean errFlag = TRUE;
2847         gchar *msg = NULL;
2848
2849         /* Read old address book, performing conversion */
2850         debug_print( "Reading and converting old address book...\n" );
2851         addrindex_set_file_name( addrIndex, ADDRESSBOOK_OLD_FILE );
2852         addrindex_read_data( addrIndex );
2853         if( addrIndex->retVal == MGU_NO_FILE ) {
2854                 /* We do not have a file - new user */
2855                 debug_print( "New user... create new books...\n" );
2856                 addrindex_create_new_books( addrIndex );
2857                 if( addrIndex->retVal == MGU_SUCCESS ) {
2858                         /* Save index file */
2859                         addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2860                         addrindex_save_data( addrIndex );
2861                         if( addrIndex->retVal == MGU_SUCCESS ) {
2862                                 retVal = TRUE;
2863                                 errFlag = FALSE;
2864                         }
2865                         else {
2866                                 msg = _( "New user, could not save index file." );
2867                         }
2868                 }
2869                 else {
2870                         msg = _( "New user, could not save address book files." );
2871                 }
2872         }
2873         else {
2874                 /* We have an old file */
2875                 if( addrIndex->wasConverted ) {
2876                         /* Converted successfully - save address index */
2877                         addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2878                         addrindex_save_data( addrIndex );
2879                         if( addrIndex->retVal == MGU_SUCCESS ) {
2880                                 msg = _( "Old address book converted successfully." );
2881                                 retVal = TRUE;
2882                                 errFlag = FALSE;
2883                         }
2884                         else {
2885                                 msg = _("Old address book converted,\n"
2886                                         "could not save new address index file" );
2887                         }
2888                 }
2889                 else {
2890                         /* File conversion failed - just create new books */
2891                         debug_print( "File conversion failed... just create new books...\n" );
2892                         addrindex_create_new_books( addrIndex );
2893                         if( addrIndex->retVal == MGU_SUCCESS ) {
2894                                 /* Save index */
2895                                 addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2896                                 addrindex_save_data( addrIndex );
2897                                 if( addrIndex->retVal == MGU_SUCCESS ) {
2898                                         msg = _("Could not convert address book,\n"
2899                                                 "but created empty new address book files." );
2900                                         retVal = TRUE;
2901                                         errFlag = FALSE;
2902                                 }
2903                                 else {
2904                                         msg = _("Could not convert address book,\n"
2905                                                 "could not create new address book files." );
2906                                 }
2907                         }
2908                         else {
2909                                 msg = _("Could not convert address book\n"
2910                                         "and could not create new address book files." );
2911                         }
2912                 }
2913         }
2914         if( errFlag ) {
2915                 debug_print( "Error\n%s\n", msg );
2916                 alertpanel( _( "Addressbook conversion error" ), msg, _( "Close" ), NULL, NULL );
2917         }
2918         else if( msg ) {
2919                 debug_print( "Warning\n%s\n", msg );
2920                 alertpanel( _( "Addressbook conversion" ), msg, _( "Close" ), NULL, NULL );
2921         }
2922
2923         return retVal;
2924 }
2925
2926 void addressbook_read_file( void ) {
2927         AddressIndex *addrIndex = NULL;
2928
2929         debug_print( "Reading address index...\n" );
2930         if( _addressIndex_ ) {
2931                 debug_print( "address book already read!!!\n" );
2932                 return;
2933         }
2934
2935         addrIndex = addrindex_create_index();
2936
2937         /* Use new address book index. */
2938         addrindex_set_file_path( addrIndex, get_rc_dir() );
2939         addrindex_set_file_name( addrIndex, ADDRESSBOOK_INDEX_FILE );
2940         addrindex_read_data( addrIndex );
2941         if( addrIndex->retVal == MGU_NO_FILE ) {
2942                 /* Conversion required */
2943                 debug_print( "Converting...\n" );
2944                 if( addressbook_convert( addrIndex ) ) {
2945                         _addressIndex_ = addrIndex;
2946                 }
2947         }
2948         else if( addrIndex->retVal == MGU_SUCCESS ) {
2949                 _addressIndex_ = addrIndex;
2950         }
2951         else {
2952                 /* Error reading address book */
2953                 debug_print( "Could not read address index.\n" );
2954                 addrindex_print_index( addrIndex, stdout );
2955                 alertpanel( _( "Addressbook Error" ),
2956                             _( "Could not read address index" ),
2957                             _( "Close" ), NULL, NULL );
2958         }
2959         debug_print( "done.\n" );
2960 }
2961
2962 /*
2963 * Add object into the address index tree widget.
2964 * Enter: node   Parent node.
2965 *        obj    Object to add.
2966 * Return: Node that was added, or NULL if object not added.
2967 */
2968 static GtkCTreeNode *addressbook_add_object(GtkCTreeNode *node,
2969                                             AddressObject *obj)
2970 {
2971         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
2972         GtkCTreeNode *added;
2973         AddressObject *pobj;
2974         AddressObjectType otype;
2975         AddressTypeControlItem *atci = NULL;
2976
2977         g_return_val_if_fail(node != NULL, NULL);
2978         g_return_val_if_fail(obj  != NULL, NULL);
2979
2980         pobj = gtk_ctree_node_get_row_data(ctree, node);
2981         g_return_val_if_fail(pobj != NULL, NULL);
2982
2983         /* Determine object type to be displayed */
2984         if( obj->type == ADDR_DATASOURCE ) {
2985                 otype = ADAPTER_DSOURCE(obj)->subType;
2986         }
2987         else {
2988                 otype = obj->type;
2989         }
2990
2991         /* Handle any special conditions. */
2992         added = node;
2993         atci = addrbookctl_lookup( otype );
2994         if( atci ) {
2995                 if( atci->showInTree ) {
2996                         /* Add object to tree */
2997                         gchar **name;
2998                         name = &obj->name;
2999                         added = gtk_ctree_insert_node( ctree, node, NULL, name, FOLDER_SPACING,
3000                                 atci->iconXpm, atci->maskXpm, atci->iconXpmOpen, atci->maskXpmOpen,
3001                                 atci->treeLeaf, atci->treeExpand );
3002                         gtk_ctree_node_set_row_data_full( ctree, added, obj,
3003                                 addressbook_free_treenode );
3004                 }
3005         }
3006
3007         gtk_sctree_sort_node(ctree, node);
3008
3009         return added;
3010 }
3011
3012 /*
3013 * Add group into the address index tree.
3014 * Enter: node      Parent node.
3015 *        ds        Data source.
3016 *        itemGroup Group to add.
3017 * Return: Inserted node.
3018 */
3019 static GtkCTreeNode *addressbook_node_add_group( GtkCTreeNode *node, AddressDataSource *ds, ItemGroup *itemGroup ) {
3020         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3021         GtkCTreeNode *newNode;
3022         AdapterGroup *adapter;
3023         AddressTypeControlItem *atci = NULL;
3024         gchar **name;
3025
3026         if( ds == NULL ) return NULL;
3027         if( node == NULL || itemGroup == NULL ) return NULL;
3028
3029         name = &itemGroup->obj.name;
3030
3031         atci = addrbookctl_lookup( ADDR_ITEM_GROUP );
3032
3033         adapter = g_new0( AdapterGroup, 1 );
3034         ADDRESS_OBJECT_TYPE(adapter) = ADDR_ITEM_GROUP;
3035         ADDRESS_OBJECT_NAME(adapter) = g_strdup( ADDRITEM_NAME(itemGroup) );
3036         adapter->itemGroup = itemGroup;
3037
3038         newNode = gtk_ctree_insert_node( ctree, node, NULL, name, FOLDER_SPACING,
3039                         atci->iconXpm, atci->maskXpm, atci->iconXpm, atci->maskXpm,
3040                         atci->treeLeaf, atci->treeExpand );
3041         gtk_ctree_node_set_row_data_full( ctree, newNode, adapter,
3042                 addressbook_free_treenode );
3043         gtk_sctree_sort_node( ctree, node );
3044         return newNode;
3045 }
3046
3047 /*
3048 * Add folder into the address index tree.
3049 * Enter: node       Parent node.
3050 *        ds         Data source.
3051 *        itemFolder Folder to add.
3052 *        otype      Object type to display.
3053 * Return: Inserted node.
3054 */
3055 static GtkCTreeNode *addressbook_node_add_folder(
3056                 GtkCTreeNode *node, AddressDataSource *ds, ItemFolder *itemFolder, AddressObjectType otype )
3057 {
3058         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3059         GtkCTreeNode *newNode = NULL;
3060         AdapterFolder *adapter;
3061         AddressTypeControlItem *atci = NULL;
3062         GList *listItems = NULL;
3063         gchar **name;
3064         ItemFolder *rootFolder;
3065
3066         if( ds == NULL ) return NULL;
3067         if( node == NULL || itemFolder == NULL ) return NULL;
3068
3069         /* Determine object type */
3070         atci = addrbookctl_lookup( otype );
3071         if( atci == NULL ) return NULL;
3072
3073         rootFolder = addrindex_ds_get_root_folder( ds );
3074         if( itemFolder == rootFolder ) {
3075                 newNode = node;
3076         }
3077         else {
3078                 name = &itemFolder->obj.name;
3079
3080                 adapter = g_new0( AdapterFolder, 1 );
3081                 ADDRESS_OBJECT_TYPE(adapter) = ADDR_ITEM_FOLDER;
3082                 ADDRESS_OBJECT_NAME(adapter) = g_strdup( ADDRITEM_NAME(itemFolder) );
3083                 adapter->itemFolder = itemFolder;
3084
3085                 newNode = gtk_ctree_insert_node( ctree, node, NULL, name, FOLDER_SPACING,
3086                                 atci->iconXpm, atci->maskXpm, atci->iconXpm, atci->maskXpm,
3087                                 atci->treeLeaf, atci->treeExpand );
3088                 gtk_ctree_node_set_row_data_full( ctree, newNode, adapter,
3089                         addressbook_free_treenode );
3090         }
3091
3092         listItems = itemFolder->listFolder;
3093         while( listItems ) {
3094                 ItemFolder *item = listItems->data;
3095                 addressbook_node_add_folder( newNode, ds, item, otype );
3096                 listItems = g_list_next( listItems );
3097         }
3098         listItems = itemFolder->listGroup;
3099         while( listItems ) {
3100                 ItemGroup *item = listItems->data;
3101                 addressbook_node_add_group( newNode, ds, item );
3102                 listItems = g_list_next( listItems );
3103         }
3104         gtk_sctree_sort_node( ctree, node );
3105         return newNode;
3106 }
3107
3108 void addressbook_export_to_file( void ) {
3109         if( _addressIndex_ ) {
3110                 /* Save all new address book data */
3111                 debug_print( "Saving address books...\n" );
3112                 addrindex_save_all_books( _addressIndex_ );
3113
3114                 debug_print( "Exporting addressbook to file...\n" );
3115                 addrindex_save_data( _addressIndex_ );
3116                 if( _addressIndex_->retVal != MGU_SUCCESS ) {
3117                         addrindex_print_index( _addressIndex_, stdout );
3118                 }
3119
3120                 /* Notify address completion of new data */
3121                 invalidate_address_completion();
3122         }
3123 }
3124
3125 static void key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
3126 {
3127         if (event && event->keyval == GDK_Escape)
3128                 addressbook_close();
3129 }
3130
3131 /*
3132 * Comparison using cell contents (text in first column). Used for sort
3133 * address index widget.
3134 */
3135 static gint addressbook_treenode_compare_func(
3136         GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2 )
3137 {
3138         GtkCell *cell1 = ((GtkCListRow *)ptr1)->cell;
3139         GtkCell *cell2 = ((GtkCListRow *)ptr2)->cell;
3140         gchar *name1 = NULL, *name2 = NULL;
3141         if( cell1 ) name1 = cell1->u.text;
3142         if( cell2 ) name2 = cell2->u.text;
3143         if( ! name1 ) return ( name2 != NULL );
3144         if( ! name2 ) return -1;
3145         return strcasecmp( name1, name2 );
3146 }
3147
3148 /*
3149 * Comparison using object names and types.
3150 */
3151 static gint addressbook_list_compare_func(
3152         GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2 )
3153 {
3154         AddrItemObject *aio1 = ((GtkCListRow *)ptr1)->data;
3155         AddrItemObject *aio2 = ((GtkCListRow *)ptr2)->data;
3156         gchar *name1 = NULL, *name2 = NULL;
3157
3158         /* Order by cell contents */
3159         name1 = ADDRITEM_NAME( aio1 );
3160         name2 = ADDRITEM_NAME( aio2 );
3161
3162         if( aio1->type == aio2->type ) {
3163                 /* Order by name */
3164                 if( ! name1 ) return ( name2 != NULL );
3165                 if( ! name2 ) return -1;
3166                 return strcasecmp( name1, name2 );
3167         }
3168         else {
3169                 /* Order groups before person */
3170                 if( aio1->type == ITEMTYPE_GROUP ) {
3171                         return -1;
3172                 }
3173                 else if( aio2->type == ITEMTYPE_GROUP ) {
3174                         return 1;
3175                 }
3176                 return 0;
3177         }
3178 }
3179
3180 static void addressbook_new_book_cb( gpointer data, guint action, GtkWidget *widget ) {
3181         AdapterDSource *ads;
3182         AdapterInterface *adapter;
3183         GtkCTreeNode *newNode;
3184
3185         adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3186         if( adapter == NULL ) return;
3187         ads = addressbook_edit_book( _addressIndex_, NULL );
3188         if( ads ) {
3189                 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3190                 if( newNode ) {
3191                         gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3192                         addrbook.treeSelected = newNode;
3193                 }
3194         }
3195 }
3196
3197 static void addressbook_new_vcard_cb( gpointer data, guint action, GtkWidget *widget ) {
3198         AdapterDSource *ads;
3199         AdapterInterface *adapter;
3200         GtkCTreeNode *newNode;
3201
3202         adapter = addrbookctl_find_interface( ADDR_IF_VCARD );
3203         if( adapter == NULL ) return;
3204         ads = addressbook_edit_vcard( _addressIndex_, NULL );
3205         if( ads ) {
3206                 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3207                 if( newNode ) {
3208                         gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3209                         addrbook.treeSelected = newNode;
3210                 }
3211         }
3212 }
3213
3214 #ifdef USE_JPILOT
3215 static void addressbook_new_jpilot_cb( gpointer data, guint action, GtkWidget *widget ) {
3216         AdapterDSource *ads;
3217         AdapterInterface *adapter;
3218         AddressInterface *iface;
3219         GtkCTreeNode *newNode;
3220
3221         adapter = addrbookctl_find_interface( ADDR_IF_JPILOT );
3222         if( adapter == NULL ) return;
3223         iface = adapter->interface;
3224         if( ! iface->haveLibrary ) return;
3225         ads = addressbook_edit_jpilot( _addressIndex_, NULL );
3226         if( ads ) {
3227                 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3228                 if( newNode ) {
3229                         gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3230                         addrbook.treeSelected = newNode;
3231                 }
3232         }
3233 }
3234 #endif
3235
3236 #ifdef USE_LDAP
3237 static void addressbook_new_ldap_cb( gpointer data, guint action, GtkWidget *widget ) {
3238         AdapterDSource *ads;
3239         AdapterInterface *adapter;
3240         AddressInterface *iface;
3241         GtkCTreeNode *newNode;
3242
3243         adapter = addrbookctl_find_interface( ADDR_IF_LDAP );
3244         if( adapter == NULL ) return;
3245         iface = adapter->interface;
3246         if( ! iface->haveLibrary ) return;
3247         ads = addressbook_edit_ldap( _addressIndex_, NULL );
3248         if( ads ) {
3249                 newNode = addressbook_add_object( adapter->treeNode, ADDRESS_OBJECT(ads) );
3250                 if( newNode ) {
3251                         gtk_ctree_select( GTK_CTREE(addrbook.ctree), newNode );
3252                         addrbook.treeSelected = newNode;
3253                 }
3254         }
3255 }
3256
3257 static void addressbook_ldap_show_message( SyldapServer *svr ) {
3258         gchar *name;
3259         gchar *desc;
3260         *addressbook_msgbuf = '\0';
3261         if( svr ) {
3262                 name = syldap_get_name( svr );
3263                 if( svr->busyFlag ) {
3264                         g_snprintf( addressbook_msgbuf,
3265                                     sizeof(addressbook_msgbuf), "%s: %s", name,
3266                                     ADDRESSBOOK_LDAP_BUSYMSG );
3267                 }
3268                 else {
3269                         if( svr->retVal == MGU_SUCCESS ) {
3270                                 g_snprintf( addressbook_msgbuf,
3271                                             sizeof(addressbook_msgbuf), "%s",
3272                                             name );
3273                         }
3274                         else {
3275                                 desc = addressbook_err2string(
3276                                                 _lutErrorsLDAP_, svr->retVal );
3277                                 g_snprintf( addressbook_msgbuf,
3278                                             sizeof(addressbook_msgbuf),
3279                                             "%s: %s", name, desc );
3280                         }
3281                 }
3282         }
3283         addressbook_status_show( addressbook_msgbuf );
3284 }
3285
3286 static void addressbook_ldap_show_results( SyldapServer *sls ) {
3287         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3288         AddressObject *obj;
3289         AdapterDSource *ads = NULL;
3290         AddressDataSource *ds = NULL;
3291         AddressInterface *iface = NULL;
3292
3293         if( sls == NULL ) return;
3294         if( ! addrbook.treeSelected ) return;
3295         if( GTK_CTREE_ROW( addrbook.treeSelected )->level == 1 ) return;
3296
3297         obj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
3298         if( obj == NULL ) return;
3299         if( obj->type == ADDR_DATASOURCE ) {
3300                 ads = ADAPTER_DSOURCE(obj);
3301                 if( ads->subType == ADDR_LDAP ) {
3302                         SyldapServer *server;
3303
3304                         ds = ads->dataSource;
3305                         if( ds == NULL ) return;
3306                         iface = ds->interface;
3307                         if( ! iface->haveLibrary ) return;
3308                         server = ds->rawDataSource;
3309                         if( server == sls ) {
3310                                 /* Read from cache */
3311                                 gtk_widget_show_all(addrbook.window);
3312                                 addressbook_set_clist( obj );
3313                                 addressbook_ldap_show_message( sls );
3314                                 gtk_widget_show_all(addrbook.window);
3315                                 gtk_entry_set_text( GTK_ENTRY(addrbook.entry), "" );
3316                         }
3317                 }
3318         }
3319 }
3320
3321 /*
3322  * LDAP idle function. This function is called during UI idle time while
3323  * an LDAP search is in progress.
3324  * Enter: data Reference to LDAP server object.
3325  */
3326 static void addressbook_ldap_idle( gpointer data ) {
3327         SyldapServer *server;
3328
3329         server = ( SyldapServer * ) data;
3330         if( ! server->busyFlag ) {
3331                 /* Server has completed search - remove from idle list */
3332                 gtk_idle_remove( server->idleId );
3333
3334                 /* Process callback and free up the thread */
3335                 addressbook_ldap_show_results( server );
3336                 g_free( server->thread );
3337                 server->thread = NULL;
3338         }
3339 }
3340
3341 /*
3342  * Perform lookup for LDAP search.
3343  * Enter: ads     Adapter for data source.
3344  *        sLookup Lookup string.
3345  */
3346 static void addressbook_ldap_lookup( AdapterDSource *ads, gchar *sLookup ) {
3347         AddressDataSource *ds = NULL;
3348         AddressInterface *iface = NULL;
3349         SyldapServer *server;
3350
3351         ds = ads->dataSource;
3352         if( ds == NULL ) return;
3353         iface = ds->interface;
3354         if( ! iface->haveLibrary ) return;
3355         server = ds->rawDataSource;
3356         if( server ) {
3357                 syldap_cancel_read( server );
3358                 if( *sLookup == '\0' || strlen( sLookup ) < 1 ) return;
3359                 syldap_set_search_value( server, sLookup );
3360                 server->idleId = gtk_idle_add(
3361                         ( GtkFunction ) addressbook_ldap_idle, server );
3362                 syldap_read_data_th( server );
3363                 addressbook_ldap_show_message( server );
3364         }
3365 }
3366 #endif
3367
3368 /*
3369  * Lookup button handler.
3370  */
3371 static void addressbook_lup_clicked( GtkButton *button, gpointer data ) {
3372         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3373         AddressObject *obj;
3374         AdapterDSource *ads = NULL;
3375         gchar *sLookup;
3376
3377         if( ! addrbook.treeSelected ) return;
3378         if( GTK_CTREE_ROW( addrbook.treeSelected )->level == 1 ) return;
3379
3380         obj = gtk_ctree_node_get_row_data( ctree, addrbook.treeSelected );
3381         if( obj == NULL ) return;
3382
3383         sLookup = gtk_editable_get_chars( GTK_EDITABLE(addrbook.entry), 0, -1 );
3384         g_strchomp( sLookup );
3385
3386         if( obj->type == ADDR_DATASOURCE ) {
3387                 ads = ADAPTER_DSOURCE(obj);
3388 #ifdef USE_LDAP
3389                 if( ads->subType == ADDR_LDAP ) {
3390                         addressbook_ldap_lookup( ads, sLookup );
3391                 }
3392 #endif /* USE_LDAP */
3393         }
3394
3395         g_free( sLookup );
3396 }
3397
3398 /* **********************************************************************
3399 * Build lookup tables.
3400 * ***********************************************************************
3401 */
3402
3403 /*
3404  * Remap object types.
3405  * Enter:  abType AddressObjectType (used in tree node).
3406  * Return: ItemObjectType (used in address cache data).
3407  */
3408 ItemObjectType addressbook_type2item( AddressObjectType abType ) {
3409         ItemObjectType ioType;
3410
3411         switch( abType ) {
3412                 case ADDR_ITEM_PERSON: ioType = ITEMTYPE_PERSON;     break;
3413                 case ADDR_ITEM_EMAIL:  ioType = ITEMTYPE_EMAIL;      break;
3414                 case ADDR_ITEM_FOLDER: ioType = ITEMTYPE_FOLDER;     break;
3415                 case ADDR_ITEM_GROUP:  ioType = ITEMTYPE_GROUP;      break;
3416                 case ADDR_DATASOURCE:  ioType = ITEMTYPE_DATASOURCE; break;
3417                 default:               ioType = ITEMTYPE_NONE;       break;
3418         }
3419         return ioType;
3420 }
3421
3422 /*
3423 * Build table that controls the rendering of object types.
3424 */
3425 void addrbookctl_build_map( GtkWidget *window ) {
3426         AddressTypeControlItem *atci;
3427
3428         /* Build icons */
3429         stock_pixmap_gdk(window, STOCK_PIXMAP_DIR_CLOSE, &folderxpm, &folderxpmmask);
3430         stock_pixmap_gdk(window, STOCK_PIXMAP_DIR_OPEN, &folderopenxpm, &folderopenxpmmask);
3431         stock_pixmap_gdk(window, STOCK_PIXMAP_GROUP, &groupxpm, &groupxpmmask);
3432         stock_pixmap_gdk(window, STOCK_PIXMAP_VCARD, &vcardxpm, &vcardxpmmask);
3433         stock_pixmap_gdk(window, STOCK_PIXMAP_BOOK, &bookxpm, &bookxpmmask);
3434         stock_pixmap_gdk(window, STOCK_PIXMAP_ADDRESS, &addressxpm, &addressxpmmask);
3435         stock_pixmap_gdk(window, STOCK_PIXMAP_JPILOT, &jpilotxpm, &jpilotxpmmask);
3436         stock_pixmap_gdk(window, STOCK_PIXMAP_CATEGORY, &categoryxpm, &categoryxpmmask);
3437         stock_pixmap_gdk(window, STOCK_PIXMAP_LDAP, &ldapxpm, &ldapxpmmask);
3438
3439         _addressBookTypeHash_ = g_hash_table_new( g_int_hash, g_int_equal );
3440         _addressBookTypeList_ = NULL;
3441
3442         /* Interface */
3443         atci = g_new0( AddressTypeControlItem, 1 );
3444         atci->objectType = ADDR_INTERFACE;
3445         atci->interfaceType = ADDR_IF_NONE;
3446         atci->showInTree = TRUE;
3447         atci->treeExpand = TRUE;
3448         atci->treeLeaf = FALSE;
3449         atci->displayName = _( "Interface" );
3450         atci->iconXpm = folderxpm;
3451         atci->maskXpm = folderxpmmask;
3452         atci->iconXpmOpen = folderopenxpm;
3453         atci->maskXpmOpen = folderopenxpmmask;
3454         atci->menuCommand = NULL;
3455         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3456         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3457
3458         /* Address book */
3459         atci = g_new0( AddressTypeControlItem, 1 );
3460         atci->objectType = ADDR_BOOK;
3461         atci->interfaceType = ADDR_IF_BOOK;
3462         atci->showInTree = TRUE;
3463         atci->treeExpand = TRUE;
3464         atci->treeLeaf = FALSE;
3465         atci->displayName = _( "Address Book" );
3466         atci->iconXpm = bookxpm;
3467         atci->maskXpm = bookxpmmask;
3468         atci->iconXpmOpen = bookxpm;
3469         atci->maskXpmOpen = bookxpmmask;
3470         atci->menuCommand = "/File/New Book";
3471         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3472         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3473
3474         /* Item person */
3475         atci = g_new0( AddressTypeControlItem, 1 );
3476         atci->objectType = ADDR_ITEM_PERSON;
3477         atci->interfaceType = ADDR_IF_NONE;
3478         atci->showInTree = FALSE;
3479         atci->treeExpand = FALSE;
3480         atci->treeLeaf = FALSE;
3481         atci->displayName = _( "Person" );
3482         atci->iconXpm = NULL;
3483         atci->maskXpm = NULL;
3484         atci->iconXpmOpen = NULL;
3485         atci->maskXpmOpen = NULL;
3486         atci->menuCommand = NULL;
3487         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3488         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3489
3490         /* Item email */
3491         atci = g_new0( AddressTypeControlItem, 1 );
3492         atci->objectType = ADDR_ITEM_EMAIL;
3493         atci->interfaceType = ADDR_IF_NONE;
3494         atci->showInTree = FALSE;
3495         atci->treeExpand = FALSE;
3496         atci->treeLeaf = TRUE;
3497         atci->displayName = _( "EMail Address" );
3498         atci->iconXpm = addressxpm;
3499         atci->maskXpm = addressxpmmask;
3500         atci->iconXpmOpen = addressxpm;
3501         atci->maskXpmOpen = addressxpmmask;
3502         atci->menuCommand = NULL;
3503         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3504         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3505
3506         /* Item group */
3507         atci = g_new0( AddressTypeControlItem, 1 );
3508         atci->objectType = ADDR_ITEM_GROUP;
3509         atci->interfaceType = ADDR_IF_BOOK;
3510         atci->showInTree = TRUE;
3511         atci->treeExpand = FALSE;
3512         atci->treeLeaf = FALSE;
3513         atci->displayName = _( "Group" );
3514         atci->iconXpm = groupxpm;
3515         atci->maskXpm = groupxpmmask;
3516         atci->iconXpmOpen = groupxpm;
3517         atci->maskXpmOpen = groupxpmmask;
3518         atci->menuCommand = NULL;
3519         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3520         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3521
3522         /* Item folder */
3523         atci = g_new0( AddressTypeControlItem, 1 );
3524         atci->objectType = ADDR_ITEM_FOLDER;
3525         atci->interfaceType = ADDR_IF_BOOK;
3526         atci->showInTree = TRUE;
3527         atci->treeExpand = FALSE;
3528         atci->treeLeaf = FALSE;
3529         atci->displayName = _( "Folder" );
3530         atci->iconXpm = folderxpm;
3531         atci->maskXpm = folderxpmmask;
3532         atci->iconXpmOpen = folderopenxpm;
3533         atci->maskXpmOpen = folderopenxpmmask;
3534         atci->menuCommand = NULL;
3535         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3536         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3537
3538         /* vCard */
3539         atci = g_new0( AddressTypeControlItem, 1 );
3540         atci->objectType = ADDR_VCARD;
3541         atci->interfaceType = ADDR_IF_VCARD;
3542         atci->showInTree = TRUE;
3543         atci->treeExpand = TRUE;
3544         atci->treeLeaf = TRUE;
3545         atci->displayName = _( "vCard" );
3546         atci->iconXpm = vcardxpm;
3547         atci->maskXpm = vcardxpmmask;
3548         atci->iconXpmOpen = vcardxpm;
3549         atci->maskXpmOpen = vcardxpmmask;
3550         atci->menuCommand = "/File/New vCard";
3551         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3552         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3553
3554         /* J-Pilot */
3555         atci = g_new0( AddressTypeControlItem, 1 );
3556         atci->objectType = ADDR_JPILOT;
3557         atci->interfaceType = ADDR_IF_JPILOT;
3558         atci->showInTree = TRUE;
3559         atci->treeExpand = TRUE;
3560         atci->treeLeaf = FALSE;
3561         atci->displayName = _( "JPilot" );
3562         atci->iconXpm = jpilotxpm;
3563         atci->maskXpm = jpilotxpmmask;
3564         atci->iconXpmOpen = jpilotxpm;
3565         atci->maskXpmOpen = jpilotxpmmask;
3566         atci->menuCommand = "/File/New JPilot";
3567         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3568         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3569
3570         /* Category */
3571         atci = g_new0( AddressTypeControlItem, 1 );
3572         atci->objectType = ADDR_CATEGORY;
3573         atci->interfaceType = ADDR_IF_JPILOT;
3574         atci->showInTree = TRUE;
3575         atci->treeExpand = TRUE;
3576         atci->treeLeaf = TRUE;
3577         atci->displayName = _( "JPilot" );
3578         atci->iconXpm = categoryxpm;
3579         atci->maskXpm = categoryxpmmask;
3580         atci->iconXpmOpen = categoryxpm;
3581         atci->maskXpmOpen = categoryxpmmask;
3582         atci->menuCommand = NULL;
3583         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3584         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3585
3586         /* LDAP Server */
3587         atci = g_new0( AddressTypeControlItem, 1 );
3588         atci->objectType = ADDR_LDAP;
3589         atci->interfaceType = ADDR_IF_LDAP;
3590         atci->showInTree = TRUE;
3591         atci->treeExpand = TRUE;
3592         atci->treeLeaf = TRUE;
3593         atci->displayName = _( "LDAP Server" );
3594         atci->iconXpm = ldapxpm;
3595         atci->maskXpm = ldapxpmmask;
3596         atci->iconXpmOpen = ldapxpm;
3597         atci->maskXpmOpen = ldapxpmmask;
3598         atci->menuCommand = "/File/New Server";
3599         g_hash_table_insert( _addressBookTypeHash_, &atci->objectType, atci );
3600         _addressBookTypeList_ = g_list_append( _addressBookTypeList_, atci );
3601
3602 }
3603
3604 /*
3605 * Search for specified object type.
3606 */
3607 AddressTypeControlItem *addrbookctl_lookup( gint ot ) {
3608         gint objType = ot;
3609         return ( AddressTypeControlItem * ) g_hash_table_lookup( _addressBookTypeHash_, &objType );
3610 }
3611
3612 /*
3613 * Search for specified interface type.
3614 */
3615 AddressTypeControlItem *addrbookctl_lookup_iface( AddressIfType ifType ) {
3616         GList *node = _addressBookTypeList_;
3617         while( node ) {
3618                 AddressTypeControlItem *atci = node->data;
3619                 if( atci->interfaceType == ifType ) return atci;
3620                 node = g_list_next( node );
3621         }
3622         return NULL;
3623 }
3624
3625 static void addrbookctl_free_address( AddressObject *obj ) {
3626         g_free( obj->name );
3627         obj->type = ADDR_NONE;
3628         obj->name = NULL;
3629 }
3630
3631 static void addrbookctl_free_interface( AdapterInterface *adapter ) {
3632         addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3633         adapter->interface = NULL;
3634         adapter->interfaceType = ADDR_IF_NONE;
3635         adapter->atci = NULL;
3636         adapter->enabled = FALSE;
3637         adapter->haveLibrary = FALSE;
3638         adapter->treeNode = NULL;
3639         g_free( adapter );
3640 }
3641
3642 static void addrbookctl_free_datasource( AdapterDSource *adapter ) {
3643         addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3644         adapter->dataSource = NULL;
3645         adapter->subType = ADDR_NONE;
3646         g_free( adapter );
3647 }
3648
3649 static void addrbookctl_free_folder( AdapterFolder *adapter ) {
3650         addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3651         adapter->itemFolder = NULL;
3652         g_free( adapter );
3653 }
3654
3655 static void addrbookctl_free_group( AdapterGroup *adapter ) {
3656         addrbookctl_free_address( ADDRESS_OBJECT(adapter) );
3657         adapter->itemGroup = NULL;
3658         g_free( adapter );
3659 }
3660
3661 /*
3662  * Build GUI interface list.
3663  */
3664 void addrbookctl_build_iflist() {
3665         AddressTypeControlItem *atci;
3666         AdapterInterface *adapter;
3667         GList *list = NULL;
3668
3669         if( _addressIndex_ == NULL ) {
3670                 _addressIndex_ = addrindex_create_index();
3671                 if( _clipBoard_ == NULL ) {
3672                         _clipBoard_ = addrclip_create();
3673                 }
3674                 addrclip_set_index( _clipBoard_, _addressIndex_ );
3675         }
3676         _addressInterfaceList_ = NULL;
3677         list = addrindex_get_interface_list( _addressIndex_ );
3678         while( list ) {
3679                 AddressInterface *interface = list->data;
3680                 atci = addrbookctl_lookup_iface( interface->type );
3681                 if( atci ) {
3682                         adapter = g_new0( AdapterInterface, 1 );
3683                         adapter->interfaceType = interface->type;
3684                         adapter->atci = atci;
3685                         adapter->interface = interface;
3686                         adapter->treeNode = NULL;
3687                         adapter->enabled = TRUE;
3688                         adapter->haveLibrary = interface->haveLibrary;
3689                         ADDRESS_OBJECT(adapter)->type = ADDR_INTERFACE;
3690                         ADDRESS_OBJECT_NAME(adapter) = g_strdup( atci->displayName );
3691                         _addressInterfaceList_ = g_list_append( _addressInterfaceList_, adapter );
3692                 }
3693                 list = g_list_next( list );
3694         }
3695 }
3696
3697 void addrbookctl_free_selection( GList *list ) {
3698         GList *node = list;
3699         while( node ) {
3700                 AdapterInterface *adapter = node->data;
3701                 adapter = NULL;
3702                 node = g_list_next( node );
3703         }
3704         g_list_free( list );
3705 }
3706
3707 /*
3708 * Find GUI interface type specified interface type.
3709 * Return: Interface item, or NULL if not found.
3710 */
3711 AdapterInterface *addrbookctl_find_interface( AddressIfType ifType ) {
3712         GList *node = _addressInterfaceList_;
3713         while( node ) {
3714                 AdapterInterface *adapter = node->data;
3715                 if( adapter->interfaceType == ifType ) return adapter;
3716                 node = g_list_next( node );
3717         }
3718         return NULL;
3719 }
3720
3721 /*
3722 * Build interface list selection.
3723 */
3724 void addrbookctl_build_ifselect() {
3725         GList *newList = NULL;
3726         gchar *selectStr;
3727         gchar **splitStr;
3728         gint ifType;
3729         gint i;
3730         gchar *endptr = NULL;
3731         gboolean enabled;
3732         AdapterInterface *adapter;
3733         /* GList *node; */
3734
3735         selectStr = g_strdup( ADDRESSBOOK_IFACE_SELECTION );
3736
3737         /* Parse string */
3738         splitStr = g_strsplit( selectStr, ",", -1 );
3739         for( i = 0; i < ADDRESSBOOK_MAX_IFACE; i++ ) {
3740                 if( splitStr[i] ) {
3741                         /* printf( "%d : %s\n", i, splitStr[i] ); */
3742                         ifType = strtol( splitStr[i], &endptr, 10 );
3743                         enabled = TRUE;
3744                         if( *endptr ) {
3745                                 if( strcmp( endptr, "/n" ) == 0 ) {
3746                                         enabled = FALSE;
3747                                 }
3748                         }
3749                         /* printf( "\t%d : %s\n", ifType, enabled ? "yes" : "no" ); */
3750                         adapter = addrbookctl_find_interface( ifType );
3751                         if( adapter ) {
3752                                 newList = g_list_append( newList, adapter );
3753                         }
3754                 }
3755                 else {
3756                         break;
3757                 }
3758         }
3759         /* printf( "i=%d\n", i ); */
3760         g_strfreev( splitStr );
3761         g_free( selectStr );
3762
3763         /* Replace existing list */
3764         mgu_clear_list( _addressIFaceSelection_ );
3765         g_list_free( _addressIFaceSelection_ );
3766         _addressIFaceSelection_ = newList;
3767         newList = NULL;
3768
3769 }
3770
3771 /* **********************************************************************
3772 * Add sender to address book.
3773 * ***********************************************************************
3774 */
3775
3776 /*
3777  * This function is used by the Add sender to address book function.
3778  */
3779 gboolean addressbook_add_contact( const gchar *name, const gchar *address, const gchar *remarks ) {
3780         debug_print( "addressbook_add_contact: name/address: %s - %s\n", name, address );
3781         if( addressadd_selection( _addressIndex_, name, address, remarks ) ) {
3782                 debug_print( "addressbook_add_contact - added\n" );
3783                 addressbook_refresh();
3784         }
3785         return TRUE;
3786 }
3787
3788 /* **********************************************************************
3789 * Address completion support.
3790 * ***********************************************************************
3791 */
3792
3793 /*
3794 * This function is used by the address completion function to load
3795 * addresses.
3796 * Enter: callBackFunc Function to be called when an address is
3797 *                     to be loaded.
3798 * Return: TRUE if data loaded, FALSE if address index not loaded.
3799 */
3800 gboolean addressbook_load_completion( gint (*callBackFunc) ( const gchar *, const gchar *, const gchar * ) ) {
3801         AddressDataSource *ds;
3802         GList *nodeIf, *nodeDS;
3803         GList *listP, *nodeP;
3804         GList *nodeM;
3805         gchar *sName, *sAddress, *sAlias, *sFriendly;
3806
3807         debug_print( "addressbook_load_completion\n" );
3808
3809         if( _addressIndex_ == NULL ) return FALSE;
3810
3811         nodeIf = addrindex_get_interface_list( _addressIndex_ );
3812         while( nodeIf ) {
3813                 AddressInterface *interface = nodeIf->data;
3814                 nodeDS = interface->listSource;
3815                 while( nodeDS ) {
3816                         ds = nodeDS->data;
3817
3818                         /* Read address book */
3819                         if( addrindex_ds_get_modify_flag( ds ) ) {
3820                                 addrindex_ds_read_data( ds );
3821                         }
3822
3823                         if( ! addrindex_ds_get_read_flag( ds ) ) {
3824                                 addrindex_ds_read_data( ds );
3825                         }
3826
3827                         /* Get all persons */
3828                         listP = addrindex_ds_get_all_persons( ds );
3829                         nodeP = listP;
3830                         while( nodeP ) {
3831                                 ItemPerson *person = nodeP->data;
3832                                 nodeM = person->listEMail;
3833
3834                                 /* Figure out name to use */
3835                                 sName = person->nickName;
3836                                 if( sName == NULL || *sName == '\0' ) {
3837                                         sName = ADDRITEM_NAME(person);
3838                                 }
3839
3840                                 /* Process each E-Mail address */
3841                                 while( nodeM ) {
3842                                         ItemEMail *email = nodeM->data;
3843                                         /* Have mail */
3844                                         sFriendly = sName;
3845                                         sAddress = email->address;
3846                                         if( sAddress || *sAddress != '\0' ) {
3847                                                 sAlias = ADDRITEM_NAME(email);
3848                                                 if( sAlias && *sAlias != '\0' ) {
3849                                                         sFriendly = sAlias;
3850                                                 }
3851                                                 ( callBackFunc ) ( sFriendly, sAddress, sName );
3852                                         }
3853
3854                                         nodeM = g_list_next( nodeM );
3855                                 }
3856                                 nodeP = g_list_next( nodeP );
3857                         }
3858                         /* Free up the list */
3859                         g_list_free( listP );
3860
3861                         nodeDS = g_list_next( nodeDS );
3862                 }
3863                 nodeIf = g_list_next( nodeIf );
3864         }
3865         debug_print( "addressbook_load_completion... done\n" );
3866
3867         return TRUE;
3868 }
3869
3870 /* **********************************************************************
3871 * Address Import.
3872 * ***********************************************************************
3873 */
3874
3875 /*
3876 * Import LDIF file.
3877 */
3878 static void addressbook_import_ldif_cb() {
3879         AddressDataSource *ds = NULL;
3880         AdapterDSource *ads = NULL;
3881         AddressBookFile *abf = NULL;
3882         AdapterInterface *adapter;
3883         GtkCTreeNode *newNode;
3884
3885         adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3886         if( adapter ) {
3887                 if( adapter->treeNode ) {
3888                         abf = addressbook_imp_ldif( _addressIndex_ );
3889                         if( abf ) {
3890                                 ds = addrindex_index_add_datasource(
3891                                         _addressIndex_, ADDR_IF_BOOK, abf );
3892                                 ads = addressbook_create_ds_adapter(
3893                                         ds, ADDR_BOOK, NULL );
3894                                 addressbook_ads_set_name(
3895                                         ads, addrbook_get_name( abf ) );
3896                                 newNode = addressbook_add_object(
3897                                         adapter->treeNode,
3898                                         ADDRESS_OBJECT(ads) );
3899                                 if( newNode ) {
3900                                         gtk_ctree_select(
3901                                                 GTK_CTREE(addrbook.ctree),
3902                                                 newNode );
3903                                         addrbook.treeSelected = newNode;
3904                                 }
3905
3906                                 /* Notify address completion */
3907                                 invalidate_address_completion();
3908                         }
3909                 }
3910         }
3911 }
3912
3913 /*
3914 * Import MUTT file.
3915 */
3916 static void addressbook_import_mutt_cb() {
3917         AddressDataSource *ds = NULL;
3918         AdapterDSource *ads = NULL;
3919         AddressBookFile *abf = NULL;
3920         AdapterInterface *adapter;
3921         GtkCTreeNode *newNode;
3922
3923         adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3924         if( adapter ) {
3925                 if( adapter->treeNode ) {
3926                         abf = addressbook_imp_mutt( _addressIndex_ );
3927                         if( abf ) {
3928                                 ds = addrindex_index_add_datasource(
3929                                         _addressIndex_, ADDR_IF_BOOK, abf );
3930                                 ads = addressbook_create_ds_adapter(
3931                                         ds, ADDR_BOOK, NULL );
3932                                 addressbook_ads_set_name(
3933                                         ads, addrbook_get_name( abf ) );
3934                                 newNode = addressbook_add_object(
3935                                         adapter->treeNode,
3936                                         ADDRESS_OBJECT(ads) );
3937                                 if( newNode ) {
3938                                         gtk_ctree_select(
3939                                                 GTK_CTREE(addrbook.ctree),
3940                                                 newNode );
3941                                         addrbook.treeSelected = newNode;
3942                                 }
3943
3944                                 /* Notify address completion */
3945                                 invalidate_address_completion();
3946                         }
3947                 }
3948         }
3949 }
3950
3951 /*
3952 * Import Pine file.
3953 */
3954 static void addressbook_import_pine_cb() {
3955         AddressDataSource *ds = NULL;
3956         AdapterDSource *ads = NULL;
3957         AddressBookFile *abf = NULL;
3958         AdapterInterface *adapter;
3959         GtkCTreeNode *newNode;
3960
3961         adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
3962         if( adapter ) {
3963                 if( adapter->treeNode ) {
3964                         abf = addressbook_imp_pine( _addressIndex_ );
3965                         if( abf ) {
3966                                 ds = addrindex_index_add_datasource(
3967                                         _addressIndex_, ADDR_IF_BOOK, abf );
3968                                 ads = addressbook_create_ds_adapter(
3969                                         ds, ADDR_BOOK, NULL );
3970                                 addressbook_ads_set_name(
3971                                         ads, addrbook_get_name( abf ) );
3972                                 newNode = addressbook_add_object(
3973                                         adapter->treeNode,
3974                                         ADDRESS_OBJECT(ads) );
3975                                 if( newNode ) {
3976                                         gtk_ctree_select(
3977                                                 GTK_CTREE(addrbook.ctree),
3978                                                 newNode );
3979                                         addrbook.treeSelected = newNode;
3980                                 }
3981
3982                                 /* Notify address completion */
3983                                 invalidate_address_completion();
3984                         }
3985                 }
3986         }
3987 }
3988
3989 /*
3990  * Harvest addresses.
3991  * Enter: folderItem Folder to import.
3992  *        sourceInd  Source indicator: FALSE - Folder, TRUE - Messages.
3993  *        msgList    List of message numbers, or NULL to process folder.
3994  */
3995 void addressbook_harvest(
3996         FolderItem *folderItem, gboolean sourceInd, GList *msgList )
3997 {
3998         AddressDataSource *ds = NULL;
3999         AdapterDSource *ads = NULL;
4000         AddressBookFile *abf = NULL;
4001         AdapterInterface *adapter;
4002         GtkCTreeNode *newNode;
4003
4004         abf = addrgather_dlg_execute(
4005                 folderItem, _addressIndex_, sourceInd, msgList );
4006         if( abf ) {
4007                 ds = addrindex_index_add_datasource(
4008                         _addressIndex_, ADDR_IF_BOOK, abf );
4009
4010                 adapter = addrbookctl_find_interface( ADDR_IF_BOOK );
4011                 if( adapter ) {
4012                         if( adapter->treeNode ) {
4013                                 ads = addressbook_create_ds_adapter(
4014                                         ds, ADDR_BOOK, addrbook_get_name( abf ) );
4015                                 newNode = addressbook_add_object(
4016                                                 adapter->treeNode,
4017                                                 ADDRESS_OBJECT(ads) );
4018                         }
4019                 }
4020
4021                 /* Notify address completion */
4022                 invalidate_address_completion();
4023         }
4024 }
4025
4026 /*
4027 * Export HTML file.
4028 */
4029 static void addressbook_export_html_cb( void ) {
4030         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
4031         AddressObject *obj;
4032         AddressDataSource *ds = NULL;
4033         AddrBookBase *adbase;
4034         AddressCache *cache;
4035         GtkCTreeNode *node = NULL;
4036
4037         if( ! addrbook.treeSelected ) return;
4038         node = addrbook.treeSelected;
4039         if( GTK_CTREE_ROW(node)->level == 1 ) return;
4040         obj = gtk_ctree_node_get_row_data( ctree, node );
4041         if( obj == NULL ) return;
4042
4043         ds = addressbook_find_datasource( node );
4044         if( ds == NULL ) return;
4045         adbase = ( AddrBookBase * ) ds->rawDataSource;
4046         cache = adbase->addressCache;
4047         addressbook_exp_html( cache );
4048 }
4049
4050 /*
4051 * End of Source.
4052 */
4053