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