src/addressbook.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999,2000 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 "xml.h"
  56 #include "prefs.h"
  57 #include "procmime.h"
  58 #include "utils.h"
  59 #include "gtkutils.h"
  60 #include "codeconv.h"
  61 #include "about.h"
  62 #include "addr_compl.h"
  63
  64 #include "addressitem.h"
  65 #include "vcard.h"
  66 #include "editvcard.h"
  67
  68 #ifdef USE_JPILOT
  69 #include "jpilot.h"
  70 #include "editjpilot.h"
  71 #endif
  72
  73 #ifdef USE_LDAP
  74 #include <pthread.h>
  75 #include "syldap.h"
  76 #include "editldap.h"
  77
  78 // Interval to check for LDAP search results
  79 // #define ADDRESSBOOK_LDAP_TIMER_INTERVAL      100
  80 #define ADDRESSBOOK_LDAP_BUSYMSG        "Busy"
  81
  82 #endif
  83
  84 #include "pixmaps/dir-close.xpm"
  85 #include "pixmaps/dir-open.xpm"
  86 #include "pixmaps/group.xpm"
  87 #include "pixmaps/vcard.xpm"
  88 #ifdef USE_JPILOT
  89 #include "pixmaps/jpilot.xpm"
  90 #include "pixmaps/category.xpm"
  91 #endif
  92 #ifdef USE_LDAP
  93 #include "pixmaps/ldap.xpm"
  94 #endif
  95
  96 // XML tag names for top level folders
  97 #define ADDRESS_TAG_COMMON    "common_address"
  98 #define ADDRESS_TAG_PERSONAL  "personal_address"
  99 #define ADDRESS_TAG_VCARD     "vcard_list"
 100 #ifdef USE_JPILOT
 101 #define ADDRESS_TAG_JPILOT    "jpilot_list"
 102 #endif
 103 #ifdef USE_LDAP
 104 #define ADDRESS_TAG_LDAP      "ldap_list"
 105 #endif
 106
 107 typedef enum
 108 {
 109         COL_NAME        = 0,
 110         COL_ADDRESS     = 1,
 111         COL_REMARKS     = 2
 112 } AddressBookColumnPos;
 113
 114 #define N_COLS  3
 115 #define COL_NAME_WIDTH          144
 116 #define COL_ADDRESS_WIDTH       156
 117
 118 #define COL_FOLDER_WIDTH        170
 119 #define ADDRESSBOOK_WIDTH       640
 120 #define ADDRESSBOOK_HEIGHT      360
 121
 122 #define ADDRESSBOOK_MSGBUF_SIZE 2048
 123
 124 static GdkPixmap *folderxpm;
 125 static GdkBitmap *folderxpmmask;
 126 static GdkPixmap *folderopenxpm;
 127 static GdkBitmap *folderopenxpmmask;
 128 static GdkPixmap *groupxpm;
 129 static GdkBitmap *groupxpmmask;
 130 static GdkPixmap *vcardxpm;
 131 static GdkBitmap *vcardxpmmask;
 132 #ifdef USE_JPILOT
 133 static GdkPixmap *jpilotxpm;
 134 static GdkBitmap *jpilotxpmmask;
 135 static GdkPixmap *categoryxpm;
 136 static GdkBitmap *categoryxpmmask;
 137 #endif
 138 #ifdef USE_LDAP
 139 static GdkPixmap *ldapxpm;
 140 static GdkBitmap *ldapxpmmask;
 141 #endif
 142
 143 // Pilot library indicator (set at run-time)
 144 static _have_pilot_library_;
 145
 146 // LDAP library indicator (set at run-time)
 147 static _have_ldap_library_;
 148
 149 // Message buffer
 150 static gchar addressbook_msgbuf[ ADDRESSBOOK_MSGBUF_SIZE ];
 151
 152 static AddressBook addrbook;
 153
 154 static struct _AddressEdit
 155 {
 156         GtkWidget *window;
 157         GtkWidget *name_entry;
 158         GtkWidget *addr_entry;
 159         GtkWidget *rem_entry;
 160         GtkWidget *ok_btn;
 161         GtkWidget *cancel_btn;
 162 } addredit;
 163
 164 static void addressbook_create                  (gboolean show);
 165 static gint addressbook_close                   (void);
 166 static void addressbook_button_set_sensitive    (void);
 167
 168 /* callback functions */
 169 static void addressbook_del_clicked             (GtkButton      *button,
 170                                                  gpointer        data);
 171 static void addressbook_reg_clicked             (GtkButton      *button,
 172                                                  gpointer        data);
 173 static void addressbook_to_clicked              (GtkButton      *button,
 174                                                  gpointer        data);
 175 static void addressbook_lup_clicked             (GtkButton      *button,
 176                                                  gpointer       data);
 177
 178 static void addressbook_tree_selected           (GtkCTree       *ctree,
 179                                                  GtkCTreeNode   *node,
 180                                                  gint            column,
 181                                                  gpointer        data);
 182 static void addressbook_list_selected           (GtkCList       *clist,
 183                                                  gint            row,
 184                                                  gint            column,
 185                                                  GdkEvent       *event,
 186                                                  gpointer        data);
 187 static void addressbook_entry_gotfocus          (GtkWidget      *widget);
 188
 189 #if 0
 190 static void addressbook_entry_changed           (GtkWidget      *widget);
 191 #endif
 192
 193 static void addressbook_list_button_pressed     (GtkWidget      *widget,
 194                                                  GdkEventButton *event,
 195                                                  gpointer        data);
 196 static void addressbook_list_button_released    (GtkWidget      *widget,
 197                                                  GdkEventButton *event,
 198                                                  gpointer        data);
 199 static void addressbook_tree_button_pressed     (GtkWidget      *ctree,
 200                                                  GdkEventButton *event,
 201                                                  gpointer        data);
 202 static void addressbook_tree_button_released    (GtkWidget      *ctree,
 203                                                  GdkEventButton *event,
 204                                                  gpointer        data);
 205 static void addressbook_popup_close             (GtkMenuShell   *menu_shell,
 206                                                  gpointer        data);
 207
 208 static void addressbook_new_folder_cb           (gpointer        data,
 209                                                  guint           action,
 210                                                  GtkWidget      *widget);
 211 static void addressbook_new_group_cb            (gpointer        data,
 212                                                  guint           action,
 213                                                  GtkWidget      *widget);
 214 static void addressbook_edit_folder_cb          (gpointer        data,
 215                                                  guint           action,
 216                                                  GtkWidget      *widget);
 217 static void addressbook_delete_folder_cb        (gpointer        data,
 218                                                  guint           action,
 219                                                  GtkWidget      *widget);
 220
 221 static void addressbook_change_node_name        (GtkCTreeNode   *node,
 222                                                  const gchar    *name);
 223 static void addressbook_edit_group              (GtkCTreeNode   *group_node);
 224
 225 static void addressbook_edit_address_create     (gboolean       *cancelled);
 226 static void edit_address_ok                     (GtkWidget      *widget,
 227                                                  gboolean       *cancelled);
 228 static void edit_address_cancel                 (GtkWidget      *widget,
 229                                                  gboolean       *cancelled);
 230 static gint edit_address_delete_event           (GtkWidget      *widget,
 231                                                  GdkEventAny    *event,
 232                                                  gboolean       *cancelled);
 233 static void edit_address_key_pressed            (GtkWidget      *widget,
 234                                                  GdkEventKey    *event,
 235                                                  gboolean       *cancelled);
 236 static AddressItem *addressbook_edit_address    (AddressItem    *item);
 237
 238 static void addressbook_new_address_cb          (gpointer        data,
 239                                                  guint           action,
 240                                                  GtkWidget      *widget);
 241 static void addressbook_edit_address_cb         (gpointer        data,
 242                                                  guint           action,
 243                                                  GtkWidget      *widget);
 244 static void addressbook_delete_address_cb       (gpointer        data,
 245                                                  guint           action,
 246                                                  GtkWidget      *widget);
 247
 248 static void close_cb                            (gpointer        data,
 249                                                  guint           action,
 250                                                  GtkWidget      *widget);
 251
 252 // VCard edit stuff
 253 static void addressbook_new_vcard_cb            ( gpointer      data,
 254                                                   guint         action,
 255                                                   GtkWidget     *widget );
 256
 257 #ifdef USE_JPILOT
 258 // JPilot edit stuff
 259 static void addressbook_new_jpilot_cb           ( gpointer      data,
 260                                                   guint         action,
 261                                                   GtkWidget     *widget );
 262 #endif
 263
 264 #ifdef USE_LDAP
 265 // LDAP edit stuff
 266 static void addressbook_new_ldap_cb             ( gpointer      data,
 267                                                   guint         action,
 268                                                   GtkWidget     *widget );
 269 #endif
 270
 271 static AddressItem *addressbook_parse_address   (const gchar    *str);
 272 static void addressbook_append_to_compose_entry (AddressItem    *item,
 273                                                  ComposeEntryType type);
 274
 275 static void addressbook_set_clist               (AddressObject  *obj);
 276
 277 static void addressbook_read_file               (void);
 278 static void addressbook_get_tree                (XMLFile        *file,
 279                                                  GtkCTreeNode   *node,
 280                                                  const gchar    *folder_tag);
 281 static void addressbook_add_objs                (XMLFile        *file,
 282                                                  GtkCTreeNode   *node);
 283
 284 static GtkCTreeNode *addressbook_add_object     (GtkCTreeNode   *node,
 285                                                  AddressObject  *obj);
 286 static void addressbook_delete_object           (AddressObject  *obj);
 287 static AddressObject *addressbook_find_object_by_name
 288                                                 (GtkCTreeNode   *node,
 289                                                  const gchar    *name);
 290
 291 static AddressItem *addressbook_parse_item      (XMLFile        *file);
 292 static void addressbook_xml_recursive_write     (GtkCTreeNode   *node,
 293                                                  FILE           *fp);
 294 static void addressbook_node_write_begin        (GtkCTreeNode   *node,
 295                                                  FILE           *fp);
 296 static void addressbook_node_write_end          (GtkCTreeNode   *node,
 297                                                  FILE           *fp);
 298 static void addressbook_write_items             (FILE           *fp,
 299                                                  GList          *items,
 300                                                  guint           level);
 301 static void tab_indent_out                      (FILE           *fp,
 302                                                  guint           level);
 303
 304 static void key_pressed                         (GtkWidget      *widget,
 305                                                  GdkEventKey    *event,
 306                                                  gpointer        data);
 307 static gint addressbook_list_compare_func       (GtkCList       *clist,
 308                                                  gconstpointer   ptr1,
 309                                                  gconstpointer   ptr2);
 310 static gint addressbook_obj_name_compare        (gconstpointer   a,
 311                                                  gconstpointer   b);
 312
 313 static AddressVCard *addressbook_parse_vcard    ( XMLFile       *file );
 314 static void addressbook_write_vcard             ( FILE          *fp,
 315                                                 AddressVCard    *vcard,
 316                                                 guint           level );
 317 static void addressbook_vcard_show_message      ( VCardFile *vcf );
 318
 319 #ifdef USE_JPILOT
 320 static AddressJPilot *addressbook_parse_jpilot  ( XMLFile       *file );
 321 static void addressbook_write_jpilot            ( FILE          *fp,
 322                                                 AddressJPilot   *jpilot,
 323                                                 guint           level );
 324 static void addressbook_jpilot_show_message     ( JPilotFile *jpf );
 325 #endif
 326 #ifdef USE_LDAP
 327 static AddressLDAP *addressbook_parse_ldap      ( XMLFile       *file );
 328 static void addressbook_write_ldap              ( FILE          *fp,
 329                                                 AddressLDAP     *ldapi,
 330                                                 guint           level );
 331 static void addressbook_ldap_show_message       ( SyldapServer *server );
 332 #endif
 333
 334 static GtkItemFactoryEntry addressbook_entries[] =
 335 {
 336         {N_("/_File"),                  NULL, NULL, 0, "<Branch>"},
 337         {N_("/_File/New _Address"),     "<alt>N", addressbook_new_address_cb, 0, NULL},
 338         {N_("/_File/New _Group"),       "<alt>G", addressbook_new_group_cb,   0, NULL},
 339         {N_("/_File/New _Folder"),      "<alt>R", addressbook_new_folder_cb,  0, NULL},
 340         {N_("/_File/New _V-Card"),      "<alt>D", addressbook_new_vcard_cb,  0, NULL},
 341 #ifdef USE_JPILOT
 342         {N_("/_File/New _J-Pilot"),     "<alt>J", addressbook_new_jpilot_cb,  0, NULL},
 343 #endif
 344 #ifdef USE_LDAP
 345         {N_("/_File/New _Server"),      "<alt>S", addressbook_new_ldap_cb,  0, NULL},
 346 #endif
 347         {N_("/_File/---"),              NULL, NULL, 0, "<Separator>"},
 348         {N_("/_File/_Edit"),            "<alt>Return", addressbook_edit_address_cb, 0, NULL},
 349         {N_("/_File/_Delete"),          NULL, addressbook_delete_address_cb, 0, NULL},
 350         {N_("/_File/---"),              NULL, NULL, 0, "<Separator>"},
 351         {N_("/_File/_Close"),           "<alt>W", close_cb, 0, NULL},
 352         {N_("/_Help"),                  NULL, NULL, 0, "<LastBranch>"},
 353         {N_("/_Help/_About"),           NULL, about_show, 0, NULL}
 354 };
 355
 356 static GtkItemFactoryEntry addressbook_tree_popup_entries[] =
 357 {
 358         {N_("/New _Address"),   NULL, addressbook_new_address_cb, 0, NULL},
 359         {N_("/New _Group"),     NULL, addressbook_new_group_cb,   0, NULL},
 360         {N_("/New _Folder"),    NULL, addressbook_new_folder_cb,  0, NULL},
 361         {N_("/New _V-Card"),    NULL, addressbook_new_vcard_cb,   0, NULL},
 362 #ifdef USE_JPILOT
 363         {N_("/New _J-Pilot"),   NULL, addressbook_new_jpilot_cb,  0, NULL},
 364 #endif
 365 #ifdef USE_LDAP
 366         {N_("/New _Server"),    NULL, addressbook_new_ldap_cb,  0, NULL},
 367 #endif
 368         {N_("/---"),            NULL, NULL, 0, "<Separator>"},
 369         {N_("/_Edit"),          NULL, addressbook_edit_folder_cb,   0, NULL},
 370         {N_("/_Delete"),        NULL, addressbook_delete_folder_cb, 0, NULL}
 371 };
 372
 373 static GtkItemFactoryEntry addressbook_list_popup_entries[] =
 374 {
 375         {N_("/New _Address"),   NULL, addressbook_new_address_cb,  0, NULL},
 376         {N_("/New _Group"),     NULL, addressbook_new_group_cb,    0, NULL},
 377         {N_("/New _Folder"),    NULL, addressbook_new_folder_cb,   0, NULL},
 378         {N_("/---"),            NULL, NULL, 0, "<Separator>"},
 379         {N_("/_Edit"),          NULL, addressbook_edit_address_cb,   0, NULL},
 380         {N_("/_Delete"),        NULL, addressbook_delete_address_cb, 0, NULL}
 381 };
 382
 383 void addressbook_open(Compose *target)
 384 {
 385         if (!addrbook.window) {
 386                 addressbook_create(TRUE);
 387                 addressbook_read_file();
 388                 addrbook.open_folder = TRUE;
 389                 gtk_ctree_select(GTK_CTREE(addrbook.ctree),
 390                                  GTK_CTREE_NODE(GTK_CLIST(addrbook.ctree)->row_list));
 391         } else
 392                 gtk_widget_hide(addrbook.window);
 393
 394         gtk_widget_show_all(addrbook.window);
 395
 396         addressbook_set_target_compose(target);
 397 }
 398
 399 void addressbook_set_target_compose(Compose *target)
 400 {
 401         addrbook.target_compose = target;
 402
 403         addressbook_button_set_sensitive();
 404 }
 405
 406 Compose *addressbook_get_target_compose(void)
 407 {
 408         return addrbook.target_compose;
 409 }
 410
 411 static void addressbook_create(gboolean show)
 412 {
 413         GtkWidget *window;
 414         GtkWidget *vbox;
 415         GtkWidget *menubar;
 416         GtkWidget *vbox2;
 417         GtkWidget *ctree_swin;
 418         GtkWidget *ctree;
 419         GtkWidget *clist_vbox;
 420         GtkWidget *clist_swin;
 421         GtkWidget *clist;
 422         GtkWidget *paned;
 423         GtkWidget *hbox;
 424         GtkWidget *label;
 425         GtkWidget *entry;
 426         GtkWidget *statusbar;
 427         GtkWidget *hmbox;
 428         GtkWidget *hbbox;
 429         GtkWidget *hsbox;
 430         GtkWidget *del_btn;
 431         GtkWidget *reg_btn;
 432         GtkWidget *lup_btn;
 433         GtkWidget *to_btn;
 434         GtkWidget *cc_btn;
 435         GtkWidget *bcc_btn;
 436         GtkWidget *tree_popup;
 437         GtkWidget *list_popup;
 438         GtkItemFactory *tree_factory;
 439         GtkItemFactory *list_factory;
 440         GtkItemFactory *menu_factory;
 441         gint n_entries;
 442
 443         gchar *titles[N_COLS] = {_("Name"), _("E-Mail address"), _("Remarks")};
 444         gchar *text;
 445         gint i;
 446
 447         debug_print("Creating addressbook window...\n");
 448
 449         // Global flag if we have library installed (at run-time)
 450         _have_pilot_library_ = FALSE;
 451         _have_ldap_library_ = FALSE;
 452
 453         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 454         gtk_window_set_title(GTK_WINDOW(window), _("Address book"));
 455         gtk_widget_set_usize(window, ADDRESSBOOK_WIDTH, ADDRESSBOOK_HEIGHT);
 456         //gtk_container_set_border_width(GTK_CONTAINER(window), BORDER_WIDTH);
 457         gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, TRUE);
 458         gtk_widget_realize(window);
 459
 460         gtk_signal_connect(GTK_OBJECT(window), "delete_event",
 461                            GTK_SIGNAL_FUNC(addressbook_close), NULL);
 462         gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
 463                            GTK_SIGNAL_FUNC(key_pressed), NULL);
 464         gtk_signal_connect(GTK_OBJECT(window), "focus_in_event",
 465                            GTK_SIGNAL_FUNC(manage_window_focus_in), NULL);
 466         gtk_signal_connect(GTK_OBJECT(window), "focus_out_event",
 467                            GTK_SIGNAL_FUNC(manage_window_focus_out), NULL);
 468
 469         vbox = gtk_vbox_new(FALSE, 0);
 470         gtk_container_add(GTK_CONTAINER(window), vbox);
 471
 472         n_entries = sizeof(addressbook_entries) /
 473                 sizeof(addressbook_entries[0]);
 474         menubar = menubar_create(window, addressbook_entries, n_entries,
 475                                  "<AddressBook>", NULL);
 476         gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
 477         menu_factory = gtk_item_factory_from_widget(menubar);
 478
 479         vbox2 = gtk_vbox_new(FALSE, 4);
 480         gtk_container_set_border_width(GTK_CONTAINER(vbox2), BORDER_WIDTH);
 481         gtk_box_pack_start(GTK_BOX(vbox), vbox2, TRUE, TRUE, 0);
 482
 483         ctree_swin = gtk_scrolled_window_new(NULL, NULL);
 484         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ctree_swin),
 485                                        GTK_POLICY_AUTOMATIC,
 486                                        GTK_POLICY_ALWAYS);
 487         gtk_widget_set_usize(ctree_swin, COL_FOLDER_WIDTH + 40, -1);
 488
 489         ctree = gtk_ctree_new(1, 0);
 490         gtk_container_add(GTK_CONTAINER(ctree_swin), ctree);
 491         gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE);
 492         gtk_clist_set_column_width(GTK_CLIST(ctree), 0, COL_FOLDER_WIDTH);
 493         gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_DOTTED);
 494         gtk_ctree_set_expander_style(GTK_CTREE(ctree),
 495                                      GTK_CTREE_EXPANDER_SQUARE);
 496         gtk_ctree_set_indent(GTK_CTREE(ctree), CTREE_INDENT);
 497         gtk_clist_set_compare_func(GTK_CLIST(ctree),
 498                                    addressbook_list_compare_func);
 499
 500         gtk_signal_connect(GTK_OBJECT(ctree), "tree_select_row",
 501                            GTK_SIGNAL_FUNC(addressbook_tree_selected), NULL);
 502         gtk_signal_connect(GTK_OBJECT(ctree), "button_press_event",
 503                            GTK_SIGNAL_FUNC(addressbook_tree_button_pressed),
 504                            NULL);
 505         gtk_signal_connect(GTK_OBJECT(ctree), "button_release_event",
 506                            GTK_SIGNAL_FUNC(addressbook_tree_button_released),
 507                            NULL);
 508
 509         clist_vbox = gtk_vbox_new(FALSE, 4);
 510
 511         clist_swin = gtk_scrolled_window_new(NULL, NULL);
 512         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin),
 513                                        GTK_POLICY_AUTOMATIC,
 514                                        GTK_POLICY_ALWAYS);
 515         gtk_box_pack_start(GTK_BOX(clist_vbox), clist_swin, TRUE, TRUE, 0);
 516
 517         clist = gtk_clist_new_with_titles(N_COLS, titles);
 518         gtk_container_add(GTK_CONTAINER(clist_swin), clist);
 519         gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_EXTENDED);
 520         gtk_clist_set_column_width(GTK_CLIST(clist), COL_NAME,
 521                                    COL_NAME_WIDTH);
 522         gtk_clist_set_column_width(GTK_CLIST(clist), COL_ADDRESS,
 523                                    COL_ADDRESS_WIDTH);
 524         gtk_clist_set_compare_func(GTK_CLIST(clist),
 525                                    addressbook_list_compare_func);
 526
 527         for (i = 0; i < N_COLS; i++)
 528                 GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[i].button,
 529                                        GTK_CAN_FOCUS);
 530
 531         gtk_signal_connect(GTK_OBJECT(clist), "select_row",
 532                            GTK_SIGNAL_FUNC(addressbook_list_selected), NULL);
 533         gtk_signal_connect(GTK_OBJECT(clist), "button_press_event",
 534                            GTK_SIGNAL_FUNC(addressbook_list_button_pressed),
 535                            NULL);
 536         gtk_signal_connect(GTK_OBJECT(clist), "button_release_event",
 537                            GTK_SIGNAL_FUNC(addressbook_list_button_released),
 538                            NULL);
 539
 540         hbox = gtk_hbox_new(FALSE, 4);
 541         gtk_box_pack_start(GTK_BOX(clist_vbox), hbox, FALSE, FALSE, 0);
 542
 543         label = gtk_label_new(_("Name:"));
 544         gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
 545
 546         entry = gtk_entry_new();
 547         gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
 548
 549         address_completion_register_entry(GTK_ENTRY(entry));
 550         gtk_signal_connect(GTK_OBJECT(entry), "focus_in_event",
 551                            GTK_SIGNAL_FUNC(addressbook_entry_gotfocus), NULL);
 552
 553 #if 0
 554         gtk_signal_connect(GTK_OBJECT(entry), "changed",
 555                            GTK_SIGNAL_FUNC(addressbook_entry_changed), NULL);
 556 #endif
 557
 558         paned = gtk_hpaned_new();
 559         gtk_box_pack_start(GTK_BOX(vbox2), paned, TRUE, TRUE, 0);
 560         gtk_paned_add1(GTK_PANED(paned), ctree_swin);
 561         gtk_paned_add2(GTK_PANED(paned), clist_vbox);
 562
 563         // Status bar
 564         hsbox = gtk_hbox_new(FALSE, 0);
 565         gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, BORDER_WIDTH);
 566         statusbar = gtk_statusbar_new();
 567         gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, BORDER_WIDTH);
 568
 569         // Button panel
 570         hbbox = gtk_hbutton_box_new();
 571         gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);
 572         gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 2);
 573         gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
 574
 575         del_btn = gtk_button_new_with_label(_("Delete"));
 576         GTK_WIDGET_SET_FLAGS(del_btn, GTK_CAN_DEFAULT);
 577         gtk_box_pack_start(GTK_BOX(hbbox), del_btn, TRUE, TRUE, 0);
 578         reg_btn = gtk_button_new_with_label(_("Add"));
 579         GTK_WIDGET_SET_FLAGS(reg_btn, GTK_CAN_DEFAULT);
 580         gtk_box_pack_start(GTK_BOX(hbbox), reg_btn, TRUE, TRUE, 0);
 581         lup_btn = gtk_button_new_with_label(_("Lookup"));
 582         GTK_WIDGET_SET_FLAGS(lup_btn, GTK_CAN_DEFAULT);
 583         gtk_box_pack_start(GTK_BOX(hbbox), lup_btn, TRUE, TRUE, 0);
 584
 585         gtk_signal_connect(GTK_OBJECT(del_btn), "clicked",
 586                            GTK_SIGNAL_FUNC(addressbook_del_clicked), NULL);
 587         gtk_signal_connect(GTK_OBJECT(reg_btn), "clicked",
 588                            GTK_SIGNAL_FUNC(addressbook_reg_clicked), NULL);
 589         gtk_signal_connect(GTK_OBJECT(lup_btn), "clicked",
 590                            GTK_SIGNAL_FUNC(addressbook_lup_clicked), NULL);
 591
 592         to_btn = gtk_button_new_with_label
 593                 (prefs_common.trans_hdr ? _("To:") : "To:");
 594         GTK_WIDGET_SET_FLAGS(to_btn, GTK_CAN_DEFAULT);
 595         gtk_box_pack_start(GTK_BOX(hbbox), to_btn, TRUE, TRUE, 0);
 596         cc_btn = gtk_button_new_with_label
 597                 (prefs_common.trans_hdr ? _("Cc:") : "Cc:");
 598         GTK_WIDGET_SET_FLAGS(cc_btn, GTK_CAN_DEFAULT);
 599         gtk_box_pack_start(GTK_BOX(hbbox), cc_btn, TRUE, TRUE, 0);
 600         bcc_btn = gtk_button_new_with_label
 601                 (prefs_common.trans_hdr ? _("Bcc:") : "Bcc:");
 602         GTK_WIDGET_SET_FLAGS(bcc_btn, GTK_CAN_DEFAULT);
 603         gtk_box_pack_start(GTK_BOX(hbbox), bcc_btn, TRUE, TRUE, 0);
 604
 605         gtk_signal_connect(GTK_OBJECT(to_btn), "clicked",
 606                            GTK_SIGNAL_FUNC(addressbook_to_clicked),
 607                            GINT_TO_POINTER(COMPOSE_TO));
 608         gtk_signal_connect(GTK_OBJECT(cc_btn), "clicked",
 609                            GTK_SIGNAL_FUNC(addressbook_to_clicked),
 610                            GINT_TO_POINTER(COMPOSE_CC));
 611         gtk_signal_connect(GTK_OBJECT(bcc_btn), "clicked",
 612                            GTK_SIGNAL_FUNC(addressbook_to_clicked),
 613                            GINT_TO_POINTER(COMPOSE_BCC));
 614
 615         PIXMAP_CREATE(window, folderxpm, folderxpmmask, DIRECTORY_CLOSE_XPM);
 616         PIXMAP_CREATE(window, folderopenxpm, folderopenxpmmask,
 617                       DIRECTORY_OPEN_XPM);
 618         PIXMAP_CREATE(window, groupxpm, groupxpmmask, group_xpm);
 619         PIXMAP_CREATE(window, vcardxpm, vcardxpmmask, vcard_xpm);
 620 #ifdef USE_JPILOT
 621         PIXMAP_CREATE(window, jpilotxpm, jpilotxpmmask, jpilot_xpm);
 622         PIXMAP_CREATE(window, categoryxpm, categoryxpmmask, category_xpm);
 623 #endif
 624 #ifdef USE_LDAP
 625         PIXMAP_CREATE(window, ldapxpm, ldapxpmmask, ldap_xpm);
 626 #endif
 627
 628         text = _("Common address");
 629         addrbook.common =
 630                 gtk_ctree_insert_node(GTK_CTREE(ctree),
 631                                       NULL, NULL, &text, FOLDER_SPACING,
 632                                       folderxpm, folderxpmmask,
 633                                       folderopenxpm, folderopenxpmmask,
 634                                       FALSE, FALSE);
 635         text = _("Personal address");
 636         addrbook.personal =
 637                 gtk_ctree_insert_node(GTK_CTREE(ctree),
 638                                       NULL, NULL, &text, FOLDER_SPACING,
 639                                       folderxpm, folderxpmmask,
 640                                       folderopenxpm, folderopenxpmmask,
 641                                       FALSE, FALSE);
 642
 643         text = _("V-Card");
 644         addrbook.vcard =
 645                 gtk_ctree_insert_node(GTK_CTREE(ctree),
 646                                       NULL, NULL, &text, FOLDER_SPACING,
 647                                       folderxpm, folderxpmmask,
 648                                       folderopenxpm, folderopenxpmmask,
 649                                       FALSE, FALSE);
 650
 651 #ifdef USE_JPILOT
 652         text = _("J-Pllot");
 653         addrbook.jpilot =
 654                 gtk_ctree_insert_node(GTK_CTREE(ctree),
 655                                       NULL, NULL, &text, FOLDER_SPACING,
 656                                       folderxpm, folderxpmmask,
 657                                       folderopenxpm, folderopenxpmmask,
 658                                       FALSE, FALSE);
 659         if( jpilot_test_pilot_lib() ) {
 660                 _have_pilot_library_ = TRUE;
 661                 menu_set_sensitive( menu_factory, "/File/New J-Pilot", TRUE );
 662         }
 663         else {
 664                 menu_set_sensitive( menu_factory, "/File/New J-Pilot", FALSE );
 665         }
 666 #endif
 667
 668 #ifdef USE_LDAP
 669         text = _("Directory");
 670         addrbook.ldap =
 671                 gtk_ctree_insert_node(GTK_CTREE(ctree),
 672                                       NULL, NULL, &text, FOLDER_SPACING,
 673                                       folderxpm, folderxpmmask,
 674                                       folderopenxpm, folderopenxpmmask,
 675                                       FALSE, FALSE);
 676         if( syldap_test_ldap_lib() ) {
 677                 _have_ldap_library_ = TRUE;
 678                 menu_set_sensitive( menu_factory, "/File/New Server", TRUE );
 679         }
 680         else {
 681                 menu_set_sensitive( menu_factory, "/File/New Server", FALSE );
 682         }
 683 #endif
 684
 685         /* popup menu */
 686         n_entries = sizeof(addressbook_tree_popup_entries) /
 687                 sizeof(addressbook_tree_popup_entries[0]);
 688         tree_popup = menu_create_items(addressbook_tree_popup_entries,
 689                                        n_entries,
 690                                        "<AddressBookTree>", &tree_factory,
 691                                        NULL);
 692         gtk_signal_connect(GTK_OBJECT(tree_popup), "selection_done",
 693                            GTK_SIGNAL_FUNC(addressbook_popup_close), NULL);
 694         n_entries = sizeof(addressbook_list_popup_entries) /
 695                 sizeof(addressbook_list_popup_entries[0]);
 696         list_popup = menu_create_items(addressbook_list_popup_entries,
 697                                        n_entries,
 698                                        "<AddressBookList>", &list_factory,
 699                                        NULL);
 700
 701         addrbook.window  = window;
 702         addrbook.menubar = menubar;
 703         addrbook.ctree   = ctree;
 704         addrbook.clist   = clist;
 705         addrbook.entry   = entry;
 706         addrbook.statusbar = statusbar;
 707         addrbook.status_cid = gtk_statusbar_get_context_id( GTK_STATUSBAR(statusbar), "Addressbook Window" );
 708
 709         addrbook.del_btn = del_btn;
 710         addrbook.reg_btn = reg_btn;
 711         addrbook.lup_btn = lup_btn;
 712         addrbook.to_btn  = to_btn;
 713         addrbook.cc_btn  = cc_btn;
 714         addrbook.bcc_btn = bcc_btn;
 715
 716         addrbook.tree_popup   = tree_popup;
 717         addrbook.list_popup   = list_popup;
 718         addrbook.tree_factory = tree_factory;
 719         addrbook.list_factory = list_factory;
 720         addrbook.menu_factory = menu_factory;
 721
 722         address_completion_start(window);
 723
 724         if (show)
 725                 gtk_widget_show_all(window);
 726 }
 727
 728 static gint addressbook_close(void)
 729 {
 730         gtk_widget_hide(addrbook.window);
 731         addressbook_export_to_file();
 732         /* tell addr_compl that there's a new addressbook file */
 733         invalidate_address_completion();
 734         return TRUE;
 735 }
 736
 737 static void addressbook_status_show( gchar *msg ) {
 738         if( addrbook.statusbar != NULL ) {
 739                 gtk_statusbar_pop( GTK_STATUSBAR(addrbook.statusbar), addrbook.status_cid );
 740                 if( msg ) {
 741                         gtk_statusbar_push( GTK_STATUSBAR(addrbook.statusbar), addrbook.status_cid, msg );
 742                 }
 743         }
 744 }
 745
 746 static void addressbook_button_set_sensitive(void)
 747 {
 748         gboolean to_sens  = FALSE;
 749         gboolean cc_sens  = FALSE;
 750         gboolean bcc_sens = FALSE;
 751
 752         if (!addrbook.window) return;
 753
 754         if (addrbook.target_compose) {
 755                 to_sens = TRUE;
 756                 cc_sens = TRUE;
 757                 if (addrbook.target_compose->use_bcc)
 758                         bcc_sens = TRUE;
 759         }
 760
 761         gtk_widget_set_sensitive(addrbook.to_btn, to_sens);
 762         gtk_widget_set_sensitive(addrbook.cc_btn, cc_sens);
 763         gtk_widget_set_sensitive(addrbook.bcc_btn, bcc_sens);
 764 }
 765
 766 static void addressbook_del_clicked(GtkButton *button, gpointer data)
 767 {
 768         GtkCList *clist = GTK_CLIST(addrbook.clist);
 769         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
 770         AddressObject *pobj, *obj;
 771         GList *cur, *next;
 772         gint row;
 773         gboolean remFlag;
 774
 775         if (!clist->selection) {
 776                 addressbook_delete_folder_cb(NULL, 0, NULL);
 777                 return;
 778         }
 779
 780         pobj = gtk_ctree_node_get_row_data(ctree, addrbook.opened);
 781         g_return_if_fail(pobj != NULL);
 782
 783         if (alertpanel(_("Delete address(es)"),
 784                        _("Really delete the address(es)?"),
 785                        _("Yes"), _("No"), NULL) != G_ALERTDEFAULT)
 786                 return;
 787
 788         for (cur = clist->selection; cur != NULL; cur = next) {
 789                 next = cur->next;
 790                 row = GPOINTER_TO_INT(cur->data);
 791                 remFlag = FALSE;
 792
 793                 obj = gtk_clist_get_row_data(clist, row);
 794                 if (!obj) continue;
 795
 796                 if (pobj->type == ADDR_GROUP) {
 797                         AddressGroup *group = ADDRESS_GROUP(pobj);
 798                         group->items = g_list_remove(group->items, obj);
 799                 } else if (pobj->type == ADDR_FOLDER) {
 800                         AddressFolder *folder = ADDRESS_FOLDER(pobj);
 801
 802                         folder->items = g_list_remove(folder->items, obj);
 803                         if (obj->type == ADDR_GROUP) {
 804                                 remFlag = TRUE;
 805                         }
 806                         else if (obj->type == ADDR_VCARD) {
 807                                 remFlag = TRUE;
 808                         }
 809                         else if (obj->type == ADDR_JPILOT) {
 810                                 remFlag = TRUE;
 811                         }
 812                         else if (obj->type == ADDR_LDAP) {
 813                                 remFlag = TRUE;
 814                         }
 815
 816                         if( remFlag ) {
 817                                 GtkCTreeNode *node;
 818                                 node = gtk_ctree_find_by_row_data
 819                                         (ctree, addrbook.opened, obj);
 820                                 if (node) gtk_ctree_remove_node(ctree, node);
 821                         }
 822                 } else
 823                         continue;
 824
 825                 addressbook_delete_object(obj);
 826
 827                 gtk_clist_remove(clist, row);
 828         }
 829 }
 830
 831 static void addressbook_reg_clicked(GtkButton *button, gpointer data)
 832 {
 833         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
 834         GtkEntry *entry = GTK_ENTRY(addrbook.entry);
 835         AddressObject *obj;
 836         AddressItem *item;
 837         gchar *str;
 838
 839         if (*gtk_entry_get_text(entry) == '\0') {
 840                 addressbook_new_address_cb(NULL, 0, NULL);
 841                 return;
 842         }
 843         if (!addrbook.opened) return;
 844
 845         obj = gtk_ctree_node_get_row_data(ctree, addrbook.opened);
 846         if (!obj) return;
 847
 848         g_return_if_fail(obj->type == ADDR_GROUP || obj->type == ADDR_FOLDER);
 849
 850         str = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);
 851
 852         item = addressbook_parse_address(str);
 853         g_free(str);
 854         if (item) {
 855                 if (addressbook_find_object_by_name
 856                         (addrbook.opened, item->name) != NULL) {
 857                         addressbook_delete_object(ADDRESS_OBJECT(item));
 858                         item = NULL;
 859                 } else if (addressbook_edit_address(item) == NULL) {
 860                         addressbook_delete_object(ADDRESS_OBJECT(item));
 861                         return;
 862                 }
 863         }
 864
 865         if (!item) {
 866                 item = addressbook_edit_address(NULL);
 867                 if (!item) return;
 868         }
 869
 870         if (addressbook_find_object_by_name(addrbook.opened, item->name)) {
 871                 addressbook_delete_object(ADDRESS_OBJECT(item));
 872                 return;
 873         }
 874
 875         addressbook_add_object(addrbook.opened, ADDRESS_OBJECT(item));
 876         addrbook.open_folder = TRUE;
 877         gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
 878 }
 879
 880 static AddressItem *addressbook_parse_address(const gchar *str)
 881 {
 882         gchar *name    = NULL;
 883         gchar *address = NULL;
 884         AddressItem *item;
 885         gchar *buf;
 886         gchar *start, *end;
 887
 888         Xalloca(buf, strlen(str) + 1, return NULL);
 889
 890         strcpy(buf, str);
 891         g_strstrip(buf);
 892         if (*buf == '\0') return NULL;
 893
 894         if ((start = strchr(buf, '<'))) {
 895                 if (start > buf) {
 896                         *start = '\0';
 897                         g_strstrip(buf);
 898                         if (*buf != '\0')
 899                                 name = g_strdup(buf);
 900                 }
 901                 start++;
 902                 if ((end = strchr(start, '>'))) {
 903                         *end = '\0';
 904                         g_strstrip(start);
 905                         if (*start != '\0')
 906                                 address = g_strdup(start);
 907                 }
 908         } else
 909                 name = g_strdup(buf);
 910
 911         if (!name && !address) return NULL;
 912
 913         item = mgu_create_address();
 914         ADDRESS_OBJECT_TYPE(item) = ADDR_ITEM;
 915         item->name    = name;
 916         item->address = address;
 917         item->remarks = NULL;
 918
 919         return item;
 920 }
 921
 922 static void addressbook_to_clicked(GtkButton *button, gpointer data)
 923 {
 924         GtkCList *clist = GTK_CLIST(addrbook.clist);
 925         GList *cur;
 926
 927         if (!addrbook.target_compose) return;
 928
 929         for (cur = clist->selection; cur != NULL; cur = cur->next) {
 930                 AddressObject *obj;
 931
 932                 obj = gtk_clist_get_row_data(clist,
 933                                              GPOINTER_TO_INT(cur->data));
 934                 if (!obj) return;
 935
 936                 if (obj->type == ADDR_ITEM) {
 937                         addressbook_append_to_compose_entry
 938                                 (ADDRESS_ITEM(obj), (ComposeEntryType)data);
 939                 } else if (obj->type == ADDR_GROUP) {
 940                         AddressGroup *group;
 941                         GList *cur_item;
 942
 943                         group = ADDRESS_GROUP(obj);
 944                         for (cur_item = group->items; cur_item != NULL;
 945                              cur_item = cur_item->next) {
 946                                 if (ADDRESS_OBJECT(cur_item->data)->type
 947                                     != ADDR_ITEM)
 948                                         continue;
 949                                 addressbook_append_to_compose_entry
 950                                         (ADDRESS_ITEM(cur_item->data),
 951                                          (ComposeEntryType)data);
 952                         }
 953                 }
 954         }
 955 }
 956
 957 static void addressbook_append_to_compose_entry(AddressItem *item,
 958                                                 ComposeEntryType type)
 959 {
 960         Compose *compose = addrbook.target_compose;
 961
 962         if (item->name && item->address) {
 963                 gchar *buf;
 964
 965                 buf = g_strdup_printf
 966                         ("%s <%s>", item->name, item->address);
 967                 compose_entry_append(compose, buf, type);
 968                 g_free(buf);
 969         } else if (item->address)
 970                 compose_entry_append(compose, item->address, type);
 971 }
 972
 973 static void addressbook_menubar_set_sensitive( gboolean sensitive ) {
 974         menu_set_sensitive( addrbook.menu_factory, "/File/New Address", sensitive );
 975         menu_set_sensitive( addrbook.menu_factory, "/File/New Group",   sensitive );
 976         menu_set_sensitive( addrbook.menu_factory, "/File/New Folder",  sensitive );
 977         menu_set_sensitive( addrbook.menu_factory, "/File/New V-Card",  sensitive );
 978 #ifdef USE_JPILOT
 979         menu_set_sensitive( addrbook.menu_factory, "/File/New J-Pilot", sensitive );
 980 #endif
 981 #ifdef USE_LDAP
 982         menu_set_sensitive( addrbook.menu_factory, "/File/New Server",  sensitive );
 983 #endif
 984         gtk_widget_set_sensitive( addrbook.reg_btn, sensitive );
 985         gtk_widget_set_sensitive( addrbook.del_btn, sensitive );
 986 }
 987
 988 static void addressbook_menuitem_set_sensitive( AddressObject *obj, GtkCTreeNode *node ) {
 989         gboolean canEdit = TRUE;
 990         if( obj->type == ADDR_FOLDER ) {
 991                 if( node == addrbook.common ) {
 992                         canEdit = FALSE;
 993                 }
 994                 if( node == addrbook.personal ) {
 995                         canEdit = FALSE;
 996                 }
 997                 if( node == addrbook.vcard ) {
 998                         canEdit = FALSE;
 999                         menu_set_sensitive( addrbook.menu_factory, "/File/New V-Card", TRUE );
1000                 }
1001 #ifdef USE_JPILOT
1002                 else if( node == addrbook.jpilot ) {
1003                         canEdit = FALSE;
1004                         if( _have_pilot_library_ ) {
1005                                 menu_set_sensitive( addrbook.menu_factory, "/File/New J-Pilot", TRUE );
1006                         }
1007                 }
1008 #endif
1009 #ifdef USE_LDAP
1010                 else if( node == addrbook.ldap ) {
1011                         canEdit = FALSE;
1012                         if( _have_ldap_library_ ) {
1013                                 menu_set_sensitive( addrbook.menu_factory, "/File/New Server", TRUE );
1014                         }
1015                 }
1016 #endif
1017                 else {
1018                         menu_set_sensitive( addrbook.menu_factory, "/File/New Address", TRUE );
1019                         menu_set_sensitive( addrbook.menu_factory, "/File/New Group",   TRUE );
1020                         menu_set_sensitive( addrbook.menu_factory, "/File/New Folder",  TRUE );
1021                         gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1022                         gtk_widget_set_sensitive( addrbook.del_btn, TRUE );
1023                 }
1024         }
1025         else if( obj->type == ADDR_GROUP ) {
1026                 menu_set_sensitive( addrbook.menu_factory, "/File/New Address", TRUE );
1027                 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1028                 gtk_widget_set_sensitive( addrbook.del_btn, TRUE );
1029         }
1030 #ifdef USE_JPILOT
1031         else if( obj->type == ADDR_JPILOT ) {
1032                 if( ! _have_pilot_library_ ) canEdit = FALSE;
1033         }
1034         else if( obj->type == ADDR_CATEGORY ) {
1035                 canEdit = FALSE;
1036         }
1037 #endif
1038 #ifdef USE_LDAP
1039         else if( obj->type == ADDR_LDAP ) {
1040                 if( ! _have_ldap_library_ ) canEdit = FALSE;
1041         }
1042 #endif
1043         menu_set_sensitive( addrbook.menu_factory, "/File/Edit",    canEdit );
1044         menu_set_sensitive( addrbook.menu_factory, "/File/Delete",  canEdit );
1045 }
1046
1047 static void addressbook_tree_selected(GtkCTree *ctree, GtkCTreeNode *node,
1048                                       gint column, gpointer data)
1049 {
1050         AddressObject *obj;
1051
1052         addrbook.selected = node;
1053         addrbook.open_folder = FALSE;
1054         addressbook_status_show( "" );
1055         if( addrbook.entry != NULL ) {
1056                 gtk_entry_set_text(GTK_ENTRY(addrbook.entry), "");
1057         }
1058
1059         obj = gtk_ctree_node_get_row_data(ctree, node);
1060         if( obj == NULL ) return;
1061
1062         addrbook.opened = node;
1063
1064         if(     obj->type == ADDR_GROUP || obj->type == ADDR_FOLDER ||
1065                 obj->type == ADDR_VCARD || obj->type == ADDR_JPILOT ||
1066                 obj->type == ADDR_CATEGORY || obj->type == ADDR_LDAP ) {
1067                 addressbook_set_clist(obj);
1068         }
1069
1070         if( obj->type == ADDR_VCARD ) {
1071                 // Read from file
1072                 VCardFile *vcf;
1073                 vcf = ADDRESS_VCARD(obj)->cardFile;
1074                 vcard_read_data( vcf );
1075                 addressbook_vcard_show_message( vcf );
1076                 ADDRESS_VCARD(obj)->items = vcard_get_address_list( vcf );
1077                 addressbook_set_clist( obj );
1078         }
1079 #ifdef USE_JPILOT
1080         else if( obj->type == ADDR_JPILOT ) {
1081                 if( _have_pilot_library_ ) {
1082                         // Read from file
1083                         JPilotFile *jpf;
1084                         GList *catList, *catNode;
1085                         AddressCategory *acat;
1086                         GtkCTreeNode *childNode, *nextNode;
1087                         GtkCTreeRow *currRow;
1088
1089                         jpf = ADDRESS_JPILOT(obj)->pilotFile;
1090                         addressbook_jpilot_show_message( jpf );
1091                         if( jpilot_get_modified( jpf ) ) {
1092                                 jpilot_read_data( jpf );
1093                                 catList = jpilot_get_category_items( jpf );
1094
1095                                 // Remove existing categories
1096                                 currRow = GTK_CTREE_ROW( node );
1097                                 if( currRow ) {
1098                                         while( nextNode = currRow->children ) {
1099                                                 gtk_ctree_remove_node( ctree, nextNode );
1100                                         }
1101                                 }
1102
1103                                 // Load new categories into the tree.
1104                                 catNode = catList;
1105                                 while( catNode ) {
1106                                         AddressItem *item = catNode->data;
1107                                         acat = g_new(AddressCategory, 1);
1108                                         ADDRESS_OBJECT_TYPE(acat) = ADDR_CATEGORY;
1109                                         acat->name = g_strdup( item->name );
1110                                         acat->items = NULL;
1111                                         acat->pilotFile = jpf;
1112                                         acat->category = item;
1113                                         catNode = g_list_next( catNode );
1114                                         addressbook_add_object(node, ADDRESS_OBJECT(acat));
1115                                 }
1116
1117                                 ADDRESS_JPILOT(obj)->items = catList;
1118                         }
1119                         addressbook_set_clist( obj );
1120                 }
1121         }
1122         else if( obj->type == ADDR_CATEGORY ) {
1123                 if( _have_pilot_library_ ) {
1124                         // Read from file
1125                         JPilotFile *jpf;
1126
1127                         jpf = ADDRESS_JPILOT(obj)->pilotFile;
1128                         if( jpilot_get_modified( jpf ) ) {
1129                                 // Force parent to be reloaded
1130                                 gtk_ctree_select( GTK_CTREE(addrbook.ctree), GTK_CTREE_ROW(node)->parent);
1131                                 gtk_ctree_expand( GTK_CTREE(addrbook.ctree), GTK_CTREE_ROW(node)->parent);
1132                         }
1133                         else {
1134                                 AddressItem *item = NULL;
1135                                 AddressCategory *acat = ADDRESS_CATEGORY(obj);
1136                                 if( acat ) item = acat->category;
1137                                 if( item ) {
1138                                         ADDRESS_CATEGORY(obj)->items =
1139                                                 jpilot_get_address_list_cat( jpf, item->categoryID );
1140                                 }
1141                                 addressbook_set_clist( obj );
1142                         }
1143                 }
1144         }
1145 #endif
1146 #ifdef USE_LDAP
1147         else if( obj->type == ADDR_LDAP ) {
1148                 if( _have_ldap_library_ ) {
1149                         // Read from cache
1150                         SyldapServer *server;
1151                         server = ADDRESS_LDAP(obj)->ldapServer;
1152                         addressbook_ldap_show_message( server );
1153                         if( ! server->busyFlag ) {
1154                                 ADDRESS_LDAP(obj)->items = syldap_get_address_list( server );
1155                                 addressbook_set_clist( obj );
1156                         }
1157                 }
1158         }
1159 #endif
1160
1161         // Setup main menu selections
1162         addressbook_menubar_set_sensitive( FALSE );
1163         addressbook_menuitem_set_sensitive( obj, node );
1164 }
1165
1166 static void addressbook_list_selected(GtkCList *clist, gint row, gint column,
1167                                       GdkEvent *event, gpointer data)
1168 {
1169         GtkEntry *entry = GTK_ENTRY(addrbook.entry);
1170         AddressObject *obj;
1171         GList *cur;
1172
1173         if (event && event->type == GDK_2BUTTON_PRESS) {
1174                 if (prefs_common.add_address_by_click &&
1175                     addrbook.target_compose)
1176                         addressbook_to_clicked(NULL, NULL);
1177                 else
1178                         addressbook_edit_address_cb(NULL, 0, NULL);
1179                 return;
1180         }
1181
1182 #if 0
1183         gtk_signal_handler_block_by_func
1184                 (GTK_OBJECT(entry),
1185                  GTK_SIGNAL_FUNC(addressbook_entry_changed), NULL);
1186 #endif
1187
1188         gtk_entry_set_text(entry, "");
1189
1190         for (cur = clist->selection; cur != NULL; cur = cur->next) {
1191                 obj = gtk_clist_get_row_data(clist,
1192                                              GPOINTER_TO_INT(cur->data));
1193                 g_return_if_fail(obj != NULL);
1194
1195                 if (obj->type == ADDR_ITEM) {
1196                         AddressItem *item;
1197
1198                         item = ADDRESS_ITEM(obj);
1199                         if (item->name && item->address) {
1200                                 gchar *buf;
1201
1202                                 buf = g_strdup_printf
1203                                         ("%s <%s>", item->name, item->address);
1204                                 if (*gtk_entry_get_text(entry) != '\0')
1205                                         gtk_entry_append_text(entry, ", ");
1206                                 gtk_entry_append_text(entry, buf);
1207                                 g_free(buf);
1208                         } else if (item->address) {
1209                                 if (*gtk_entry_get_text(entry) != '\0')
1210                                         gtk_entry_append_text(entry, ", ");
1211                                 gtk_entry_append_text(entry, item->address);
1212                         }
1213                 }
1214         }
1215
1216 #if 0
1217         gtk_signal_handler_unblock_by_func
1218                 (GTK_OBJECT(entry),
1219                  GTK_SIGNAL_FUNC(addressbook_entry_changed), NULL);
1220 #endif
1221 }
1222
1223 #if 0
1224 static void addressbook_entry_changed(GtkWidget *widget)
1225 {
1226         GtkCList *clist = GTK_CLIST(addrbook.clist);
1227         GtkEntry *entry = GTK_ENTRY(addrbook.entry);
1228         const gchar *str;
1229         gint len;
1230         gint row;
1231
1232         //if (clist->selection && clist->selection->next) return;
1233
1234         str = gtk_entry_get_text(entry);
1235         if (*str == '\0') {
1236                 gtk_clist_unselect_all(clist);
1237                 return;
1238         }
1239         len = strlen(str);
1240
1241         for (row = 0; row < clist->rows; row++) {
1242                 AddressObject *obj;
1243                 const gchar *name;
1244
1245                 obj = ADDRESS_OBJECT(gtk_clist_get_row_data(clist, row));
1246                 if (!obj) continue;
1247                 if (obj->type == ADDR_ITEM)
1248                         name = ADDRESS_ITEM(obj)->name;
1249                 else if (obj->type == ADDR_GROUP)
1250                         name = ADDRESS_GROUP(obj)->name;
1251                 else
1252                         continue;
1253
1254                 if (name && !strncasecmp(name, str, len)) {
1255                         gtk_clist_unselect_all(clist);
1256                         gtk_clist_select_row(clist, row, -1);
1257                         return;
1258                 }
1259         }
1260
1261         gtk_clist_unselect_all(clist);
1262 }
1263 #endif
1264
1265 static void addressbook_entry_gotfocus( GtkWidget *widget ) {
1266         gtk_editable_select_region( GTK_EDITABLE(addrbook.entry), 0, -1 );
1267 }
1268
1269 static void addressbook_list_button_pressed(GtkWidget *widget,
1270                                             GdkEventButton *event,
1271                                             gpointer data)
1272 {
1273         GtkCList *clist = GTK_CLIST(widget);
1274         gint row, column;
1275         gint tRow, tCol;
1276         AddressObject *obj, *pobj;
1277
1278         if (!event) return;
1279
1280         obj = gtk_ctree_node_get_row_data(GTK_CTREE(addrbook.ctree),
1281                                           addrbook.opened);
1282         g_return_if_fail(obj != NULL);
1283
1284         pobj = gtk_ctree_node_get_row_data(GTK_CTREE(addrbook.ctree), addrbook.selected);
1285         if( pobj ) {
1286                 if(     pobj->type == ADDR_VCARD ||
1287                         pobj->type == ADDR_JPILOT ||
1288                         pobj->type == ADDR_CATEGORY ||
1289                         pobj->type == ADDR_LDAP ) {
1290                         menu_set_sensitive(addrbook.menu_factory, "/File/Edit", FALSE);
1291                         menu_set_sensitive(addrbook.menu_factory, "/File/Delete", FALSE);
1292                 }
1293         }
1294
1295         if (event->button != 3) return;
1296         menu_set_insensitive_all(GTK_MENU_SHELL(addrbook.list_popup));
1297
1298         if (gtk_clist_get_selection_info
1299                 (clist, event->x, event->y, &row, &column)) {
1300                 GtkCListRow *clist_row;
1301
1302                 clist_row = g_list_nth(clist->row_list, row)->data;
1303                 if (clist_row->state != GTK_STATE_SELECTED) {
1304                         gtk_clist_unselect_all(clist);
1305                         gtk_clist_select_row(clist, row, column);
1306                 }
1307                 gtkut_clist_set_focus_row(clist, row);
1308
1309                 if(     obj->type != ADDR_VCARD &&
1310                         obj->type != ADDR_JPILOT &&
1311                         obj->type != ADDR_CATEGORY &&
1312                         obj->type != ADDR_LDAP ) {
1313                         menu_set_sensitive(addrbook.list_factory, "/Edit", TRUE);
1314                         menu_set_sensitive(addrbook.list_factory, "/Delete", TRUE);
1315                 }
1316         }
1317
1318         if( !(  addrbook.opened == addrbook.vcard ||
1319                 addrbook.opened == addrbook.jpilot ||
1320                 addrbook.opened == addrbook.ldap ) ) {
1321
1322                 if( obj->type == ADDR_FOLDER || obj->type == ADDR_GROUP ) {
1323                         menu_set_sensitive(addrbook.list_factory, "/New Address", TRUE);
1324                         gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1325                         gtk_widget_set_sensitive( addrbook.del_btn, TRUE );
1326                 }
1327                 if (obj->type == ADDR_FOLDER) {
1328                         menu_set_sensitive(addrbook.list_factory, "/New Folder", TRUE);
1329                         menu_set_sensitive(addrbook.list_factory, "/New Group", TRUE);
1330                 }
1331         }
1332         gtk_menu_popup(GTK_MENU(addrbook.list_popup), NULL, NULL, NULL, NULL,
1333                        event->button, event->time);
1334 }
1335
1336 static void addressbook_list_button_released(GtkWidget *widget,
1337                                              GdkEventButton *event,
1338                                              gpointer data)
1339 {
1340 }
1341
1342 static void addressbook_tree_button_pressed(GtkWidget *ctree,
1343                                             GdkEventButton *event,
1344                                             gpointer data)
1345 {
1346         GtkCList *clist = GTK_CLIST(ctree);
1347         gint row, column;
1348         AddressObject *obj;
1349         GtkCTreeNode *node;
1350
1351         if (!event) return;
1352         if (event->button == 1) {
1353                 addrbook.open_folder = TRUE;
1354                 return;
1355         }
1356         if (event->button != 3) return;
1357
1358         if (!gtk_clist_get_selection_info
1359                 (clist, event->x, event->y, &row, &column)) return;
1360         gtk_clist_select_row(clist, row, column);
1361
1362         obj = gtk_clist_get_row_data(clist, row);
1363         g_return_if_fail(obj != NULL);
1364
1365         menu_set_insensitive_all(GTK_MENU_SHELL(addrbook.tree_popup));
1366
1367         if (obj->type == ADDR_FOLDER) {
1368                 node = gtk_ctree_node_nth(GTK_CTREE(ctree), row);
1369                 if( node == addrbook.vcard ) {
1370                         menu_set_sensitive(addrbook.tree_factory, "/New V-Card", TRUE);
1371                 }
1372 #ifdef USE_JPILOT
1373                 else if( node == addrbook.jpilot ) {
1374                         if( _have_pilot_library_ ) {
1375                                 menu_set_sensitive(addrbook.tree_factory, "/New J-Pilot", TRUE);
1376                         }
1377                 }
1378 #endif
1379 #ifdef USE_LDAP
1380                 else if( node == addrbook.ldap ) {
1381                         if( _have_ldap_library_ ) {
1382                                 menu_set_sensitive(addrbook.tree_factory, "/New Server", TRUE);
1383                         }
1384                 }
1385 #endif
1386                 else {
1387                         menu_set_sensitive(addrbook.tree_factory, "/New Address", TRUE);
1388                         menu_set_sensitive(addrbook.tree_factory, "/New Folder", TRUE);
1389                         menu_set_sensitive(addrbook.tree_factory, "/New Group", TRUE);
1390                         if (node && GTK_CTREE_ROW(node)->level >= 2) {
1391                                 menu_set_sensitive(addrbook.tree_factory, "/Edit", TRUE);
1392                                 menu_set_sensitive(addrbook.tree_factory, "/Delete", TRUE);
1393                         }
1394                         gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1395                         gtk_widget_set_sensitive( addrbook.del_btn, TRUE );
1396                 }
1397         }
1398         else if (obj->type == ADDR_GROUP) {
1399                 menu_set_sensitive(addrbook.tree_factory, "/New Address", TRUE);
1400                 menu_set_sensitive(addrbook.tree_factory, "/Edit", TRUE);
1401                 menu_set_sensitive(addrbook.tree_factory, "/Delete", TRUE);
1402                 gtk_widget_set_sensitive( addrbook.reg_btn, TRUE );
1403                 gtk_widget_set_sensitive( addrbook.del_btn, TRUE );
1404         }
1405         else if (obj->type == ADDR_VCARD) {
1406                 menu_set_sensitive(addrbook.tree_factory, "/Edit", TRUE);
1407                 menu_set_sensitive(addrbook.tree_factory, "/Delete", TRUE);
1408         }
1409 #ifdef USE_JPILOT
1410         else if (obj->type == ADDR_JPILOT) {
1411                 if( _have_pilot_library_ ) {
1412                         menu_set_sensitive(addrbook.tree_factory, "/Edit", TRUE);
1413                         menu_set_sensitive(addrbook.tree_factory, "/Delete", TRUE);
1414                 }
1415         }
1416         else if (obj->type == ADDR_CATEGORY) {
1417                 if( _have_pilot_library_ ) {
1418                         menu_set_sensitive(addrbook.tree_factory, "/Edit", FALSE);
1419                         menu_set_sensitive(addrbook.tree_factory, "/Delete", FALSE);
1420                 }
1421         }
1422 #endif
1423 #ifdef USE_LDAP
1424         else if (obj->type == ADDR_LDAP) {
1425                 if( _have_ldap_library_ ) {
1426                         menu_set_sensitive(addrbook.tree_factory, "/Edit", TRUE);
1427                         menu_set_sensitive(addrbook.tree_factory, "/Delete", TRUE);
1428                 }
1429         }
1430 #endif
1431         else {
1432                 return;
1433         }
1434         gtk_menu_popup(GTK_MENU(addrbook.tree_popup), NULL, NULL, NULL, NULL,
1435                        event->button, event->time);
1436 }
1437
1438 static void addressbook_tree_button_released(GtkWidget *ctree,
1439                                              GdkEventButton *event,
1440                                              gpointer data)
1441 {
1442         gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
1443         gtkut_ctree_set_focus_row(GTK_CTREE(addrbook.ctree), addrbook.opened);
1444 }
1445
1446 static void addressbook_popup_close(GtkMenuShell *menu_shell, gpointer data)
1447 {
1448         if (!addrbook.opened) return;
1449
1450         gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
1451         gtkut_ctree_set_focus_row(GTK_CTREE(addrbook.ctree),
1452                                   addrbook.opened);
1453 }
1454
1455 static void addressbook_new_folder_cb(gpointer data, guint action,
1456                                       GtkWidget *widget)
1457 {
1458         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1459         AddressObject *obj;
1460         AddressFolder *folder;
1461         gchar *new_folder;
1462
1463         if (!addrbook.selected) return;
1464
1465         obj = gtk_ctree_node_get_row_data(ctree, addrbook.selected);
1466         g_return_if_fail(obj != NULL);
1467         if (obj->type != ADDR_FOLDER) return;
1468
1469         new_folder = input_dialog(_("New folder"),
1470                                   _("Input the name of new folder:"),
1471                                   _("NewFolder"));
1472         if (!new_folder) return;
1473         g_strstrip(new_folder);
1474         if (*new_folder == '\0') {
1475                 g_free(new_folder);
1476                 return;
1477         }
1478
1479         if (gtk_ctree_find_by_row_data_custom(ctree, addrbook.selected,
1480                                               new_folder,
1481                                               addressbook_obj_name_compare)) {
1482                 alertpanel_error(_("The name already exists."));
1483                 g_free(new_folder);
1484                 return;
1485         }
1486
1487         folder = g_new(AddressFolder, 1);
1488         ADDRESS_OBJECT_TYPE(folder) = ADDR_FOLDER;
1489         folder->name = g_strdup(new_folder);
1490         folder->items = NULL;
1491
1492         addressbook_add_object(addrbook.selected, ADDRESS_OBJECT(folder));
1493
1494         g_free(new_folder);
1495
1496         if (addrbook.selected == addrbook.opened)
1497                 addressbook_set_clist(obj);
1498 }
1499
1500 static void addressbook_new_group_cb(gpointer data, guint action,
1501                                      GtkWidget *widget)
1502 {
1503         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1504         AddressObject *obj;
1505         AddressGroup *group;
1506         gchar *new_group;
1507
1508         if (!addrbook.selected) return;
1509
1510         obj = gtk_ctree_node_get_row_data(ctree, addrbook.selected);
1511         g_return_if_fail(obj != NULL);
1512         if (obj->type != ADDR_FOLDER) return;
1513
1514         new_group = input_dialog(_("New group"),
1515                                  _("Input the name of new group:"),
1516                                   _("NewGroup"));
1517         if (!new_group) return;
1518         g_strstrip(new_group);
1519         if (*new_group == '\0') {
1520                 g_free(new_group);
1521                 return;
1522         }
1523
1524         if (gtk_ctree_find_by_row_data_custom(ctree, addrbook.selected,
1525                                               new_group,
1526                                               addressbook_obj_name_compare)) {
1527                 alertpanel_error(_("The name already exists."));
1528                 g_free(new_group);
1529                 return;
1530         }
1531
1532         group = g_new(AddressGroup, 1);
1533         ADDRESS_OBJECT_TYPE(group) = ADDR_GROUP;
1534         group->name = g_strdup(new_group);
1535         group->items = NULL;
1536
1537         addressbook_add_object(addrbook.selected, ADDRESS_OBJECT(group));
1538
1539         g_free(new_group);
1540
1541         if (addrbook.selected == addrbook.opened)
1542                 addressbook_set_clist(obj);
1543 }
1544
1545 static void addressbook_change_node_name(GtkCTreeNode *node, const gchar *name)
1546 {
1547         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1548         gchar *text[1];
1549         guint8 spacing;
1550         GdkPixmap *pix_cl, *pix_op;
1551         GdkBitmap *mask_cl, *mask_op;
1552         gboolean is_leaf, expanded;
1553
1554         gtk_ctree_get_node_info(ctree, node, text, &spacing,
1555                                 &pix_cl, &mask_cl, &pix_op, &mask_op,
1556                                 &is_leaf, &expanded);
1557         gtk_ctree_set_node_info(ctree, node, name, spacing,
1558                                 pix_cl, mask_cl, pix_op, mask_op,
1559                                 is_leaf, expanded);
1560 }
1561
1562 static void addressbook_edit_group(GtkCTreeNode *group_node)
1563 {
1564         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1565         GtkCList *clist = GTK_CLIST(addrbook.clist);
1566         AddressObject *obj;
1567         AddressGroup *group;
1568         gchar *new_name;
1569         GtkCTreeNode *node;
1570
1571         if (!group_node && clist->selection) {
1572                 obj = gtk_clist_get_row_data(clist,
1573                                              GPOINTER_TO_INT(clist->selection->data));
1574                 g_return_if_fail(obj != NULL);
1575                 if (obj->type != ADDR_GROUP) return;
1576                 node = gtk_ctree_find_by_row_data
1577                         (ctree, addrbook.selected, obj);
1578                 if (!node) return;
1579         } else {
1580                 if (group_node)
1581                         node = group_node;
1582                 else
1583                         node = addrbook.selected;
1584                 obj = gtk_ctree_node_get_row_data(ctree, node);
1585                 g_return_if_fail(obj != NULL);
1586                 if (obj->type != ADDR_GROUP) return;
1587         }
1588
1589         group = ADDRESS_GROUP(obj);
1590
1591         new_name = input_dialog(_("Edit group"),
1592                                 _("Input the new name of group:"),
1593                                 group->name);
1594         if (!new_name) return;
1595         g_strstrip(new_name);
1596         if (*new_name == '\0') {
1597                 g_free(new_name);
1598                 return;
1599         }
1600
1601         if (gtk_ctree_find_by_row_data_custom(ctree, addrbook.selected,
1602                                               new_name,
1603                                               addressbook_obj_name_compare)) {
1604                 alertpanel_error(_("The name already exists."));
1605                 g_free(new_name);
1606                 return;
1607         }
1608
1609         g_free(group->name);
1610         group->name = g_strdup(new_name);
1611
1612         addressbook_change_node_name(node, new_name);
1613         gtk_ctree_sort_node(ctree, GTK_CTREE_ROW(node)->parent);
1614
1615         g_free(new_name);
1616
1617         addrbook.open_folder = TRUE;
1618         gtk_ctree_select(ctree, addrbook.opened);
1619 }
1620
1621 static void addressbook_edit_folder_cb(gpointer data, guint action,
1622                                        GtkWidget *widget)
1623 {
1624         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1625         AddressObject *obj;
1626         AddressFolder *folder;
1627         gchar *new_name = NULL;
1628         GtkCTreeNode *node = NULL, *parentNode = NULL;
1629
1630         if (!addrbook.selected) return;
1631         if (GTK_CTREE_ROW(addrbook.selected)->level == 1) return;
1632
1633         obj = gtk_ctree_node_get_row_data(ctree, addrbook.selected);
1634         g_return_if_fail(obj != NULL);
1635         g_return_if_fail(obj->type == ADDR_FOLDER || obj->type == ADDR_GROUP ||
1636                         obj->type == ADDR_VCARD || obj->type == ADDR_JPILOT ||
1637                         obj->type == ADDR_CATEGORY || obj->type == ADDR_LDAP );
1638
1639         if (obj->type == ADDR_GROUP) {
1640                 addressbook_edit_group(addrbook.selected);
1641                 return;
1642         }
1643
1644         if( obj->type == ADDR_VCARD ) {
1645                 AddressVCard *vcard = ADDRESS_VCARD(obj);
1646                 if( addressbook_edit_vcard( vcard ) == NULL ) return;
1647                 new_name = vcard->name;
1648                 parentNode = addrbook.vcard;
1649         }
1650 #ifdef USE_JPILOT
1651         else if( obj->type == ADDR_JPILOT ) {
1652                 AddressJPilot *jpilot = ADDRESS_JPILOT(obj);
1653                 if( ! _have_pilot_library_ ) return;
1654                 if( addressbook_edit_jpilot( jpilot ) == NULL ) return;
1655                 new_name = jpilot->name;
1656                 parentNode = addrbook.jpilot;
1657         }
1658 #endif
1659 #ifdef USE_LDAP
1660         else if( obj->type == ADDR_LDAP ) {
1661                 AddressLDAP *ldapi = ADDRESS_LDAP(obj);
1662                 if( ! _have_ldap_library_ ) return;
1663                 if( addressbook_edit_ldap( ldapi ) == NULL ) return;
1664                 new_name = ldapi->name;
1665                 parentNode = addrbook.ldap;
1666         }
1667 #endif
1668
1669         if( new_name && parentNode) {
1670                 // Update node in tree view
1671                 node = gtk_ctree_find_by_row_data( ctree, addrbook.selected, obj );
1672                 if( ! node ) return;
1673                 addressbook_change_node_name( node, new_name );
1674                 gtk_ctree_sort_node(ctree, parentNode);
1675                 addrbook.open_folder = TRUE;
1676                 gtk_ctree_select( GTK_CTREE(addrbook.ctree), node );
1677                 return;
1678         }
1679
1680         folder = ADDRESS_FOLDER(obj);
1681         new_name = input_dialog(_("Edit folder"),
1682                                 _("Input the new name of folder:"),
1683                                 folder->name);
1684
1685         if (!new_name) return;
1686         g_strstrip(new_name);
1687         if (*new_name == '\0') {
1688                 g_free(new_name);
1689                 return;
1690         }
1691
1692         if (gtk_ctree_find_by_row_data_custom(ctree, addrbook.selected,
1693                                               new_name,
1694                                               addressbook_obj_name_compare)) {
1695                 alertpanel_error(_("The name already exists."));
1696                 g_free(new_name);
1697                 return;
1698         }
1699
1700         g_free(folder->name);
1701         folder->name = g_strdup(new_name);
1702
1703         addressbook_change_node_name(addrbook.selected, new_name);
1704         gtk_ctree_sort_node(ctree, GTK_CTREE_ROW(addrbook.selected)->parent);
1705
1706         g_free(new_name);
1707 }
1708
1709 static void addressbook_delete_folder_cb(gpointer data, guint action,
1710                                          GtkWidget *widget)
1711 {
1712         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
1713         AddressObject *obj, *pobj;
1714         gchar *name;
1715         gchar *message;
1716         AlertValue aval;
1717
1718         if (!addrbook.selected) return;
1719         if (GTK_CTREE_ROW(addrbook.selected)->level == 1) return;
1720
1721         obj = gtk_ctree_node_get_row_data(ctree, addrbook.selected);
1722         g_return_if_fail(obj != NULL);
1723
1724         if (obj->type == ADDR_GROUP)
1725                 name = ADDRESS_GROUP(obj)->name;
1726         else if (obj->type == ADDR_FOLDER)
1727                 name = ADDRESS_FOLDER(obj)->name;
1728         else if (obj->type == ADDR_VCARD)
1729                 name = ADDRESS_VCARD(obj)->name;
1730 #ifdef USE_JPILOT
1731         else if (obj->type == ADDR_JPILOT) {
1732                 if( ! _have_pilot_library_ ) return;
1733                 name = ADDRESS_JPILOT(obj)->name;
1734         }
1735 #endif
1736 #ifdef USE_LDAP
1737         else if (obj->type == ADDR_LDAP) {
1738                 if( ! _have_ldap_library_ ) return;
1739                 name = ADDRESS_LDAP(obj)->name;
1740         }
1741 #endif
1742         else
1743                 return;
1744
1745         message = g_strdup_printf(_("Really delete `%s' ?"), name);
1746         aval = alertpanel(_("Delete"), message, _("Yes"), _("No"), NULL);
1747         g_free(message);
1748         if (aval != G_ALERTDEFAULT) return;
1749
1750         pobj = gtk_ctree_node_get_row_data
1751                 (ctree, GTK_CTREE_ROW(addrbook.selected)->parent);
1752         if (!pobj) return;
1753         g_return_if_fail(pobj->type == ADDR_FOLDER);
1754         ADDRESS_FOLDER(pobj)->items =
1755                 g_list_remove(ADDRESS_FOLDER(pobj)->items, obj);
1756
1757         addressbook_delete_object(obj);
1758         addrbook.open_folder = TRUE;
1759         gtk_ctree_remove_node(ctree, addrbook.selected);
1760         addrbook.open_folder = FALSE;
1761 }
1762
1763 #define SET_LABEL_AND_ENTRY(str, entry, top) \
1764 { \
1765         label = gtk_label_new(str); \
1766         gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), \
1767                          GTK_FILL, 0, 0, 0); \
1768         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); \
1769  \
1770         entry = gtk_entry_new(); \
1771         gtk_table_attach(GTK_TABLE(table), entry, 1, 2, top, (top + 1), \
1772                          GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); \
1773 }
1774
1775 static void addressbook_edit_address_create(gboolean *cancelled)
1776 {
1777         GtkWidget *window;
1778         GtkWidget *vbox;
1779         GtkWidget *table;
1780         GtkWidget *label;
1781         GtkWidget *name_entry;
1782         GtkWidget *addr_entry;
1783         GtkWidget *rem_entry;
1784         GtkWidget *hbbox;
1785         GtkWidget *ok_btn;
1786         GtkWidget *cancel_btn;
1787
1788         debug_print("Creating edit_address window...\n");
1789
1790         window = gtk_window_new(GTK_WINDOW_DIALOG);
1791         gtk_widget_set_usize(window, 400, -1);
1792         gtk_container_set_border_width(GTK_CONTAINER(window), 8);
1793         gtk_window_set_title(GTK_WINDOW(window), _("Edit address"));
1794         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
1795         gtk_window_set_modal(GTK_WINDOW(window), TRUE);
1796         gtk_signal_connect(GTK_OBJECT(window), "delete_event",
1797                            GTK_SIGNAL_FUNC(edit_address_delete_event),
1798                            cancelled);
1799         gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
1800                            GTK_SIGNAL_FUNC(edit_address_key_pressed),
1801                            cancelled);
1802
1803         vbox = gtk_vbox_new(FALSE, 8);
1804         gtk_container_add(GTK_CONTAINER(window), vbox);
1805
1806         table = gtk_table_new(3, 2, FALSE);
1807         gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
1808         gtk_table_set_row_spacings(GTK_TABLE(table), 8);
1809         gtk_table_set_col_spacings(GTK_TABLE(table), 8);
1810
1811         SET_LABEL_AND_ENTRY(_("Name"),    name_entry, 0);
1812         SET_LABEL_AND_ENTRY(_("Address"), addr_entry, 1);
1813         SET_LABEL_AND_ENTRY(_("Remarks"), rem_entry,  2);
1814
1815         gtkut_button_set_create(&hbbox, &ok_btn, _("OK"),
1816                                 &cancel_btn, _("Cancel"), NULL, NULL);
1817         gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
1818         gtk_widget_grab_default(ok_btn);
1819
1820         gtk_signal_connect(GTK_OBJECT(ok_btn), "clicked",
1821                            GTK_SIGNAL_FUNC(edit_address_ok), cancelled);
1822         gtk_signal_connect(GTK_OBJECT(cancel_btn), "clicked",
1823                            GTK_SIGNAL_FUNC(edit_address_cancel), cancelled);
1824
1825         gtk_widget_show_all(vbox);
1826
1827         addredit.window     = window;
1828         addredit.name_entry = name_entry;
1829         addredit.addr_entry = addr_entry;
1830         addredit.rem_entry  = rem_entry;
1831         addredit.ok_btn     = ok_btn;
1832         addredit.cancel_btn = cancel_btn;
1833 }
1834
1835 static void edit_address_ok(GtkWidget *widget, gboolean *cancelled)
1836 {
1837         *cancelled = FALSE;
1838         gtk_main_quit();
1839 }
1840
1841 static void edit_address_cancel(GtkWidget *widget, gboolean *cancelled)
1842 {
1843         *cancelled = TRUE;
1844         gtk_main_quit();
1845 }
1846
1847 static gint edit_address_delete_event(GtkWidget *widget, GdkEventAny *event,
1848                                       gboolean *cancelled)
1849 {
1850         *cancelled = TRUE;
1851         gtk_main_quit();
1852
1853         return TRUE;
1854 }
1855
1856 static void edit_address_key_pressed(GtkWidget *widget, GdkEventKey *event,
1857                                      gboolean *cancelled)
1858 {
1859         if (event && event->keyval == GDK_Escape) {
1860                 *cancelled = TRUE;
1861                 gtk_main_quit();
1862         }
1863 }
1864
1865 static AddressItem *addressbook_edit_address(AddressItem *item)
1866 {
1867         static gboolean cancelled;
1868         const gchar *str;
1869
1870         if (!addredit.window)
1871                 addressbook_edit_address_create(&cancelled);
1872         gtk_widget_grab_focus(addredit.ok_btn);
1873         gtk_widget_grab_focus(addredit.name_entry);
1874         gtk_widget_show(addredit.window);
1875         manage_window_set_transient(GTK_WINDOW(addredit.window));
1876
1877         gtk_entry_set_text(GTK_ENTRY(addredit.name_entry), "");
1878         gtk_entry_set_text(GTK_ENTRY(addredit.addr_entry), "");
1879         gtk_entry_set_text(GTK_ENTRY(addredit.rem_entry),  "");
1880
1881         if (item) {
1882                 if (item->name)
1883                         gtk_entry_set_text(GTK_ENTRY(addredit.name_entry),
1884                                            item->name);
1885                 if (item->address)
1886                         gtk_entry_set_text(GTK_ENTRY(addredit.addr_entry),
1887                                            item->address);
1888                 if (item->remarks)
1889                         gtk_entry_set_text(GTK_ENTRY(addredit.rem_entry),
1890                                            item->remarks);
1891         }
1892
1893         gtk_main();
1894         gtk_widget_hide(addredit.window);
1895         if (cancelled == TRUE) return NULL;
1896
1897         str = gtk_entry_get_text(GTK_ENTRY(addredit.name_entry));
1898         if (*str == '\0') return NULL;
1899
1900         if (!item) {
1901                 item = mgu_create_address();
1902                 ADDRESS_OBJECT_TYPE(item) = ADDR_ITEM;
1903         }
1904
1905         g_free(item->name);
1906         item->name = g_strdup(str);
1907
1908         str = gtk_entry_get_text(GTK_ENTRY(addredit.addr_entry));
1909         g_free(item->address);
1910         if (*str == '\0')
1911                 item->address = NULL;
1912         else
1913                 item->address = g_strdup(str);
1914
1915         str = gtk_entry_get_text(GTK_ENTRY(addredit.rem_entry));
1916         g_free(item->remarks);
1917         if (*str == '\0')
1918                 item->remarks = NULL;
1919         else
1920                 item->remarks = g_strdup(str);
1921
1922         return item;
1923 }
1924
1925 static void addressbook_new_address_cb(gpointer data, guint action,
1926                                        GtkWidget *widget)
1927 {
1928         AddressItem *item;
1929
1930         item = addressbook_edit_address(NULL);
1931
1932         if (item) {
1933                 addressbook_add_object(addrbook.selected,
1934                                        ADDRESS_OBJECT(item));
1935                 if (addrbook.selected == addrbook.opened) {
1936                         addrbook.open_folder = TRUE;
1937                         gtk_ctree_select(GTK_CTREE(addrbook.ctree),
1938                                          addrbook.opened);
1939                 }
1940         }
1941 }
1942
1943 static void addressbook_edit_address_cb(gpointer data, guint action,
1944                                         GtkWidget *widget)
1945 {
1946         GtkCList *clist = GTK_CLIST(addrbook.clist);
1947         GtkCTree *ctree;
1948         AddressObject *obj, *pobj;
1949         GtkCTreeNode *node = NULL, *parentNode = NULL;
1950         gchar *nodeName;
1951
1952         if (!clist->selection) {
1953                 addressbook_edit_folder_cb(NULL, 0, NULL);
1954                 return;
1955         }
1956
1957         obj = gtk_clist_get_row_data(clist, GPOINTER_TO_INT(clist->selection->data));
1958         g_return_if_fail(obj != NULL);
1959
1960         pobj = gtk_ctree_node_get_row_data(GTK_CTREE(addrbook.ctree), addrbook.selected);
1961
1962         if (obj->type == ADDR_ITEM) {
1963                 AddressItem *item = ADDRESS_ITEM(obj);
1964
1965                 if( pobj ) {
1966                         // Prevent edit of readonly items
1967                         if(     pobj->type == ADDR_VCARD ||
1968                                 pobj->type == ADDR_JPILOT ||
1969                                 pobj->type == ADDR_CATEGORY ||
1970                                 pobj->type == ADDR_LDAP ) return;
1971                 }
1972
1973                 if (addressbook_edit_address(item) == NULL) return;
1974
1975                 addrbook.open_folder = TRUE;
1976                 gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
1977                 return;
1978         }
1979         else if (obj->type == ADDR_GROUP) {
1980                 addressbook_edit_group(NULL);
1981                 return;
1982         }
1983         else if( obj->type == ADDR_VCARD ) {
1984                 AddressVCard *vcard = ADDRESS_VCARD(obj);
1985                 if( addressbook_edit_vcard( vcard ) == NULL ) return;
1986                 nodeName = vcard->name;
1987                 parentNode = addrbook.vcard;
1988         }
1989 #ifdef USE_JPILOT
1990         else if( obj->type == ADDR_JPILOT ) {
1991                 AddressJPilot *jpilot = ADDRESS_JPILOT(obj);
1992                 if( addressbook_edit_jpilot( jpilot ) == NULL ) return;
1993                 nodeName = jpilot->name;
1994                 parentNode = addrbook.jpilot;
1995         }
1996 #endif
1997 #ifdef USE_LDAP
1998         else if( obj->type == ADDR_LDAP ) {
1999                 AddressLDAP *ldapi = ADDRESS_LDAP(obj);
2000                 if( addressbook_edit_ldap( ldapi ) == NULL ) return;
2001                 nodeName = ldapi->name;
2002                 parentNode = addrbook.ldap;
2003         }
2004 #endif
2005         else {
2006                 return;
2007         }
2008
2009         // Update tree node with node name
2010         ctree = GTK_CTREE( addrbook.ctree );
2011         node = gtk_ctree_find_by_row_data( ctree, addrbook.selected, obj );
2012         if( ! node ) return;
2013         addressbook_change_node_name( node, nodeName );
2014         gtk_ctree_sort_node(ctree, parentNode );
2015         addrbook.open_folder = TRUE;
2016         gtk_ctree_select( ctree, addrbook.opened );
2017 }
2018
2019 static void addressbook_delete_address_cb(gpointer data, guint action,
2020                                           GtkWidget *widget)
2021 {
2022         addressbook_del_clicked(NULL, NULL);
2023 }
2024
2025 static void close_cb(gpointer data, guint action, GtkWidget *widget)
2026 {
2027         addressbook_close();
2028 }
2029
2030 static void addressbook_set_clist(AddressObject *obj)
2031 {
2032         GtkCList *clist = GTK_CLIST(addrbook.clist);
2033         GList *items;
2034         gchar *text[N_COLS];
2035
2036         if (!obj) {
2037                 gtk_clist_clear(clist);
2038                 return;
2039         }
2040
2041         gtk_clist_freeze(clist);
2042         gtk_clist_clear(clist);
2043
2044         if (obj->type == ADDR_GROUP)
2045                 items = ADDRESS_GROUP(obj)->items;
2046         else if (obj->type == ADDR_FOLDER) {
2047                 items = ADDRESS_FOLDER(obj)->items;
2048         }
2049         else if (obj->type == ADDR_VCARD) {
2050                 items = ADDRESS_VCARD(obj)->items;
2051         }
2052 #ifdef USE_JPILOT
2053         else if (obj->type == ADDR_JPILOT) {
2054                 items = ADDRESS_JPILOT(obj)->items;
2055         }
2056         else if (obj->type == ADDR_CATEGORY) {
2057                 items = ADDRESS_CATEGORY(obj)->items;
2058         }
2059 #endif
2060 #ifdef USE_LDAP
2061         else if (obj->type == ADDR_LDAP) {
2062                 items = ADDRESS_LDAP(obj)->items;
2063         }
2064 #endif
2065         else {
2066                 gtk_clist_thaw(clist);
2067                 return;
2068         }
2069
2070         for (; items != NULL; items = items->next) {
2071                 AddressObject *iobj;
2072                 gint row;
2073                 iobj = ADDRESS_OBJECT(items->data);
2074                 if( iobj == NULL ) continue;
2075
2076                 if (iobj->type == ADDR_GROUP) {
2077                         AddressGroup *group;
2078
2079                         group = ADDRESS_GROUP(iobj);
2080                         text[COL_NAME]    = group->name;
2081                         text[COL_ADDRESS] = NULL;
2082                         text[COL_REMARKS] = NULL;
2083                         row = gtk_clist_append(clist, text);
2084                         gtk_clist_set_pixtext(clist, row, COL_NAME,
2085                                               group->name, 4,
2086                                               groupxpm, groupxpmmask);
2087                         gtk_clist_set_row_data(clist, row, iobj);
2088                 } if (iobj->type == ADDR_VCARD) {
2089                         AddressVCard *vcard;
2090
2091                         vcard = ADDRESS_VCARD(iobj);
2092                         text[COL_NAME]    = vcard->name;
2093                         text[COL_ADDRESS] = NULL;
2094                         text[COL_REMARKS] = NULL;
2095                         row = gtk_clist_append(clist, text);
2096                         gtk_clist_set_pixtext(clist, row, COL_NAME,
2097                                               vcard->name, 4,
2098                                               vcardxpm, vcardxpmmask);
2099                         gtk_clist_set_row_data(clist, row, iobj);
2100 #ifdef USE_JPILOT
2101                 } if (iobj->type == ADDR_JPILOT) {
2102                         AddressJPilot *jpilot;
2103
2104                         jpilot = ADDRESS_JPILOT(iobj);
2105                         text[COL_NAME]    = jpilot->name;
2106                         text[COL_ADDRESS] = NULL;
2107                         text[COL_REMARKS] = NULL;
2108                         row = gtk_clist_append(clist, text);
2109                         gtk_clist_set_pixtext(clist, row, COL_NAME,
2110                                               jpilot->name, 4,
2111                                               jpilotxpm, jpilotxpmmask);
2112                         gtk_clist_set_row_data(clist, row, iobj);
2113                 } if (iobj->type == ADDR_CATEGORY) {
2114                         AddressCategory *category;
2115
2116                         category = ADDRESS_CATEGORY(iobj);
2117                         text[COL_NAME]    = category->name;
2118                         text[COL_ADDRESS] = NULL;
2119                         text[COL_REMARKS] = NULL;
2120                         row = gtk_clist_append(clist, text);
2121                         gtk_clist_set_pixtext(clist, row, COL_NAME,
2122                                               category->name, 4,
2123                                               categoryxpm, categoryxpmmask);
2124                         gtk_clist_set_row_data(clist, row, iobj);
2125 #endif
2126 #ifdef USE_LDAP
2127                 } if (iobj->type == ADDR_LDAP) {
2128                         AddressLDAP *ldapi;
2129
2130                         ldapi = ADDRESS_LDAP(iobj);
2131                         text[COL_NAME]    = ldapi->name;
2132                         text[COL_ADDRESS] = NULL;
2133                         text[COL_REMARKS] = NULL;
2134                         row = gtk_clist_append(clist, text);
2135                         gtk_clist_set_pixtext(clist, row, COL_NAME,
2136                                               ldapi->name, 4,
2137                                               ldapxpm, ldapxpmmask);
2138                         gtk_clist_set_row_data(clist, row, iobj);
2139 #endif
2140                 } else if (iobj->type == ADDR_ITEM) {
2141                         AddressItem *item;
2142
2143                         item = ADDRESS_ITEM(iobj);
2144                         text[COL_NAME]    = item->name;
2145                         text[COL_ADDRESS] = item->address;
2146                         text[COL_REMARKS] = item->remarks;
2147                         row = gtk_clist_append(clist, text);
2148                         gtk_clist_set_row_data(clist, row, iobj);
2149                 }
2150         }
2151
2152         gtk_clist_sort(clist);
2153         gtk_clist_thaw(clist);
2154 }
2155
2156 static void addressbook_read_file(void)
2157 {
2158         XMLFile *file;
2159         gchar *path;
2160
2161         debug_print(_("Reading addressbook file..."));
2162
2163         path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, ADDRESS_BOOK, NULL);
2164         if ((file = xml_open_file(path)) == NULL) {
2165                 debug_print(_("%s doesn't exist.\n"), path);
2166                 g_free(path);
2167                 addressbook_get_tree(NULL, addrbook.common, ADDRESS_TAG_COMMON);
2168                 addressbook_get_tree(NULL, addrbook.personal, ADDRESS_TAG_PERSONAL);
2169                 addressbook_get_tree(NULL, addrbook.vcard, ADDRESS_TAG_VCARD);
2170 #ifdef USE_JPILOT
2171                 addressbook_get_tree(NULL, addrbook.jpilot, ADDRESS_TAG_JPILOT);
2172 #endif
2173 #ifdef USE_LDAP
2174                 addressbook_get_tree(NULL, addrbook.ldap, ADDRESS_TAG_LDAP);
2175 #endif
2176                 return;
2177         }
2178         g_free(path);
2179
2180         xml_get_dtd(file);
2181
2182         if (xml_parse_next_tag(file) < 0 ||
2183             xml_compare_tag(file, "addressbook") == FALSE) {
2184                 g_warning("Invalid addressbook data\n");
2185                 xml_close_file(file);
2186                 return;
2187         }
2188
2189         addressbook_get_tree(file, addrbook.common, ADDRESS_TAG_COMMON);
2190         addressbook_get_tree(file, addrbook.personal, ADDRESS_TAG_PERSONAL);
2191         addressbook_get_tree(file, addrbook.vcard, ADDRESS_TAG_VCARD);
2192 #ifdef USE_JPILOT
2193         addressbook_get_tree(file, addrbook.jpilot, ADDRESS_TAG_JPILOT);
2194 #endif
2195 #ifdef USE_LDAP
2196         addressbook_get_tree(file, addrbook.ldap, ADDRESS_TAG_LDAP);
2197 #endif
2198
2199         xml_close_file(file);
2200
2201         debug_print(_("done.\n"));
2202 }
2203
2204 static void addressbook_get_tree(XMLFile *file, GtkCTreeNode *node,
2205                                  const gchar *folder_tag)
2206 {
2207         AddressFolder *folder;
2208
2209         g_return_if_fail(node != NULL);
2210
2211         folder = g_new(AddressFolder, 1);
2212         ADDRESS_OBJECT(folder)->type = ADDR_FOLDER;
2213         folder->name = g_strdup(folder_tag);
2214         folder->items = NULL;
2215         gtk_ctree_node_set_row_data(GTK_CTREE(addrbook.ctree), node, folder);
2216
2217         if (file) {
2218                 if (xml_parse_next_tag(file) < 0 ||
2219                     xml_compare_tag(file, folder_tag) == FALSE) {
2220                         g_warning("Invalid addressbook data\n");
2221                         return;
2222                 }
2223         }
2224
2225         if (file) addressbook_add_objs(file, node);
2226 }
2227
2228 static void addressbook_add_objs(XMLFile *file, GtkCTreeNode *node)
2229 {
2230         GList *attr;
2231         guint prev_level;
2232         GtkCTreeNode *new_node;
2233
2234         for (;;) {
2235                 prev_level = file->level;
2236                 if (xml_parse_next_tag(file) < 0) return;
2237                 if (file->level < prev_level) return;
2238
2239                 if (xml_compare_tag(file, "group")) {
2240                         AddressGroup *group;
2241
2242                         group = g_new(AddressGroup, 1);
2243                         ADDRESS_OBJECT_TYPE(group) = ADDR_GROUP;
2244                         attr = xml_get_current_tag_attr(file);
2245                         if (attr)
2246                                 group->name = g_strdup(((XMLAttr *)attr->data)->value);
2247                         else
2248                                 group->name = NULL;
2249                         group->items = NULL;
2250
2251                         new_node = addressbook_add_object
2252                                 (node, ADDRESS_OBJECT(group));
2253
2254                         addressbook_add_objs(file, new_node);
2255                 } else if (xml_compare_tag(file, "folder")) {
2256                         AddressFolder *folder;
2257
2258                         folder = g_new(AddressFolder, 1);
2259                         ADDRESS_OBJECT_TYPE(folder) = ADDR_FOLDER;
2260                         attr = xml_get_current_tag_attr(file);
2261                         if (attr)
2262                                 folder->name = g_strdup(((XMLAttr *)attr->data)->value);
2263                         else
2264                                 folder->name = NULL;
2265                         folder->items = NULL;
2266
2267                         new_node = addressbook_add_object
2268                                 (node, ADDRESS_OBJECT(folder));
2269
2270                         addressbook_add_objs(file, new_node);
2271                 }
2272                 else if( xml_compare_tag( file, "vcard" ) ) {
2273                         AddressVCard *vcard;
2274                         vcard = addressbook_parse_vcard( file );
2275                         if( ! vcard ) return;
2276                         new_node = addressbook_add_object
2277                                 (node, ADDRESS_OBJECT(vcard));
2278                 }
2279 #ifdef USE_JPILOT
2280                 else if( xml_compare_tag( file, "jpilot" ) ) {
2281                         AddressJPilot *jpilot;
2282                         jpilot = addressbook_parse_jpilot( file );
2283                         if( ! jpilot ) return;
2284                         new_node = addressbook_add_object
2285                                 (node, ADDRESS_OBJECT(jpilot));
2286                 }
2287 #endif
2288 #ifdef USE_LDAP
2289                 else if( xml_compare_tag( file, "server" ) ) {
2290                         AddressLDAP *ldapi;
2291                         ldapi = addressbook_parse_ldap( file );
2292                         if( ! ldapi ) return;
2293                         new_node = addressbook_add_object
2294                                 (node, ADDRESS_OBJECT(ldapi));
2295                 }
2296 #endif
2297                 else if (xml_compare_tag(file, "item")) {
2298                         AddressItem *item;
2299
2300                         item = addressbook_parse_item(file);
2301                         if (!item) return;
2302                         new_node = addressbook_add_object
2303                                 (node, ADDRESS_OBJECT(item));
2304                 } else {
2305                         g_warning("Invalid tag\n");
2306                         return;
2307                 }
2308         }
2309 }
2310
2311 static GtkCTreeNode *addressbook_add_object(GtkCTreeNode *node,
2312                                             AddressObject *obj)
2313 {
2314         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
2315         GtkCTreeNode *added;
2316         AddressObject *pobj;
2317
2318         g_return_val_if_fail(node != NULL, NULL);
2319         g_return_val_if_fail(obj  != NULL, NULL);
2320
2321         pobj = gtk_ctree_node_get_row_data(ctree, node);
2322         g_return_val_if_fail(pobj != NULL, NULL);
2323
2324         if (pobj->type == ADDR_ITEM) {
2325                 g_warning("Parent object mustn't be an item.\n");
2326                 return NULL;
2327         }
2328         if (pobj->type == ADDR_FOLDER &&
2329             (obj->type == ADDR_GROUP || obj->type == ADDR_FOLDER))
2330                 gtk_ctree_expand(ctree, node);
2331
2332         if (pobj->type == ADDR_FOLDER && obj->type == ADDR_VCARD )
2333                 gtk_ctree_expand(ctree, node);
2334
2335         if (pobj->type == ADDR_FOLDER && obj->type == ADDR_JPILOT )
2336                 gtk_ctree_expand(ctree, node);
2337
2338         if (pobj->type == ADDR_FOLDER && obj->type == ADDR_LDAP )
2339                 gtk_ctree_expand(ctree, node);
2340
2341         if (obj->type == ADDR_GROUP) {
2342                 AddressGroup *group = ADDRESS_GROUP(obj);
2343
2344                 if (pobj->type != ADDR_FOLDER) {
2345                         g_warning("Group can't be added in another group.\n");
2346                         return NULL;
2347                 }
2348
2349                 added = gtk_ctree_insert_node(ctree, node, NULL,
2350                                               &group->name, FOLDER_SPACING,
2351                                               groupxpm, groupxpmmask,
2352                                               groupxpm, groupxpmmask,
2353                                               TRUE, FALSE);
2354                 gtk_ctree_node_set_row_data(ctree, added, obj);
2355         } else if (obj->type == ADDR_FOLDER) {
2356                 AddressFolder *folder = ADDRESS_FOLDER(obj);
2357
2358                 if (pobj->type != ADDR_FOLDER) {
2359                         g_warning("Group can't contain folder.\n");
2360                         return NULL;
2361                 }
2362
2363                 added = gtk_ctree_insert_node(ctree, node, NULL,
2364                                               &folder->name, FOLDER_SPACING,
2365                                               folderxpm, folderxpmmask,
2366                                               folderopenxpm, folderopenxpmmask,
2367                                               FALSE, FALSE);
2368                 gtk_ctree_node_set_row_data(ctree, added, obj);
2369
2370         }
2371         else if (obj->type == ADDR_VCARD) {
2372                 AddressVCard *vcard = ADDRESS_VCARD(obj);
2373                 added = gtk_ctree_insert_node(ctree, node, NULL,
2374                                               &vcard->name, FOLDER_SPACING,
2375                                               vcardxpm, vcardxpmmask,
2376                                               vcardxpm, vcardxpmmask,
2377                                               TRUE, FALSE);
2378                 gtk_ctree_node_set_row_data(ctree, added, obj);
2379         }
2380 #ifdef USE_JPILOT
2381         else if (obj->type == ADDR_JPILOT) {
2382                 AddressJPilot *jpilot = ADDRESS_JPILOT(obj);
2383                 added = gtk_ctree_insert_node(ctree, node, NULL,
2384                                               &jpilot->name, FOLDER_SPACING,
2385                                               jpilotxpm, jpilotxpmmask,
2386                                               jpilotxpm, jpilotxpmmask,
2387                                               FALSE, FALSE);
2388                 gtk_ctree_node_set_row_data(ctree, added, obj);
2389         }
2390         else if (obj->type == ADDR_CATEGORY) {
2391                 AddressCategory *category = ADDRESS_CATEGORY(obj);
2392                 added = gtk_ctree_insert_node(ctree, node, NULL,
2393                                               &category->name, FOLDER_SPACING,
2394                                               categoryxpm, categoryxpmmask,
2395                                               categoryxpm, categoryxpmmask,
2396                                               TRUE, FALSE);
2397                 gtk_ctree_node_set_row_data(ctree, added, obj);
2398         }
2399 #endif
2400 #ifdef USE_LDAP
2401         else if (obj->type == ADDR_LDAP) {
2402                 AddressLDAP *server = ADDRESS_LDAP(obj);
2403                 added = gtk_ctree_insert_node(ctree, node, NULL,
2404                                               &server->name, FOLDER_SPACING,
2405                                               ldapxpm, ldapxpmmask,
2406                                               ldapxpm, ldapxpmmask,
2407                                               TRUE, FALSE);
2408                 gtk_ctree_node_set_row_data(ctree, added, obj);
2409         }
2410 #endif
2411         else {
2412                 added = node;
2413         }
2414
2415         if (obj->type == ADDR_GROUP || obj->type == ADDR_ITEM) {
2416                 if (pobj->type == ADDR_GROUP) {
2417                         AddressGroup *group = ADDRESS_GROUP(pobj);
2418
2419                         group->items = g_list_append(group->items, obj);
2420                 } else if (pobj->type == ADDR_FOLDER) {
2421                         AddressFolder *folder = ADDRESS_FOLDER(pobj);
2422
2423                         folder->items = g_list_append(folder->items, obj);
2424                 }
2425         }
2426
2427         if (pobj->type == ADDR_FOLDER) {
2428                 if (obj->type == ADDR_VCARD || obj->type == ADDR_JPILOT || obj->type == ADDR_LDAP) {
2429                         AddressFolder *folder = ADDRESS_FOLDER(pobj);
2430                         folder->items = g_list_append(folder->items, obj);
2431                 }
2432         }
2433
2434         gtk_ctree_sort_node(ctree, node);
2435
2436         return added;
2437 }
2438
2439 static void addressbook_delete_object(AddressObject *obj)
2440 {
2441         if (!obj) return;
2442
2443         if (obj->type == ADDR_ITEM) {
2444                 AddressItem *item = ADDRESS_ITEM(obj);
2445
2446                 mgu_free_address( item );
2447         } else if (obj->type == ADDR_GROUP) {
2448                 AddressGroup *group = ADDRESS_GROUP(obj);
2449
2450                 g_free(group->name);
2451                 while (group->items != NULL) {
2452                         addressbook_delete_object
2453                                 (ADDRESS_OBJECT(group->items->data));
2454                         group->items = g_list_remove(group->items,
2455                                                      group->items->data);
2456                 }
2457                 g_free(group);
2458         } else if (obj->type == ADDR_FOLDER) {
2459                 AddressFolder *folder = ADDRESS_FOLDER(obj);
2460
2461                 g_free(folder->name);
2462                 while (folder->items != NULL) {
2463                         addressbook_delete_object
2464                                 (ADDRESS_OBJECT(folder->items->data));
2465                         folder->items = g_list_remove(folder->items,
2466                                                       folder->items->data);
2467                 }
2468                 g_free(folder);
2469         }
2470         else if( obj->type == ADDR_VCARD ) {
2471                 AddressVCard *vcard = ADDRESS_VCARD(obj);
2472                 g_free( vcard->name );
2473                 vcard_free( vcard->cardFile );
2474                 vcard->cardFile = NULL;
2475                 vcard->items = NULL;
2476                 g_free( vcard );
2477         }
2478 #ifdef USE_JPILOT
2479         else if( obj->type == ADDR_JPILOT ) {
2480                 AddressJPilot *jpilot = ADDRESS_JPILOT(obj);
2481                 g_free( jpilot->name );
2482                 jpilot_free( jpilot->pilotFile );
2483                 jpilot->pilotFile = NULL;
2484                 jpilot->items = NULL;
2485                 g_free( jpilot );
2486         }
2487 #endif
2488 #ifdef USE_LDAP
2489         else if( obj->type == ADDR_LDAP ) {
2490                 AddressLDAP *ldapi = ADDRESS_LDAP(obj);
2491                 g_free( ldapi->name );
2492                 syldap_free( ldapi->ldapServer );
2493                 ldapi->ldapServer = NULL;
2494                 ldapi->items = NULL;
2495                 g_free( ldapi );
2496         }
2497 #endif
2498 }
2499
2500 static AddressObject *addressbook_find_object_by_name(GtkCTreeNode *node,
2501                                                       const gchar *name)
2502 {
2503         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
2504         AddressObject *obj;
2505         GList *found;
2506
2507         g_return_val_if_fail(node != NULL, NULL);
2508
2509         obj = gtk_ctree_node_get_row_data(ctree, node);
2510         g_return_val_if_fail(obj != NULL, NULL);
2511
2512         if (obj->type == ADDR_GROUP) {
2513                 AddressGroup *group = ADDRESS_GROUP(obj);
2514
2515                 found = g_list_find_custom(group->items, (gpointer)name,
2516                                            addressbook_obj_name_compare);
2517                 if (found) return ADDRESS_OBJECT(found->data);
2518         } else if (obj->type == ADDR_FOLDER) {
2519                 AddressFolder *folder = ADDRESS_FOLDER(obj);
2520
2521                 found = g_list_find_custom(folder->items, (gpointer)name,
2522                                            addressbook_obj_name_compare);
2523                 if (found) return ADDRESS_OBJECT(found->data);
2524         } else if (obj->type == ADDR_ITEM) {
2525                 if (!addressbook_obj_name_compare(obj, name)) return obj;
2526         }
2527
2528         return NULL;
2529 }
2530
2531 static AddressItem *addressbook_parse_item(XMLFile *file)
2532 {
2533         gchar *element;
2534         AddressItem *item;
2535         guint level;
2536
2537         item = mgu_create_address();
2538         ADDRESS_OBJECT(item)->type = ADDR_ITEM;
2539
2540         level = file->level;
2541
2542         while (xml_parse_next_tag(file) == 0) {
2543                 if (file->level < level) return item;
2544                 if (file->level == level) break;
2545
2546                 element = xml_get_element(file);
2547
2548                 if (xml_compare_tag(file, "name")) {
2549                         item->name = element;
2550                 } else if (xml_compare_tag(file, "address")) {
2551                         item->address = element;
2552                 } else if (xml_compare_tag(file, "remarks")) {
2553                         item->remarks = element;
2554                 }
2555
2556                 if (xml_parse_next_tag(file) < 0) break;
2557                 if (file->level != level) break;
2558         }
2559
2560         g_warning("addressbook_parse_item(): Parse error\n");
2561         mgu_free_address( item );
2562 }
2563
2564 void addressbook_export_to_file(void)
2565 {
2566         PrefFile *pfile;
2567         gchar *path;
2568
2569         if (!addrbook.ctree) return;
2570
2571         debug_print(_("Exporting addressbook to file..."));
2572
2573         path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, ADDRESS_BOOK, NULL);
2574         if ((pfile = prefs_write_open(path)) == NULL) {
2575                 g_free(path);
2576                 return;
2577         }
2578         g_free(path);
2579
2580         fprintf(pfile->fp, "<?xml version=\"1.0\" encoding=\"%s\"?>\n",
2581                 conv_get_current_charset_str());
2582         fputs("<addressbook>\n\n", pfile->fp);
2583
2584         addressbook_xml_recursive_write(NULL, pfile->fp);
2585
2586         fputs("</addressbook>\n", pfile->fp);
2587
2588         if (prefs_write_close(pfile) < 0) {
2589                 g_warning(_("failed to write addressbook data.\n"));
2590                 return;
2591         }
2592
2593         debug_print(_("done.\n"));
2594 }
2595
2596 /* Most part of this function was taken from gtk_ctree_pre_recursive() and
2597    gtk_ctree_post_recursive(). */
2598 static void addressbook_xml_recursive_write(GtkCTreeNode *node, FILE *fp)
2599 {
2600         GtkCTreeNode *work;
2601         GtkCTreeNode *tmp;
2602
2603         if (node) {
2604                 work = GTK_CTREE_ROW(node)->children;
2605                 addressbook_node_write_begin(node, fp);
2606         } else
2607                 work = GTK_CTREE_NODE(GTK_CLIST(addrbook.ctree)->row_list);
2608
2609         while (work) {
2610                 tmp = GTK_CTREE_ROW(work)->sibling;
2611                 addressbook_xml_recursive_write(work, fp);
2612                 work = tmp;
2613         }
2614
2615         if (node)
2616                 addressbook_node_write_end(node, fp);
2617 }
2618
2619 static void addressbook_node_write_begin(GtkCTreeNode *node, FILE *fp)
2620 {
2621         AddressObject *obj;
2622
2623         obj = gtk_ctree_node_get_row_data(GTK_CTREE(addrbook.ctree), node);
2624         g_return_if_fail(obj != NULL);
2625
2626         if (obj->type == ADDR_FOLDER) {
2627                 AddressFolder *folder = ADDRESS_FOLDER(obj);
2628
2629                 if (GTK_CTREE_ROW(node)->level == 1) {
2630                         fprintf(fp, "<%s>\n", folder->name);
2631                 } else {
2632                         tab_indent_out(fp, GTK_CTREE_ROW(node)->level - 1);
2633                         fputs("<folder name=\"", fp);
2634                         xml_file_put_escape_str(fp, folder->name);
2635                         fputs("\">\n", fp);
2636                 }
2637         } else if (obj->type == ADDR_GROUP) {
2638                 AddressGroup *group = ADDRESS_GROUP(obj);
2639
2640                 tab_indent_out(fp, GTK_CTREE_ROW(node)->level - 1);
2641                 fputs("<group name=\"", fp);
2642                 xml_file_put_escape_str(fp, group->name);
2643                 fputs("\">\n", fp);
2644         }
2645 }
2646
2647 static void addressbook_node_write_end(GtkCTreeNode *node, FILE *fp)
2648 {
2649         AddressObject *obj;
2650
2651         obj = gtk_ctree_node_get_row_data(GTK_CTREE(addrbook.ctree), node);
2652         g_return_if_fail(obj != NULL);
2653
2654         if (obj->type == ADDR_FOLDER) {
2655                 AddressFolder *folder = ADDRESS_FOLDER(obj);
2656
2657                 addressbook_write_items(fp, folder->items,
2658                                         GTK_CTREE_ROW(node)->level);
2659
2660                 if (GTK_CTREE_ROW(node)->level == 1) {
2661                         fprintf(fp, "</%s>\n\n", folder->name);
2662                 } else {
2663                         tab_indent_out(fp, GTK_CTREE_ROW(node)->level - 1);
2664                         fputs("</folder>\n", fp);
2665                 }
2666         } else if (obj->type == ADDR_GROUP) {
2667                 AddressGroup *group = ADDRESS_GROUP(obj);
2668
2669                 addressbook_write_items(fp, group->items,
2670                                         GTK_CTREE_ROW(node)->level);
2671
2672                 tab_indent_out(fp, GTK_CTREE_ROW(node)->level - 1);
2673                 fputs("</group>\n", fp);
2674         }
2675         else if (obj->type == ADDR_VCARD) {
2676                 AddressVCard *vcard = ADDRESS_VCARD(obj);
2677                 addressbook_write_vcard( fp, vcard, GTK_CTREE_ROW(node)->level);
2678         }
2679 #ifdef USE_JPILOT
2680         else if (obj->type == ADDR_JPILOT) {
2681                 AddressJPilot *jpilot = ADDRESS_JPILOT(obj);
2682                 addressbook_write_jpilot( fp, jpilot, GTK_CTREE_ROW(node)->level);
2683         }
2684 #endif
2685 #ifdef USE_LDAP
2686         else if (obj->type == ADDR_LDAP) {
2687                 AddressLDAP *ldap = ADDRESS_LDAP(obj);
2688                 addressbook_write_ldap( fp, ldap, GTK_CTREE_ROW(node)->level);
2689         }
2690 #endif
2691 }
2692
2693 static void addressbook_write_items(FILE *fp, GList *items, guint level)
2694 {
2695         AddressItem *item;
2696
2697         for (; items != NULL; items = items->next) {
2698                 if (ADDRESS_OBJECT_TYPE(items->data) == ADDR_ITEM) {
2699                         item = ADDRESS_ITEM(items->data);
2700
2701                         tab_indent_out(fp, level);
2702                         fputs("<item>\n", fp);
2703
2704                         tab_indent_out(fp, level + 1);
2705                         fputs("<name>", fp);
2706                         xml_file_put_escape_str(fp, item->name);
2707                         fputs("</name>\n", fp);
2708
2709                         tab_indent_out(fp, level + 1);
2710                         fputs("<address>", fp);
2711                         xml_file_put_escape_str(fp, item->address);
2712                         fputs("</address>\n", fp);
2713
2714                         tab_indent_out(fp, level + 1);
2715                         fputs("<remarks>", fp);
2716                         xml_file_put_escape_str(fp, item->remarks);
2717                         fputs("</remarks>\n", fp);
2718
2719                         tab_indent_out(fp, level);
2720                         fputs("</item>\n", fp);
2721                 }
2722         }
2723 }
2724
2725 static void tab_indent_out(FILE *fp, guint level)
2726 {
2727         gint i;
2728
2729         for (i = 0; i < level; i++)
2730                 fputs("    ", fp);
2731 }
2732
2733 static void key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
2734 {
2735         if (event && event->keyval == GDK_Escape)
2736                 addressbook_close();
2737 }
2738
2739 static gint addressbook_list_compare_func(GtkCList *clist,
2740                                           gconstpointer ptr1,
2741                                           gconstpointer ptr2)
2742 {
2743         AddressObject *obj1 = ((GtkCListRow *)ptr1)->data;
2744         AddressObject *obj2 = ((GtkCListRow *)ptr2)->data;
2745         gchar *name1, *name2;
2746
2747         if (obj1) {
2748                 if (obj1->type == ADDR_ITEM)
2749                         name1 = ADDRESS_ITEM(obj1)->name;
2750                 else if (obj1->type == ADDR_GROUP)
2751                         name1 = ADDRESS_GROUP(obj1)->name;
2752                 else if (obj1->type == ADDR_FOLDER)
2753                         name1 = ADDRESS_FOLDER(obj1)->name;
2754                 else if (obj1->type == ADDR_VCARD)
2755                         name1 = ADDRESS_VCARD(obj1)->name;
2756 #ifdef USE_JPILOT
2757                 else if (obj1->type == ADDR_JPILOT)
2758                         name1 = ADDRESS_JPILOT(obj1)->name;
2759                 else if (obj1->type == ADDR_CATEGORY)
2760                         name1 = ADDRESS_CATEGORY(obj1)->name;
2761 #endif
2762 #ifdef USE_LDAP
2763                 else if (obj1->type == ADDR_LDAP)
2764                         name1 = ADDRESS_LDAP(obj1)->name;
2765 #endif
2766                 else
2767                         name1 = NULL;
2768         } else
2769                 name1 = NULL;
2770
2771         if (obj2) {
2772                 if (obj2->type == ADDR_ITEM)
2773                         name2 = ADDRESS_ITEM(obj2)->name;
2774                 else if (obj2->type == ADDR_GROUP)
2775                         name2 = ADDRESS_GROUP(obj2)->name;
2776                 else if (obj2->type == ADDR_FOLDER)
2777                         name2 = ADDRESS_FOLDER(obj2)->name;
2778                 else if (obj2->type == ADDR_VCARD)
2779                         name2 = ADDRESS_VCARD(obj2)->name;
2780 #ifdef USE_JPILOT
2781                 else if (obj2->type == ADDR_JPILOT)
2782                         name2 = ADDRESS_JPILOT(obj2)->name;
2783                 else if (obj2->type == ADDR_CATEGORY)
2784                         name2 = ADDRESS_CATEGORY(obj2)->name;
2785 #endif
2786 #ifdef USE_LDAP
2787                 else if (obj2->type == ADDR_LDAP)
2788                         name2 = ADDRESS_LDAP(obj2)->name;
2789 #endif
2790                 else
2791                         name2 = NULL;
2792         } else
2793                 name2 = NULL;
2794
2795         if (!name1)
2796                 return (name2 != NULL);
2797         if (!name2)
2798                 return -1;
2799
2800         return strcasecmp(name1, name2);
2801 }
2802
2803 static gint addressbook_obj_name_compare(gconstpointer a, gconstpointer b)
2804 {
2805         const AddressObject *obj = a;
2806         const gchar *name = b;
2807
2808         if (!obj || !name) return -1;
2809
2810         if (obj->type == ADDR_GROUP) {
2811                 AddressGroup *group = ADDRESS_GROUP(obj);
2812                 if (!group->name)
2813                         return -1;
2814                 else
2815                         return strcasecmp(group->name, name);
2816         } else if (obj->type == ADDR_FOLDER) {
2817                 AddressFolder *folder = ADDRESS_FOLDER(obj);
2818                 if (!folder->name)
2819                         return -1;
2820                 else
2821                         return strcasecmp(folder->name, name);
2822         }
2823         else if (obj->type == ADDR_VCARD) {
2824                 AddressVCard *vcard = ADDRESS_VCARD(obj);
2825                 if (!vcard->name)
2826                         return -1;
2827                 else
2828                         return strcasecmp(vcard->name, name);
2829         }
2830 #ifdef USE_JPILOT
2831         else if (obj->type == ADDR_JPILOT) {
2832                 AddressJPilot *jpilot = ADDRESS_JPILOT(obj);
2833                 if (!jpilot->name)
2834                         return -1;
2835                 else
2836                         return strcasecmp(jpilot->name, name);
2837         }
2838         else if (obj->type == ADDR_CATEGORY) {
2839                 AddressCategory *category = ADDRESS_CATEGORY(obj);
2840                 if (!category->name)
2841                         return -1;
2842                 else
2843                         return strcasecmp(category->name, name);
2844         }
2845 #endif
2846 #ifdef USE_LDAP
2847         else if (obj->type == ADDR_LDAP) {
2848                 AddressLDAP *server = ADDRESS_LDAP(obj);
2849                 if (!server->name)
2850                         return -1;
2851                 else
2852                         return strcasecmp(server->name, name);
2853         }
2854 #endif
2855         else if (obj->type == ADDR_ITEM) {
2856                 AddressItem *item = ADDRESS_ITEM(obj);
2857                 if (!item->name)
2858                         return -1;
2859                 else
2860                         return strcasecmp(item->name, name);
2861         } else
2862                 return -1;
2863 }
2864
2865 static AddressVCard *addressbook_parse_vcard(XMLFile *file) {
2866         AddressVCard *item = NULL;
2867         VCardFile *vcf;
2868         GList *attr;
2869         gchar *name, *value;
2870
2871         vcf = vcard_create();
2872         attr = xml_get_current_tag_attr( file );
2873         while( attr ) {
2874                 name = ((XMLAttr *)attr->data)->name;
2875                 value = ((XMLAttr *)attr->data)->value;
2876                 if( strcmp( name, "name" ) == 0 ) {
2877                         vcard_set_name( vcf, value );
2878                 }
2879                 else if( strcmp( name, "file" ) == 0) {
2880                         vcard_set_file( vcf, value );
2881                 }
2882                 attr = g_list_next( attr );
2883         }
2884
2885         // Move to next tag
2886         if( xml_parse_next_tag( file ) >= 0 ) {
2887                 if( vcard_validate( vcf ) ) {
2888                         item = g_new( AddressVCard, 1 );
2889                         ADDRESS_OBJECT(item)->type = ADDR_VCARD;
2890                         item->name = g_strdup( vcf->name );
2891                         item->cardFile = vcf;
2892                         item->items = NULL;
2893                         return item;
2894                 }
2895         }
2896
2897         // Must be an invalid tag or data.
2898         g_warning( "addressbook_parse_vcard(): Parse error\n");
2899         vcard_free( vcf );
2900         vcf = NULL;
2901         item = NULL;
2902         return NULL;
2903 }
2904
2905 static void addressbook_write_vcard( FILE *fp, AddressVCard *vcard, guint level ) {
2906         VCardFile *cardFile = vcard->cardFile;
2907         if( cardFile ) {
2908                 tab_indent_out(fp, 1);
2909                 fputs("<vcard ", fp);
2910                 fputs("name=\"", fp);
2911                 xml_file_put_escape_str(fp, cardFile->name);
2912                 fputs("\"", fp);
2913                 fputs(" file=\"", fp);
2914                 xml_file_put_escape_str(fp, cardFile->path);
2915                 fputs("\"", fp);
2916                 fputs(" />\n", fp);
2917         }
2918 }
2919
2920 #ifdef USE_JPILOT
2921 static AddressJPilot *addressbook_parse_jpilot(XMLFile *file) {
2922         AddressJPilot *item = NULL;
2923         JPilotFile *jpf;
2924         GList *attr;
2925         gchar *name, *value;
2926
2927         jpf = jpilot_create();
2928         attr = xml_get_current_tag_attr( file );
2929         while( attr ) {
2930                 name = ((XMLAttr *)attr->data)->name;
2931                 value = ((XMLAttr *)attr->data)->value;
2932                 if( strcmp( name, "name" ) == 0 ) {
2933                         jpilot_set_name( jpf, value );
2934                 }
2935                 else if( strcmp( name, "file" ) == 0 ) {
2936                         jpilot_set_file( jpf, value );
2937                 }
2938                 else if( strcmp( name, "custom-1" ) == 0 ) {
2939                         jpilot_add_custom_label( jpf, value );
2940                 }
2941                 else if( strcmp( name, "custom-2" ) == 0 ) {
2942                         jpilot_add_custom_label( jpf, value );
2943                 }
2944                 else if( strcmp( name, "custom-3" ) == 0 ) {
2945                         jpilot_add_custom_label( jpf, value );
2946                 }
2947                 else if( strcmp( name, "custom-4" ) == 0 ) {
2948                         jpilot_add_custom_label( jpf, value );
2949                 }
2950                 attr = g_list_next( attr );
2951         }
2952
2953         // Move to next tag
2954         if( xml_parse_next_tag( file ) >= 0 ) {
2955                 if( jpilot_validate( jpf ) ) {
2956                         item = g_new( AddressJPilot, 1 );
2957                         ADDRESS_OBJECT(item)->type = ADDR_JPILOT;
2958                         item->name = g_strdup( jpf->name );
2959                         item->pilotFile = jpf;
2960                         item->items = NULL;
2961                         return item;
2962                 }
2963         }
2964
2965         // Must be an invalid tag or data.
2966         g_warning( "addressbook_parse_jpilot(): Parse error\n");
2967         jpilot_free( jpf );
2968         jpf = NULL;
2969         item = NULL;
2970         return NULL;
2971 }
2972
2973 static void addressbook_write_jpilot( FILE *fp, AddressJPilot *jpilot, guint level ) {
2974         JPilotFile *pilotFile = jpilot->pilotFile;
2975         if( pilotFile ) {
2976                 gint ind;
2977                 GList *node;
2978                 GList *customLbl = jpilot_get_custom_labels( pilotFile );
2979                 tab_indent_out(fp, 1);
2980                 fputs("<jpilot ", fp);
2981                 fputs("name=\"", fp);
2982                 xml_file_put_escape_str(fp, pilotFile->name);
2983                 fputs("\" file=\"", fp);
2984                 xml_file_put_escape_str(fp, pilotFile->path);
2985
2986                 fputs( "\" ", fp );
2987                 node = customLbl;
2988                 ind = 1;
2989                 while( node ) {
2990                         fprintf( fp, "custom-%d=\"", ind );
2991                         xml_file_put_escape_str( fp, node->data );
2992                         fputs( "\" ", fp );
2993                         ind++;
2994                         node = g_list_next( node );
2995                 }
2996                 fputs("/>\n", fp);
2997         }
2998 }
2999 #endif
3000
3001 static void addressbook_new_vcard_cb( gpointer data, guint action, GtkWidget *widget ) {
3002         AddressVCard *vcard;
3003
3004         if( addrbook.selected != addrbook.vcard ) return;
3005         vcard = addressbook_edit_vcard( NULL );
3006         if( vcard ) {
3007                 addressbook_add_object( addrbook.selected, ADDRESS_OBJECT(vcard) );
3008                 if( addrbook.selected == addrbook.opened ) {
3009                         addrbook.open_folder = TRUE;
3010                         gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
3011                 }
3012         }
3013 }
3014
3015 static void addressbook_vcard_show_message( VCardFile *vcf ) {
3016         *addressbook_msgbuf = '\0';
3017         if( vcf ) {
3018                 if( vcf->retVal == MGU_SUCCESS ) {
3019                         sprintf( addressbook_msgbuf, "%s", vcf->name );
3020                 }
3021                 else {
3022                         sprintf( addressbook_msgbuf, "%s: %s", vcf->name, mgu_error2string( vcf->retVal ) );
3023                 }
3024         }
3025         addressbook_status_show( addressbook_msgbuf );
3026 }
3027
3028 #ifdef USE_JPILOT
3029 static void addressbook_new_jpilot_cb( gpointer data, guint action, GtkWidget *widget ) {
3030         AddressJPilot *jpilot;
3031
3032         if( addrbook.selected != addrbook.jpilot ) return;
3033         if( ! _have_pilot_library_ ) return;
3034         jpilot = addressbook_edit_jpilot( NULL );
3035         if( jpilot ) {
3036                 addressbook_add_object( addrbook.selected, ADDRESS_OBJECT(jpilot) );
3037                 if( addrbook.selected == addrbook.opened ) {
3038                         addrbook.open_folder = TRUE;
3039                         gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
3040                 }
3041         }
3042 }
3043
3044 static void addressbook_jpilot_show_message( JPilotFile *jpf ) {
3045         *addressbook_msgbuf = '\0';
3046         if( jpf ) {
3047                 if( jpf->retVal == MGU_SUCCESS ) {
3048                         sprintf( addressbook_msgbuf, "%s", jpf->name );
3049                 }
3050                 else {
3051                         sprintf( addressbook_msgbuf, "%s: %s", jpf->name, mgu_error2string( jpf->retVal ) );
3052                 }
3053         }
3054         addressbook_status_show( addressbook_msgbuf );
3055 }
3056
3057 #endif
3058
3059 #ifdef USE_LDAP
3060 static void addressbook_new_ldap_cb( gpointer data, guint action, GtkWidget *widget ) {
3061         AddressLDAP *ldapi;
3062
3063         if( addrbook.selected != addrbook.ldap ) return;
3064         if( ! _have_ldap_library_ ) return;
3065         ldapi = addressbook_edit_ldap( NULL );
3066         if( ldapi ) {
3067                 addressbook_add_object( addrbook.selected, ADDRESS_OBJECT(ldapi) );
3068                 if( addrbook.selected == addrbook.opened ) {
3069                         addrbook.open_folder = TRUE;
3070                         gtk_ctree_select( GTK_CTREE(addrbook.ctree), addrbook.opened );
3071                 }
3072         }
3073 }
3074
3075 static AddressLDAP *addressbook_parse_ldap(XMLFile *file) {
3076         AddressLDAP *item = NULL;
3077         SyldapServer *server;
3078         GList *attr;
3079         gchar *name, *value;
3080         gint ivalue;
3081
3082         server = syldap_create();
3083         attr = xml_get_current_tag_attr( file );
3084         while( attr ) {
3085                 name = ((XMLAttr *)attr->data)->name;
3086                 value = ((XMLAttr *)attr->data)->value;
3087                 ivalue = atoi( value );
3088                 if( strcmp( name, "name" ) == 0 ) {
3089                         syldap_set_name( server, value );
3090                 }
3091                 else if( strcmp( name, "host" ) == 0 ) {
3092                         syldap_set_host( server, value );
3093                 }
3094                 else if( strcmp( name, "port" ) == 0 ) {
3095                         syldap_set_port( server, ivalue );
3096                 }
3097                 else if( strcmp( name, "base-dn" ) == 0 ) {
3098                         syldap_set_base_dn( server, value );
3099                 }
3100                 else if( strcmp( name, "bind-dn" ) == 0 ) {
3101                         syldap_set_bind_dn( server, value );
3102                 }
3103                 else if( strcmp( name, "bind-pass" ) == 0 ) {
3104                         syldap_set_bind_password( server, value );
3105                 }
3106                 else if( strcmp( name, "criteria" ) == 0 ) {
3107                         syldap_set_search_criteria( server, value );
3108                 }
3109                 else if( strcmp( name, "max-entry" ) == 0 ) {
3110                         syldap_set_max_entries( server, ivalue );
3111                 }
3112                 else if( strcmp( name, "timeout" ) == 0 ) {
3113                         syldap_set_timeout( server, ivalue );
3114                 }
3115                 attr = g_list_next( attr );
3116         }
3117
3118         // Move to next tag
3119         if( xml_parse_next_tag( file ) >= 0 ) {
3120                 item = g_new( AddressLDAP, 1 );
3121                 ADDRESS_OBJECT(item)->type = ADDR_LDAP;
3122                 item->name = g_strdup( server->name );
3123                 item->ldapServer = server;
3124                 item->items = NULL;
3125                 return item;
3126         }
3127
3128         // Must be an invalid tag or data.
3129         g_warning( "addressbook_parse_ldap(): Parse error\n");
3130         syldap_free( server );
3131         server = NULL;
3132         item = NULL;
3133         return NULL;
3134 }
3135
3136 static void addressbook_write_ldap( FILE *fp, AddressLDAP *ldapi, guint level ) {
3137         SyldapServer *server = ldapi->ldapServer;
3138         if( server ) {
3139                 tab_indent_out(fp, 1);
3140                 fputs("<server ", fp);
3141                 fputs("name=\"", fp);
3142                 xml_file_put_escape_str(fp, server->name);
3143                 fputs("\" host=\"", fp);
3144                 xml_file_put_escape_str(fp, server->hostName);
3145                 fprintf( fp, "\" port=\"%d", server->port);
3146                 fputs("\" base-dn=\"", fp);
3147                 xml_file_put_escape_str(fp, server->baseDN);
3148                 fputs("\" bind-dn=\"", fp);
3149                 xml_file_put_escape_str(fp, server->bindDN);
3150                 fputs("\" bind-pass=\"", fp);
3151                 xml_file_put_escape_str(fp, server->bindPass);
3152                 fputs("\" criteria=\"", fp);
3153                 xml_file_put_escape_str(fp, server->searchCriteria);
3154                 fprintf( fp, "\" max-entry=\"%d", server->maxEntries);
3155                 fprintf( fp, "\" timeout=\"%d", server->timeOut);
3156                 fputs("\" />\n", fp);
3157         }
3158 }
3159
3160 static void addressbook_ldap_show_message( SyldapServer *svr ) {
3161         *addressbook_msgbuf = '\0';
3162         if( svr ) {
3163                 if( svr->busyFlag ) {
3164                         sprintf( addressbook_msgbuf, "%s: %s", svr->name, ADDRESSBOOK_LDAP_BUSYMSG );
3165                 }
3166                 else {
3167                         if( svr->retVal == MGU_SUCCESS ) {
3168                                 sprintf( addressbook_msgbuf, "%s", svr->name );
3169                         }
3170                         else {
3171                                 sprintf( addressbook_msgbuf, "%s: %s", svr->name, mgu_error2string( svr->retVal ) );
3172                         }
3173                 }
3174         }
3175         addressbook_status_show( addressbook_msgbuf );
3176 }
3177
3178 static gint ldapsearch_callback( SyldapServer *sls ) {
3179         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3180         AddressObject *obj;
3181
3182         if( sls == NULL ) return;
3183         if( ! addrbook.selected ) return;
3184         if( GTK_CTREE_ROW( addrbook.selected )->level == 1 ) return;
3185
3186         obj = gtk_ctree_node_get_row_data( ctree, addrbook.selected );
3187         if( obj == NULL ) return;
3188         if( obj->type == ADDR_LDAP ) {
3189                 AddressLDAP *ldapi = ADDRESS_LDAP(obj);
3190                 SyldapServer *server = ldapi->ldapServer;
3191                 if( server == sls ) {
3192                         if( ! _have_ldap_library_ ) return;
3193                         // Read from cache
3194                         gtk_widget_show_all(addrbook.window);
3195                         ADDRESS_LDAP(obj)->items = syldap_get_address_list( sls );
3196                         addressbook_set_clist( obj );
3197                         addressbook_ldap_show_message( sls );
3198                         gtk_widget_show_all(addrbook.window);
3199                 }
3200         }
3201 }
3202 #endif
3203
3204 /*
3205  * Lookup button handler.
3206  */
3207 static void addressbook_lup_clicked( GtkButton *button, gpointer data ) {
3208         GtkCTree *ctree = GTK_CTREE(addrbook.ctree);
3209         AddressObject *obj;
3210         gchar *sLookup;
3211 #ifdef USE_LDAP
3212         AddressLDAP *ldapi;
3213         SyldapServer *server;
3214 #endif
3215
3216         sLookup = gtk_editable_get_chars( GTK_EDITABLE(addrbook.entry), 0, -1 );
3217         g_strchomp( sLookup );
3218
3219         if( ! addrbook.selected ) return;
3220         if( GTK_CTREE_ROW( addrbook.selected )->level == 1 ) return;
3221
3222         obj = gtk_ctree_node_get_row_data( ctree, addrbook.selected );
3223         if( obj == NULL ) return;
3224
3225 #ifdef USE_LDAP
3226         if( obj->type == ADDR_LDAP ) {
3227                 ldapi = ADDRESS_LDAP(obj);
3228                 server = ldapi->ldapServer;
3229                 if( server ) {
3230                         if( ! _have_ldap_library_ ) return;
3231                         syldap_cancel_read( server );
3232                         if( *sLookup == '\0' || strlen( sLookup ) < 1 ) return;
3233                         syldap_set_search_value( server, sLookup );
3234                         syldap_set_callback( server, ldapsearch_callback );
3235                         syldap_read_data_th( server );
3236                         addressbook_ldap_show_message( server );
3237                 }
3238         }
3239 #endif
3240
3241 }
3242
3243 /***/
3244
3245 typedef struct {
3246         gboolean                init;                   /* if FALSE should init jump buffer */
3247         GtkCTreeNode   *node_found;             /* match (can be used to backtrack folders)  */
3248         AddressObject  *addr_found;             /* match */
3249         int                             level;                  /* current recursion level (0 is root level) */
3250         jmp_buf                 jumper;                 /* jump buffer */
3251 } FindObject;
3252
3253 typedef struct {
3254         FindObject              ancestor;
3255         const gchar        *groupname;
3256 } FindGroup;
3257
3258 typedef struct {
3259         FindObject              ancestor;
3260         const gchar    *name;
3261         const gchar    *address;
3262 } FindAddress;
3263
3264 typedef struct {
3265         FindObject              ancestor;
3266         GList              *grouplist;
3267 } FindAllGroups;
3268
3269 typedef gboolean (*ADDRESSBOOK_TRAVERSE_FUNC)(AddressObject *node, gpointer data);
3270
3271 /***/
3272
3273 static gboolean traverse_find_group_by_name(AddressObject *ao, FindGroup *find)
3274 {
3275         AddressFolder *folder;
3276         AddressGroup  *group;
3277
3278         /* a group or folder: both are groups */
3279         if (ADDRESS_OBJECT_TYPE(ao) == ADDR_GROUP) {
3280                 group = ADDRESS_GROUP(ao);
3281                 if (0 == g_strcasecmp(group->name, find->groupname)) {
3282                         return TRUE;
3283                 }
3284         }
3285         else if (ADDRESS_OBJECT_TYPE(ao) == ADDR_FOLDER) {
3286                 folder = ADDRESS_FOLDER(ao);
3287                 if (0 == g_strcasecmp(folder->name, find->groupname)) {
3288                         return TRUE;
3289                 }
3290         }
3291         return FALSE;
3292 }
3293
3294 static gboolean traverse_find_name_email(AddressObject *ao, FindAddress *find)
3295 {
3296         AddressItem *item;
3297         if (ADDRESS_OBJECT_TYPE(ao) == ADDR_ITEM) {
3298                 gboolean nmatch = FALSE, amatch = FALSE;
3299                 item = ADDRESS_ITEM(ao);
3300                 /* conditions:
3301                  * o only match at the first characters in item strings
3302                  * o match either name or address */
3303                 if (find->name && item->name) {
3304                         nmatch = item->name == strcasestr(item->name, find->name);
3305                 }
3306                 if (find->address && item->address) {
3307                         amatch = item->address == strcasestr(item->address, find->address);
3308                 }
3309                 return nmatch || amatch;
3310         }
3311         return FALSE;
3312 }
3313
3314 static gboolean traverse_find_all_groups(AddressObject *ao, FindAllGroups *find)
3315 {
3316         /* NOTE: added strings come from the address book. should perhaps
3317          * strdup() them, especially if the address book is invalidated */
3318         if (ADDRESS_OBJECT_TYPE(ao) == ADDR_FOLDER) {
3319                 AddressFolder *folder = ADDRESS_FOLDER(ao);
3320                 find->grouplist = g_list_insert_sorted(find->grouplist, (gpointer) folder->name, (GCompareFunc) g_strcasecmp);
3321         }
3322         else if (ADDRESS_OBJECT_TYPE(ao) == ADDR_GROUP) {
3323                 AddressGroup *group = ADDRESS_GROUP(ao);
3324                 find->grouplist = g_list_insert_sorted(find->grouplist, (gpointer) group->name, (GCompareFunc) g_strcasecmp);
3325         }
3326         return FALSE;
3327 }
3328
3329 /* addressbook_traverse() - traverses all address objects stored in the address book.
3330  * for some reason gtkctree's recursive tree functions don't allow a premature return,
3331  * which is what we need if we need to enumerate the tree and check for a condition
3332  * and then skipping other nodes. */
3333 static AddressObject *addressbook_traverse(GtkCTreeNode *node, ADDRESSBOOK_TRAVERSE_FUNC func, FindObject *data, int level)
3334 {
3335         GtkCTreeNode  *current, *tmp;
3336         AddressObject *ao;
3337
3338         if (data->init == FALSE) {
3339                 /* initialize non-local exit */
3340                 data->init  = TRUE;
3341                 data->level = 0;
3342                 /* HANDLE NON-LOCAL EXIT */
3343                 if (setjmp(data->jumper)) {
3344                         return data->addr_found;
3345                 }
3346         }
3347
3348         /* actual recursive code */
3349         if (!node) {
3350                 current = GTK_CTREE_NODE(GTK_CLIST(addrbook.ctree)->row_list);
3351         }
3352         else {
3353                 current = node;
3354         }
3355
3356         while (current) {
3357                 tmp = GTK_CTREE_ROW(current)->sibling;
3358                 ao = (AddressObject *) gtk_ctree_node_get_row_data(GTK_CTREE(addrbook.ctree), current);
3359                 if (ao) {
3360                         GList *next;
3361
3362                         next = (ADDRESS_OBJECT_TYPE(ao) == ADDR_FOLDER) ?
3363                                    g_list_first(((ADDRESS_FOLDER(ao))->items)) :
3364                                    (ADDRESS_OBJECT_TYPE(ao)  == ADDR_GROUP) ?
3365                                    g_list_first(((ADDRESS_GROUP(ao))->items))  : NULL;
3366
3367                         while (ao) {
3368                                 /* NOTE: first iteration of the root calls callback for the tree
3369                                  * node, other iterations call callback for the address book items */
3370                                 if (func(ao, data)) {
3371                                         /* unwind */
3372                                         data->node_found = current;
3373                                         data->addr_found = ao;
3374                                         longjmp(data->jumper, 1);
3375                                 }
3376                                 /* ctree node only stores folders and groups. now descend into
3377                                  * address object data, searching for address items. */
3378                                 for ( ; next && ADDRESS_OBJECT_TYPE((next->data)) != ADDR_ITEM
3379                                           ; next = g_list_next(next))
3380                                         ;
3381                                 ao   = next ? (AddressObject *) next->data : NULL;
3382                                 next = next ? g_list_next(next) : NULL;
3383                         }
3384                 }
3385                 /* check the children (if level permits) */
3386                 if (level == -1 || data->level < level) {
3387                         current = GTK_CTREE_ROW(current)->children;
3388                         if (current) {
3389                                 data->level++;
3390                                 addressbook_traverse(current, func, data, level);
3391                                 data->level--;
3392                         }
3393                 }
3394                 /* check the siblings */
3395                 current = tmp;
3396         }
3397         return NULL;
3398 }
3399
3400 static GtkCTreeNode *addressbook_get_group_node(const gchar *name)
3401 {
3402         FindGroup fg = { { FALSE, NULL, NULL }, NULL };
3403         fg.groupname = name;
3404         addressbook_traverse(NULL, (void *)traverse_find_group_by_name, (FindObject *)&fg, -1);
3405         return fg.ancestor.node_found;
3406 }
3407
3408 static void addressbook_free_item(AddressItem *item)
3409 {
3410         if (item) {
3411                 if (item->name) g_free(item->name);
3412                 if (item->address) g_free(item->address);
3413                 if (item->remarks) g_free(item->remarks);
3414                 g_free(item);
3415         }
3416 }
3417
3418 static AddressItem *addressbook_alloc_item(const gchar *name, const gchar *address, const gchar *remarks)
3419 {
3420         AddressItem *item = g_new0(AddressItem, 1);
3421
3422         if (item) {
3423                 item->obj.type = ADDR_ITEM;
3424                 if (item->name = g_strdup(name))
3425                         if (item->address = g_strdup(address)) {
3426                                 if (remarks) {
3427                                         item->remarks = g_strdup(remarks);
3428                                 }
3429                                 return item;
3430                         }
3431         }
3432         addressbook_free_item(item);
3433         return NULL;
3434 }
3435
3436 /***/
3437
3438 /* public provisional API */
3439
3440 /* addressbook_access() - should be called before using any of the following apis. it
3441  * reloads the address book. */
3442 void addressbook_access(void)
3443 {
3444         log_message("accessing address book\n");
3445         if (!addrbook.window) {
3446                 addressbook_create(FALSE);
3447                 addressbook_read_file();
3448                 addrbook.open_folder = TRUE;
3449                 gtk_ctree_select(GTK_CTREE(addrbook.ctree), GTK_CTREE_NODE(GTK_CLIST(addrbook.ctree)->row_list));
3450         }
3451 }
3452
3453 /* addressbook_unaccess() - should only be called after changing the address book's
3454  * contents */
3455 void addressbook_unaccess(void)
3456 {
3457         log_message("unaccessing address book\n");
3458         addressbook_export_to_file();
3459         invalidate_address_completion();
3460 }
3461
3462 const gchar *addressbook_get_personal_folder_name(void)
3463 {
3464         return _("Personal addresses"); /* human readable */
3465 }
3466
3467 const gchar *addressbook_get_common_folder_name(void)
3468 {
3469         return _("Common addresses"); /* human readable */
3470 }
3471
3472 /* addressbook_find_group_by_name() - finds a group (folder or group) by
3473  * its name */
3474 AddressObject *addressbook_find_group_by_name(const gchar *name)
3475 {
3476         FindGroup          fg = { { FALSE, NULL, NULL } };
3477         AddressObject *ao;
3478
3479         /* initialize obj members */
3480         fg.groupname = name;
3481         ao = addressbook_traverse(NULL,
3482                                                           (ADDRESSBOOK_TRAVERSE_FUNC)traverse_find_group_by_name,
3483                                                           (FindObject *)&fg, -1);
3484         return ao;
3485 }
3486
3487 /* addressbook_find_contact() - finds an address item by either name or address
3488  * or both. the comparison is done on the first few characters of the strings */
3489 AddressObject *addressbook_find_contact(const gchar *name, const gchar *address)
3490 {
3491         FindAddress   fa = { { FALSE, NULL, NULL } };
3492         AddressObject *ao;
3493
3494         fa.name = name;
3495         fa.address = address;
3496         ao = addressbook_traverse(NULL, (ADDRESSBOOK_TRAVERSE_FUNC)traverse_find_name_email,
3497                                                           (FindObject *)&fa, -1);
3498         return ao;
3499 }
3500
3501 /* addressbook_get_group_list() - returns a list of strings with group names (both
3502  * groups and folders). free the list using g_list_free(). note that another
3503  * call may invalidate the returned list */
3504 GList *addressbook_get_group_list(void)
3505 {
3506         FindAllGroups fag = { { FALSE, NULL, NULL }, NULL };
3507         addressbook_traverse(NULL, (ADDRESSBOOK_TRAVERSE_FUNC)traverse_find_all_groups,
3508                                                  (FindObject *)&fag, -1);
3509         return fag.grouplist;
3510 }
3511
3512 /* addressbook_add_contact() - adds a contact to the address book. returns 1
3513  * if succesful else error */
3514 gint addressbook_add_contact(const gchar *group, const gchar *name, const gchar *address,
3515                                                          const gchar *remarks)
3516 {
3517         GtkCTreeNode *node;
3518         AddressItem *item;
3519         FindAddress  fa = { { FALSE, NULL, NULL } };
3520
3521         /* a healthy mix of hiro's and my code */
3522         if (name == NULL || strlen(name) == 0
3523         ||  address == NULL || strlen(address) == 0
3524         ||  group == NULL || strlen(group) == 0) {
3525                 return __LINE__;
3526         }
3527         node = addressbook_get_group_node(group);
3528         if (!node) {
3529                 return __LINE__;
3530         }
3531
3532         /* check if it's already in this group */
3533         fa.name = name;
3534         fa.address = address;
3535
3536         if (addressbook_traverse(node, (gpointer)traverse_find_name_email, (gpointer)&fa, 0)) {
3537                 log_message("address <%s> already in %s\n", address, group);
3538                 return __LINE__;
3539         }
3540
3541         item = addressbook_alloc_item(name, address, remarks);
3542         if (!item) {
3543                 return __LINE__;
3544         }
3545
3546         if (!addressbook_add_object(node, (AddressObject *)item)) {
3547                 addressbook_free_item(item);
3548                 return __LINE__;
3549         }
3550
3551         /* make sure it's updated if selected */
3552         log_message("updating addressbook widgets\n");
3553         addrbook.open_folder = TRUE;
3554         gtk_ctree_select(GTK_CTREE(addrbook.ctree), addrbook.opened);
3555
3556         /* not saved yet. only after unaccessing the address book */
3557         return 0;
3558 }
3559
3560 static void group_object_data_destroy(gchar *group)
3561 {
3562         if (group) {
3563                 g_free(group);
3564         }
3565 }
3566
3567 /***/
3568
3569 typedef struct {
3570         gchar *name;
3571         gchar *address;
3572         gchar *remarks;
3573 } ContactInfo;
3574
3575 static void addressbook_destroy_contact(ContactInfo *ci)
3576 {
3577         g_return_if_fail(ci != NULL);
3578         if (ci->name) g_free(ci->name);
3579         if (ci->address) g_free(ci->address);
3580         if (ci->remarks) g_free(ci->remarks);
3581         g_free(ci);
3582 }
3583
3584 static ContactInfo *addressbook_new_contact(const gchar *name, const gchar *address, const gchar *remarks)
3585 {
3586         ContactInfo *ci = g_new0(ContactInfo, 1);
3587
3588         g_return_val_if_fail(ci != NULL, NULL);
3589         g_return_val_if_fail(address != NULL, NULL); /* address should be valid */
3590         ci->name    = name ? g_strdup(name) : NULL;
3591         ci->address = g_strdup(address);
3592         ci->remarks = remarks ? g_strdup(remarks) : NULL;
3593         if (NULL == ci->address) {
3594                 addressbook_destroy_contact(ci);
3595                 ci = NULL;
3596         }
3597         return ci;
3598 }
3599
3600 static void addressbook_group_menu_selected(GtkMenuItem *menuitem,
3601                                                                                         ContactInfo *data)
3602 {
3603         const gchar *group_name = (const gchar *) gtk_object_get_data(GTK_OBJECT(menuitem),
3604                                                                                                                                   "group_name");
3605
3606         if (!group_name) {
3607                 g_warning("%s(%d) - invalid group name\n", __FILE__, __LINE__);
3608                 return ;
3609         }
3610         g_return_if_fail(group_name != NULL);
3611
3612         g_message("selected group %s from menu\n", group_name);
3613         g_message("selected %s <%s>\n", data->name ? data->name : data->address, data->address);
3614
3615         addressbook_access();
3616         addressbook_add_contact(group_name, data->name ? data->name : data->address,
3617                                                         data->address, data->remarks ? data->remarks : data->address);
3618         addressbook_unaccess();
3619
3620         g_free(data);
3621 }
3622
3623 /* addressbook_add_contact_by_meny() - launches menu with group items. submenu may be
3624  * the menu item in the parent menu, or NULL for a normal right-click context menu */
3625 gboolean addressbook_add_contact_by_menu(GtkWidget   *submenu,
3626                                                                                  const gchar *name,
3627                                                                                  const gchar *address,
3628                                                                                  const gchar *remarks)
3629 {
3630         GtkWidget       *menu, *menuitem;
3631         GList           *groups, *tmp;
3632         ContactInfo *ci;
3633
3634         ci = addressbook_new_contact(name, address, remarks);
3635         g_return_val_if_fail(ci != NULL, FALSE);
3636
3637         addressbook_access();
3638         groups = addressbook_get_group_list();
3639         g_return_val_if_fail(groups != NULL, (addressbook_destroy_contact(ci), FALSE));
3640
3641         menu = gtk_menu_new();
3642         g_return_val_if_fail(menu != NULL, (g_list_free(groups), addressbook_destroy_contact(ci), FALSE));
3643
3644         /* add groups to menu */
3645         for (tmp = g_list_first(groups); tmp != NULL; tmp = g_list_next(tmp)) {
3646                 const gchar *display_name;
3647                 gchar *original_name = (gchar *) tmp->data;
3648                 gboolean addItem = TRUE;
3649
3650                 if (!g_strcasecmp(original_name, ADDRESS_TAG_PERSONAL)) {
3651                         display_name = addressbook_get_personal_folder_name();
3652                 }
3653                 else if (!g_strcasecmp(original_name, ADDRESS_TAG_COMMON)) {
3654                         display_name = addressbook_get_common_folder_name();
3655                 }
3656                 else if( ! g_strcasecmp( original_name, ADDRESS_TAG_VCARD ) ) {
3657                         addItem = FALSE;
3658                 }
3659 #ifdef USE_JPILOT
3660                 else if( ! g_strcasecmp( original_name, ADDRESS_TAG_JPILOT ) ) {
3661                         addItem = FALSE;
3662                 }
3663 #endif
3664 #ifdef USE_LDAP
3665                 else if( ! g_strcasecmp( original_name, ADDRESS_TAG_LDAP ) ) {
3666                         addItem = FALSE;
3667                 }
3668 #endif
3669                 else {
3670                         display_name = original_name;
3671                 }
3672
3673                 if( addItem ) {
3674                         original_name = g_strdup(original_name);
3675                         menuitem = gtk_menu_item_new_with_label(display_name);
3676                         /* register the duplicated string pointer as object data,
3677                          * so we get the opportunity to free it */
3678                         gtk_object_set_data_full(GTK_OBJECT(menuitem), "group_name",
3679                                                                  original_name,
3680                                                                  (GtkDestroyNotify) group_object_data_destroy);
3681                         gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
3682                                                    GTK_SIGNAL_FUNC(addressbook_group_menu_selected),
3683                                                    (gpointer)(ci));
3684                         gtk_menu_append(GTK_MENU(menu), menuitem);
3685                         gtk_widget_show(menuitem);
3686                 }
3687         }
3688
3689         gtk_widget_show(menu);
3690
3691         if (submenu) {
3692                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenu), menu);
3693                 gtk_widget_set_sensitive(GTK_WIDGET(submenu), TRUE);
3694         }
3695         else {
3696                 gtk_widget_grab_focus(GTK_WIDGET(menu));
3697                 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 1, GDK_CURRENT_TIME);
3698         }
3699
3700         if (groups) g_list_free(groups);
3701         return TRUE;
3702 }
3703
3704 /*
3705 * End of Source.
3706 */
3707