src/addressbook.c

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