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