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