src/addrduplicates.c

   1 /* Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   2  * Copyright (C) 2007-2009 Holger Berndt <hb@claws-mail.org>
   3  * and the Claws Mail team
   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 3 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, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #  include "config.h"
  21 #endif
  22
  23 #include <gdk/gdk.h>
  24 #include <gdk/gdkkeysyms.h>
  25 #include <glib/gi18n.h>
  26 #include <string.h>
  27
  28 #include "defs.h"
  29
  30 #ifdef USE_LDAP
  31 #include "ldapserver.h"
  32 #include "ldapupdate.h"
  33 #endif
  34 #include "addrduplicates.h"
  35 #include "addrbook.h"
  36 #include "addressbook.h"
  37 #include "editaddress.h"
  38 #include "alertpanel.h"
  39 #include "gtkutils.h"
  40 #include "inc.h"
  41 #include "utils.h"
  42 #include "prefs_common.h"
  43
  44 typedef struct
  45 {
  46         ItemPerson        *person;
  47         AddressDataSource *ds;
  48         gchar             *book_path;
  49 }
  50 AddrDupListEntry;
  51
  52 enum {
  53     COL_BOOKPATH = 0,
  54     COL_NAME,
  55     COL_ITEM,
  56     COL_DS,
  57     NUM_COLS
  58 };
  59
  60 static gboolean create_dialog();
  61 static void refresh_addr_hash(void);
  62 static void refresh_stores(gchar*,GSList*);
  63 static void present_finder_results(GtkWindow*);
  64 static void cb_finder_results_dialog_destroy(GtkWindow*, gpointer);
  65 static gboolean cb_finder_results_dialog_key_pressed(GtkWidget*, GdkEventKey*,
  66         gpointer);
  67 static void destroy_addr_hash_val(gpointer);
  68 static GSList* deep_copy_hash_val(GSList*);
  69 static void fill_hash_table();
  70 static gint collect_emails(ItemPerson*, AddressDataSource*);
  71 static gboolean is_not_duplicate(gpointer, gpointer, gpointer);
  72 static gint books_compare(gconstpointer, gconstpointer);
  73 static GtkWidget* create_email_view(GtkListStore*);
  74 static GtkWidget* create_detail_view(GtkListStore*);
  75 static void append_to_email_store(gpointer,gpointer,gpointer);
  76 static void email_selection_changed(GtkTreeSelection*,gpointer);
  77 static void detail_selection_changed(GtkTreeSelection*,gpointer);
  78 static void detail_row_activated(GtkTreeView*,GtkTreePath*,
  79                                  GtkTreeViewColumn*,
  80                                  gpointer);
  81 static gboolean detail_focus_in(GtkWidget*,GdkEventFocus*,gpointer);
  82 static gboolean detail_focus_out(GtkWidget*,GdkEventFocus*,gpointer);
  83
  84 static void cb_del_btn_clicked(GtkButton *, gpointer);
  85 static void cb_edit_btn_clicked(GtkButton *, gpointer);
  86 static gchar* get_bookpath(ItemPerson*,AddressDataSource*);
  87 static gboolean is_editing_entry_only_selection(void);
  88 static void edit_post_update_cb(ItemPerson*);
  89
  90 static GHashTable *addr_hash;
  91 static gboolean include_same_book = TRUE;
  92 static gboolean include_other_books = TRUE;
  93
  94 static GtkListStore *email_store;
  95 static GtkListStore *detail_store;
  96 static GtkWidget    *email_view;
  97 static GtkWidget    *detail_view;
  98 static GtkWidget    *inline_edit_vbox;
  99
 100 static GtkWidget *del_btn;
 101 static GtkWidget *edit_btn;
 102
 103 static GtkWidget *dialog;
 104 static gchar *editing_uid;
 105 static gboolean detail_view_has_focus;
 106
 107 void addrduplicates_find(GtkWindow *parent)
 108 {
 109         if(create_dialog()) {
 110                 refresh_addr_hash();
 111                 present_finder_results(parent);
 112         }
 113 }
 114
 115 static gboolean create_dialog()
 116 {
 117         gboolean want_search;
 118         GtkWidget *vbox;
 119         GtkWidget *check_same_book;
 120         GtkWidget *check_other_book;
 121         AlertValue val;
 122
 123         want_search = FALSE;
 124
 125         vbox = gtk_vbox_new(FALSE, 0);
 126         check_same_book = gtk_check_button_new_with_label(_("Show duplicates in "
 127                           "the same book"));
 128         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_same_book),
 129                                      include_same_book);
 130         gtk_box_pack_start(GTK_BOX(vbox), check_same_book, FALSE, FALSE, 0);
 131         gtk_widget_show(check_same_book);
 132         check_other_book = gtk_check_button_new_with_label(_("Show duplicates in "
 133                            "different books"));
 134         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_other_book),
 135                                      include_other_books);
 136         gtk_box_pack_start(GTK_BOX(vbox), check_other_book, FALSE, FALSE, 0);
 137         gtk_widget_show(check_other_book);
 138
 139         /* prevent checkboxes from being destroyed on dialog close */
 140         g_object_ref(check_same_book);
 141         g_object_ref(check_other_book);
 142
 143         val = alertpanel_full(_("Find address book email duplicates"),
 144                               _("Claws Mail will now search for duplicate email "
 145                                 "addresses in the address book."),
 146                               GTK_STOCK_CANCEL,GTK_STOCK_FIND,NULL, FALSE, vbox, ALERT_NOTICE,
 147                               G_ALERTALTERNATE);
 148         if(val == G_ALERTALTERNATE) {
 149                 want_search = TRUE;
 150
 151                 /* save options */
 152                 include_same_book =
 153                     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_same_book));
 154                 include_other_books =
 155                     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check_other_book));
 156
 157         }
 158
 159         g_object_unref(check_same_book);
 160         g_object_unref(check_other_book);
 161         return want_search;
 162 }
 163
 164 static void refresh_addr_hash(void)
 165 {
 166         if(addr_hash)
 167                 g_hash_table_destroy(addr_hash);
 168         addr_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
 169                                           g_free, destroy_addr_hash_val);
 170         fill_hash_table();
 171 }
 172
 173 static void destroy_addr_hash_val(gpointer value)
 174 {
 175         GSList *list = (GSList*) value;
 176         GSList *walk;
 177
 178         for(walk = list; walk; walk = walk->next) {
 179                 AddrDupListEntry *entry = (AddrDupListEntry*) walk->data;
 180                 if(entry && entry->book_path)
 181                         g_free(entry->book_path);
 182                 if(entry)
 183                         g_free(entry);
 184         }
 185         if(list)
 186                 g_slist_free(list);
 187 }
 188
 189 static GSList* deep_copy_hash_val(GSList *in)
 190 {
 191         GSList *walk;
 192         GSList *out = NULL;
 193
 194         out = g_slist_copy(in);
 195         for(walk = out; walk; walk = walk->next) {
 196                 AddrDupListEntry *out_entry;
 197                 AddrDupListEntry *in_entry = walk->data;
 198
 199                 out_entry = g_new0(AddrDupListEntry,1);
 200                 out_entry->person = in_entry->person;
 201                 out_entry->ds     = in_entry->ds;
 202                 out_entry->book_path = g_strdup(in_entry->book_path);
 203                 walk->data = out_entry;
 204         }
 205
 206         return out;
 207 }
 208
 209 static void fill_hash_table()
 210 {
 211         addrindex_load_person_ds(collect_emails);
 212         g_hash_table_foreach_remove(addr_hash,is_not_duplicate, NULL);
 213 }
 214
 215 static gboolean is_not_duplicate(gpointer key, gpointer value,
 216                                  gpointer user_data)
 217 {
 218         gboolean is_in_same_book;
 219         gboolean is_in_other_books;
 220         GSList *books;
 221         GSList *walk;
 222         gboolean retval;
 223         GSList *list = value;
 224
 225         /* remove everything that is just in one book */
 226         if(g_slist_length(list) <= 1)
 227                 return TRUE;
 228
 229         /* work on a shallow copy */
 230         books = g_slist_copy(list);
 231
 232         /* sorting the list makes it easier to check for books */
 233         books = g_slist_sort(books, books_compare);
 234
 235         /* check if a book appears twice */
 236         is_in_same_book = FALSE;
 237         for(walk = books; walk && walk->next; walk = walk->next) {
 238                 if(books_compare(walk->data, walk->next->data) == 0) {
 239                         is_in_same_book = TRUE;
 240                         break;
 241                 }
 242         }
 243
 244         /* check is at least two different books appear in the list */
 245         is_in_other_books = FALSE;
 246         if(books && books->next) {
 247                 for(walk = books->next; walk; walk = walk->next) {
 248                         if(books_compare(walk->data, books->data) != 0) {
 249                                 is_in_other_books = TRUE;
 250                                 break;
 251                         }
 252                 }
 253         }
 254
 255         /* delete the shallow copy */
 256         g_slist_free(books);
 257
 258         retval = FALSE;
 259         if(is_in_same_book && include_same_book)
 260                 retval = TRUE;
 261         if(is_in_other_books && include_other_books)
 262                 retval = TRUE;
 263         retval = !retval;
 264
 265         return retval;
 266 }
 267
 268 static gint collect_emails(ItemPerson *itemperson, AddressDataSource *ds)
 269 {
 270         gchar *addr;
 271         GList *nodeM;
 272         GSList *old_val;
 273         GSList *new_val;
 274         AddrDupListEntry *entry;
 275
 276         /* Process each E-Mail address */
 277         nodeM = itemperson->listEMail;
 278         while(nodeM) {
 279                 ItemEMail *email = nodeM->data;
 280
 281                 addr = g_utf8_strdown(email->address, -1);
 282                 old_val = g_hash_table_lookup(addr_hash, addr);
 283                 if(old_val)
 284                         new_val = deep_copy_hash_val(old_val);
 285                 else
 286                         new_val = NULL;
 287
 288                 entry = g_new0(AddrDupListEntry,1);
 289                 entry->person = itemperson;
 290                 entry->ds     = ds;
 291                 entry->book_path = get_bookpath(itemperson, ds);
 292
 293                 new_val = g_slist_prepend(new_val, entry);
 294                 g_hash_table_insert(addr_hash, addr, new_val);
 295
 296                 nodeM = g_list_next(nodeM);
 297         }
 298         return 0;
 299 }
 300
 301 static gint books_compare(gconstpointer a, gconstpointer b)
 302 {
 303         const AddrDupListEntry *entry1;
 304         const AddrDupListEntry *entry2;
 305         entry1 = a;
 306         entry2 = b;
 307         return strcmp(entry1->book_path, entry2->book_path);
 308 }
 309
 310 static void present_finder_results(GtkWindow *parent)
 311 {
 312         GtkWidget *scrolled_win;
 313         GtkWidget *vbox;
 314         GtkWidget *hbox;
 315         GtkWidget *hpaned;
 316         GtkWidget *vpaned;
 317         GtkWidget *close;
 318         gint pos;
 319         GtkTreeSelection *email_select;
 320         GtkTreeSelection *detail_select;
 321         static GdkGeometry geometry;
 322
 323         if(g_hash_table_size(addr_hash) == 0) {
 324                 alertpanel_notice(_("No duplicate email addresses found in the address book"));
 325                 return;
 326         }
 327
 328         email_store = gtk_list_store_new(1, G_TYPE_STRING);
 329         refresh_stores(NULL,NULL);
 330         email_view = create_email_view(email_store);
 331         email_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(email_view));
 332         gtk_tree_selection_set_mode(email_select,GTK_SELECTION_SINGLE);
 333
 334         g_signal_connect(email_select, "changed",
 335                          (GCallback)email_selection_changed, NULL);
 336
 337         detail_store = gtk_list_store_new(NUM_COLS, G_TYPE_STRING, G_TYPE_STRING,
 338                                           G_TYPE_POINTER, G_TYPE_POINTER);
 339         detail_view = create_detail_view(detail_store);
 340         detail_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
 341         gtk_tree_selection_set_mode(detail_select,GTK_SELECTION_MULTIPLE);
 342
 343         g_signal_connect(detail_select, "changed",
 344                          (GCallback)detail_selection_changed, NULL);
 345
 346         dialog = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "address_dupes_finder");
 347         gtk_window_set_transient_for(GTK_WINDOW(dialog),parent);
 348         gtk_window_set_modal(GTK_WINDOW(dialog),TRUE);
 349         if(!geometry.min_height) {
 350                 geometry.min_width = 600;
 351                 geometry.min_height = 400;
 352         }
 353         gtk_window_set_geometry_hints(GTK_WINDOW(dialog), NULL, &geometry,
 354                                       GDK_HINT_MIN_SIZE);
 355         gtk_window_set_title(GTK_WINDOW(dialog), _("Duplicate email addresses"));
 356
 357         vbox = gtk_vbox_new(FALSE, 0);
 358         gtk_container_add(GTK_CONTAINER(dialog), vbox);
 359
 360         hpaned = gtk_hpaned_new();
 361         gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
 362
 363         scrolled_win = gtk_scrolled_window_new(NULL,NULL);
 364         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
 365                                        GTK_POLICY_AUTOMATIC,
 366                                        GTK_POLICY_AUTOMATIC);
 367         gtk_container_add(GTK_CONTAINER(scrolled_win), email_view);
 368
 369         gtk_paned_add1(GTK_PANED(hpaned), scrolled_win);
 370
 371         scrolled_win = gtk_scrolled_window_new(NULL,NULL);
 372         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
 373                                        GTK_POLICY_AUTOMATIC,
 374                                        GTK_POLICY_AUTOMATIC);
 375         gtk_container_add(GTK_CONTAINER(scrolled_win), detail_view);
 376
 377         if (prefs_common.addressbook_use_editaddress_dialog) {
 378                 gtk_paned_add2(GTK_PANED(hpaned), scrolled_win);
 379                 inline_edit_vbox = NULL;
 380         } else {
 381                 inline_edit_vbox = gtk_vbox_new(FALSE, 4);
 382                 vpaned = gtk_vpaned_new();
 383                 gtk_paned_pack1(GTK_PANED(vpaned), scrolled_win, FALSE, FALSE);
 384                 gtk_paned_pack2(GTK_PANED(vpaned), inline_edit_vbox, TRUE, FALSE);
 385                 gtk_paned_pack2(GTK_PANED(hpaned), vpaned, TRUE, FALSE);
 386         }
 387
 388         g_object_get(G_OBJECT(hpaned),
 389                      "position", &pos, NULL);
 390         if(pos < 200)
 391                 gtk_paned_set_position(GTK_PANED(hpaned), 200);
 392
 393         hbox = gtk_hbutton_box_new();
 394         gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
 395         gtk_box_set_spacing(GTK_BOX(hbox), 2);
 396         gtk_container_set_border_width(GTK_CONTAINER(hbox), 4);
 397         gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
 398
 399         edit_btn = gtk_button_new_from_stock(GTK_STOCK_EDIT);
 400         gtk_box_pack_start(GTK_BOX(hbox), edit_btn, TRUE, TRUE, 0);
 401         gtk_widget_set_sensitive(edit_btn, FALSE);
 402
 403         del_btn = gtk_button_new_from_stock(GTK_STOCK_DELETE);
 404         gtk_box_pack_start(GTK_BOX(hbox), del_btn, TRUE, TRUE, 0);
 405         gtk_widget_set_sensitive(del_btn, FALSE);
 406
 407         close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
 408         gtk_box_pack_start(GTK_BOX(hbox), close, TRUE, TRUE, 0);
 409
 410         g_signal_connect(dialog, "destroy",
 411                          G_CALLBACK(cb_finder_results_dialog_destroy), NULL);
 412         g_signal_connect(G_OBJECT(dialog), "key-press-event",
 413                          G_CALLBACK(cb_finder_results_dialog_key_pressed), NULL);
 414         g_signal_connect_swapped(close, "clicked",
 415                                  G_CALLBACK(gtk_widget_destroy), dialog);
 416         g_signal_connect(del_btn, "clicked",
 417                          G_CALLBACK(cb_del_btn_clicked), detail_view);
 418         g_signal_connect(edit_btn, "clicked",
 419                          G_CALLBACK(cb_edit_btn_clicked), detail_view);
 420
 421         inc_lock();
 422         gtk_widget_show_all(dialog);
 423 }
 424
 425 static void cb_finder_results_dialog_destroy(GtkWindow *win, gpointer data)
 426 {
 427         email_store = NULL;
 428         detail_store = NULL;
 429         email_view = NULL;
 430         inline_edit_vbox = NULL;
 431
 432         if(addr_hash) {
 433                 g_hash_table_destroy(addr_hash);
 434                 addr_hash = NULL;
 435         }
 436         dialog = NULL;
 437         addressbook_refresh();
 438         inc_unlock();
 439 }
 440
 441 static GtkWidget* create_email_view(GtkListStore *store)
 442 {
 443         GtkWidget *view;
 444         GtkCellRenderer *renderer;
 445
 446         view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 447         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), prefs_common.use_stripes_everywhere);
 448         renderer = gtk_cell_renderer_text_new();
 449         gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
 450                 -1,
 451                 _("Address"),
 452                 renderer,
 453                 "text", 0,
 454                 NULL);
 455         g_object_unref(store);
 456         return view;
 457 }
 458
 459 static GtkWidget* create_detail_view(GtkListStore *store)
 460 {
 461         GtkWidget *view;
 462         GtkCellRenderer *renderer;
 463         GList *cols;
 464         GList *walk;
 465
 466         view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 467         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), prefs_common.use_stripes_everywhere);
 468         renderer = gtk_cell_renderer_text_new();
 469
 470         /* col 1 */
 471         gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
 472                 -1,
 473                 _("Address book path"),
 474                 renderer,
 475                 "text", COL_BOOKPATH,
 476                 NULL);
 477         /* col 2 */
 478         gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
 479                 -1,
 480                 _("Name"),
 481                 renderer,
 482                 "text", COL_NAME,
 483                 NULL);
 484
 485         cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(view));
 486         for(walk = cols; walk; walk = walk->next)
 487                 gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(walk->data),
 488                                                    TRUE);
 489         g_list_free(cols);
 490
 491         g_signal_connect(view, "row-activated",
 492                          G_CALLBACK(detail_row_activated), NULL);
 493
 494         g_signal_connect(view, "focus-in-event",
 495                          G_CALLBACK(detail_focus_in), NULL);
 496         g_signal_connect(view, "focus-out-event",
 497                          G_CALLBACK(detail_focus_out), NULL);
 498
 499
 500         return view;
 501 }
 502
 503 static void append_to_email_store(gpointer key,gpointer value,gpointer data)
 504 {
 505         GtkTreeIter iter;
 506         GtkListStore *store = (GtkListStore*) data;
 507
 508         gtk_list_store_append(store, &iter);
 509         gtk_list_store_set(store, &iter, 0, (gchar*) key, -1);
 510 }
 511
 512 static gboolean is_editing_entry_only_selection(void)
 513 {
 514         GtkTreeSelection *sel_detail;
 515         GtkTreeIter iter;
 516         GList *selected;
 517         GtkTreeModel *model;
 518         ItemPerson *item;
 519
 520         sel_detail = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
 521
 522         if(gtk_tree_selection_count_selected_rows(sel_detail) > 1)
 523                 return FALSE;
 524
 525         selected = gtk_tree_selection_get_selected_rows(sel_detail,&model);
 526         if(!selected)
 527                 return FALSE;
 528
 529         gtk_tree_model_get_iter(model, &iter, (GtkTreePath*)selected->data);
 530         g_list_foreach(selected, (GFunc)gtk_tree_path_free, NULL);
 531         g_list_free(selected);
 532
 533         gtk_tree_model_get(model, &iter, COL_ITEM, &item,-1);
 534         if(ADDRITEM_ID(item) && editing_uid &&
 535                 strcmp(ADDRITEM_ID(item),editing_uid) == 0)
 536                 return TRUE;
 537         else
 538                 return FALSE;
 539 }
 540
 541 static void detail_selection_changed(GtkTreeSelection *selection, gpointer data)
 542 {
 543         gint num_selected;
 544         num_selected = gtk_tree_selection_count_selected_rows(selection);
 545
 546         if(num_selected > 0)
 547                 gtk_widget_set_sensitive(del_btn,TRUE);
 548         else
 549                 gtk_widget_set_sensitive(del_btn,FALSE);
 550
 551         if(num_selected == 1)
 552                 gtk_widget_set_sensitive(edit_btn,TRUE);
 553         else
 554                 gtk_widget_set_sensitive(edit_btn,FALSE);
 555
 556         if(!is_editing_entry_only_selection())
 557                 addressbook_edit_person_widgetset_hide();
 558 }
 559
 560 static void email_selection_changed(GtkTreeSelection *selection, gpointer data)
 561 {
 562         GtkTreeIter iter;
 563         GtkTreeModel *model;
 564         gchar *email;
 565
 566         if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
 567                 GSList *hashval;
 568                 GSList *walk;
 569
 570                 gtk_tree_model_get(model, &iter, 0, &email, -1);
 571
 572                 hashval = g_hash_table_lookup(addr_hash, email);
 573                 gtk_list_store_clear(detail_store);
 574                 for(walk = hashval; walk; walk = walk->next) {
 575                         AddrDupListEntry *entry = walk->data;
 576                         if(!entry)
 577                                 continue;
 578                         gtk_list_store_append(detail_store, &iter);
 579                         gtk_list_store_set(detail_store, &iter,
 580                                            COL_BOOKPATH, entry->book_path,
 581                                            COL_NAME, addressbook_set_col_name_guard(ADDRITEM_NAME(entry->person)),
 582                                            COL_ITEM, entry->person,
 583                                            COL_DS, entry->ds,
 584                                            -1);
 585                 }
 586                 g_free(email);
 587         }
 588 }
 589
 590 static gchar* get_bookpath(ItemPerson *itemPerson, AddressDataSource *ds)
 591 {
 592         gchar *path;
 593         gchar *tmp;
 594         AddrItemObject *item;
 595
 596         item = (AddrItemObject*)itemPerson;
 597         path = g_strdup("");
 598         while((item = ADDRITEM_PARENT(item)) != NULL) {
 599
 600                 if(ADDRITEM_TYPE(item) == ITEMTYPE_FOLDER) {
 601                         ItemFolder *folder = (ItemFolder*) item;
 602                         tmp = path;
 603                         path = g_strdup_printf("%s%s%s",
 604                                                folder->isRoot ? addrindex_ds_get_name(ds) :
 605                                                ADDRITEM_NAME(folder),
 606                                                (*tmp == '\0') ? "" : "/", tmp);
 607                         g_free(tmp);
 608                 }
 609
 610         }
 611
 612         /* prepend bookpath */
 613         if(ds && ds->interface && ds->interface->name) {
 614                 tmp = path;
 615                 path = g_strdup_printf("%s%s%s", ds->interface->name,
 616                                        (*tmp == '\0') ? "" : "/", tmp);
 617                 g_free(tmp);
 618         }
 619
 620         return path;
 621 }
 622
 623 static void refresh_stores(gchar *email_to_select, GSList *detail_to_select)
 624 {
 625         refresh_addr_hash();
 626         if(email_store)
 627                 gtk_list_store_clear(email_store);
 628         if(detail_store)
 629                 gtk_list_store_clear(detail_store);
 630         g_hash_table_foreach(addr_hash,append_to_email_store,email_store);
 631
 632         /* sort the email store */
 633         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(email_store),
 634                                              0, GTK_SORT_ASCENDING);
 635
 636         /* try to select email address */
 637         if(email_to_select) {
 638                 /* Search email in email store */
 639                 GtkTreeIter iter;
 640                 GtkTreeSelection *selection;
 641
 642                 if(!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(email_store), &iter))
 643                         return;
 644                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(email_view));
 645
 646                 do {
 647                         gint retVal;
 648                         gchar *email;
 649
 650                         gtk_tree_model_get(GTK_TREE_MODEL(email_store), &iter, 0, &email, -1);
 651                         retVal = g_ascii_strncasecmp(email,email_to_select,strlen(email));
 652                         g_free(email);
 653                         if(retVal == 0) {
 654                                 gtk_tree_selection_select_iter(selection,&iter);
 655                                 break;
 656                         }
 657                 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(email_store), &iter));
 658
 659         }
 660
 661         /* try to select detail rows */
 662         if(detail_to_select) {
 663                 GtkTreeIter iter;
 664                 GtkTreeSelection *sel;
 665                 if(!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(detail_store), &iter))
 666                         return;
 667                 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
 668
 669                 do {
 670                         GSList *walk;
 671                         ItemPerson *person;
 672                         gtk_tree_model_get(GTK_TREE_MODEL(detail_store), &iter,
 673                                            COL_ITEM, &person, -1);
 674                         for(walk = detail_to_select; walk; walk = walk->next) {
 675                                 gchar *uid = walk->data;
 676                                 if(uid && ADDRITEM_ID(person) &&
 677                                         (strcmp(uid,ADDRITEM_ID(person)) == 0))
 678                                         gtk_tree_selection_select_iter(sel,&iter);
 679                         }
 680                 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(detail_store), &iter));
 681         }
 682 }
 683
 684 static void detail_row_activated(GtkTreeView       *tree_view,
 685                                  GtkTreePath       *path,
 686                                  GtkTreeViewColumn *column,
 687                                  gpointer           user_data)
 688 {
 689         GtkTreeIter iter;
 690         ItemPerson *person;
 691         AddressDataSource *ds;
 692         GtkTreeModel *model;
 693         AddressBookFile *abf;
 694
 695         model = gtk_tree_view_get_model(tree_view);
 696
 697         if(!gtk_tree_model_get_iter(model,&iter,path))
 698                 return;
 699
 700         gtk_tree_model_get(model, &iter, COL_ITEM, &person, COL_DS, &ds, -1);
 701
 702
 703         if(!((ds->type == ADDR_IF_BOOK) || ds->type == ADDR_IF_LDAP)) {
 704                 debug_print("Unsupported address datasource type for editing\n");
 705                 return;
 706         }
 707
 708         abf = ds->rawDataSource;
 709         if(inline_edit_vbox)
 710                 gtk_widget_show_all(inline_edit_vbox);
 711         if(editing_uid)
 712                 g_free(editing_uid);
 713         editing_uid = g_strdup(ADDRITEM_ID(person));
 714         addressbook_edit_person(abf,NULL,person,FALSE,inline_edit_vbox,
 715                                 edit_post_update_cb,FALSE);
 716 }
 717
 718 static void edit_post_update_cb(ItemPerson *item)
 719 {
 720         GtkTreeSelection *sel;
 721         gchar *email;
 722         GList *detail_sel;
 723         GList *walk;
 724         GSList *detail;
 725         GtkTreeIter iter;
 726         GtkTreeModel *model;
 727         ItemPerson *person;
 728
 729         /* save selection for after the update */
 730
 731         /* email -> string of email address */
 732         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(email_view));
 733         if(gtk_tree_selection_get_selected(sel,NULL,&iter))
 734                 gtk_tree_model_get(GTK_TREE_MODEL(email_store), &iter, 0, &email, -1);
 735         else
 736                 email = NULL;
 737
 738         /* detail -> GSList of ItemPerson UIDs */
 739         detail = NULL;
 740         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
 741         detail_sel = gtk_tree_selection_get_selected_rows(sel, &model);
 742         for(walk = detail_sel; walk; walk = walk->next) {
 743                 GtkTreePath *path = walk->data;
 744                 if(!gtk_tree_model_get_iter(model,&iter,path))
 745                         continue;
 746                 gtk_tree_model_get(model, &iter, COL_ITEM, &person,-1);
 747                 detail = g_slist_prepend(detail, g_strdup(ADDRITEM_ID(person)));
 748         }
 749         g_list_foreach(detail_sel, (GFunc)gtk_tree_path_free, NULL);
 750         g_list_free(detail_sel);
 751
 752         /* now refresh the stores, trying to keep the selections active */
 753         refresh_stores(email,detail);
 754
 755         /* cleanup */
 756         if(email)
 757                 g_free(email);
 758         g_slist_foreach(detail, (GFunc)g_free, NULL);
 759         g_slist_free(detail);
 760 }
 761
 762 static void cb_edit_btn_clicked(GtkButton *button, gpointer data)
 763 {
 764         GtkTreeSelection *selection;
 765         GList *selected;
 766         GtkTreeModel *model;
 767
 768         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
 769         selected = gtk_tree_selection_get_selected_rows(selection,&model);
 770         cm_return_if_fail(selected);
 771
 772         /* we are guaranteed to have exactly one row selected */
 773         gtk_tree_view_row_activated(GTK_TREE_VIEW(detail_view),(GtkTreePath*)selected->data,
 774                                     gtk_tree_view_get_column(GTK_TREE_VIEW(detail_view),0));
 775
 776         g_list_foreach(selected, (GFunc)gtk_tree_path_free, NULL);
 777         g_list_free(selected);
 778 }
 779
 780 static void cb_del_btn_clicked(GtkButton *button, gpointer data)
 781 {
 782         GtkTreeIter iter;
 783         GtkTreeModel *model;
 784         GtkTreeSelection *selection;
 785         ItemPerson *item;
 786         AddressDataSource *ds;
 787         GList *list;
 788         GList *ref_list;
 789         GList *walk;
 790         GtkTreeRowReference *ref;
 791         AlertValue aval;
 792         GtkTreeSelection *sel;
 793         gchar *email;
 794
 795         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
 796
 797         list = gtk_tree_selection_get_selected_rows(selection, &model);
 798
 799         if(!list)
 800                 return;
 801
 802         aval = alertpanel(_("Delete address(es)"),
 803                           _("Really delete the address(es)?"),
 804                           GTK_STOCK_CANCEL, "+"GTK_STOCK_DELETE, NULL);
 805         if(aval != G_ALERTALTERNATE)
 806                 return;
 807
 808         ref_list = NULL;
 809         for(walk = list; walk; walk = walk->next) {
 810                 ref = gtk_tree_row_reference_new(model,(GtkTreePath*)(walk->data));
 811                 ref_list = g_list_prepend(ref_list, ref);
 812         }
 813         g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
 814         g_list_free(list);
 815
 816         for(walk = ref_list; walk; walk = walk->next) {
 817                 GtkTreePath *path;
 818                 ref = walk->data;
 819                 if(!gtk_tree_row_reference_valid(ref))
 820                         continue;
 821                 path = gtk_tree_row_reference_get_path(ref);
 822                 if(gtk_tree_model_get_iter(model, &iter, path)) {
 823                         gtk_tree_model_get(model, &iter, COL_ITEM, &item, COL_DS, &ds, -1);
 824                         addrduplicates_delete_item_person(item,ds);
 825                 }
 826                 gtk_tree_path_free(path);
 827         }
 828
 829         g_list_foreach(ref_list, (GFunc)gtk_tree_row_reference_free, NULL);
 830         g_list_free(ref_list);
 831
 832         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(email_view));
 833         if(gtk_tree_selection_get_selected(sel,NULL,&iter))
 834                 gtk_tree_model_get(GTK_TREE_MODEL(email_store), &iter, 0, &email, -1);
 835         else
 836                 email = NULL;
 837         refresh_stores(email,NULL);
 838         if(email)
 839                 g_free(email);
 840 }
 841
 842 gboolean addrduplicates_delete_item_person(ItemPerson *item, AddressDataSource *ds)
 843 {
 844         AddressBookFile *abf;
 845         AddressInterface *iface;
 846         if (!ds)
 847                 return FALSE;
 848         /* Test for read only */
 849         iface = ds->interface;
 850         if( iface && iface->readOnly ) {
 851                 alertpanel( _("Delete address"),
 852                             _("This address data is readonly and cannot be deleted."),
 853                             GTK_STOCK_CLOSE, NULL, NULL );
 854                 return FALSE;
 855         }
 856
 857         if(!(abf = ds->rawDataSource))
 858                 return FALSE;
 859
 860         item->status = DELETE_ENTRY;
 861         item = addrbook_remove_person(abf, item);
 862
 863 #ifdef USE_LDAP
 864
 865         if (ds && ds->type == ADDR_IF_LDAP) {
 866                 LdapServer *server = ds->rawDataSource;
 867                 ldapsvr_set_modified(server, TRUE);
 868                 ldapsvr_update_book(server, item);
 869         }
 870
 871 #endif
 872
 873         if(item) {
 874                 gchar *filename = addritem_person_get_picture(item);
 875                 if (filename && is_file_exist(filename))
 876                         claws_unlink(filename);
 877                 g_free(filename);
 878                 addritem_free_item_person(item);
 879         }
 880         return TRUE;
 881 }
 882
 883 static gboolean cb_finder_results_dialog_key_pressed(GtkWidget *widget,
 884         GdkEventKey *event,
 885         gpointer data)
 886 {
 887         if(event) {
 888                 if(event->keyval == GDK_Delete && detail_view_has_focus)
 889                         cb_del_btn_clicked(NULL,NULL);
 890                 else if(event->keyval == GDK_Escape)
 891                         gtk_widget_destroy(dialog);
 892         }
 893
 894         return FALSE;
 895 }
 896
 897 static gboolean detail_focus_in(GtkWidget *widget,
 898                                 GdkEventFocus *event,gpointer data)
 899 {
 900         detail_view_has_focus = TRUE;
 901         return FALSE;
 902 }
 903
 904 static gboolean detail_focus_out(GtkWidget *widget,
 905                                  GdkEventFocus *event,gpointer data)
 906 {
 907         detail_view_has_focus = FALSE;
 908         return FALSE;
 909 }