src/addressbook.c

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