2007-12-04 [holger] 3.1.0cvs53
[claws.git] / src / addrduplicates.c
1 /* Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
2  * Copyright (C) 2007 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->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_strdup(email->address);
282                 g_strdown(addr);
283                 old_val = g_hash_table_lookup(addr_hash, addr);
284                 if(old_val)
285                         new_val = deep_copy_hash_val(old_val);
286                 else
287                         new_val = NULL;
288
289                 entry = g_new0(AddrDupListEntry,1);
290                 entry->person = itemperson;
291                 entry->ds     = ds;
292                 entry->book_path = get_bookpath(itemperson, ds);
293
294                 new_val = g_slist_prepend(new_val, entry);
295                 g_hash_table_insert(addr_hash, addr, new_val);
296
297                 nodeM = g_list_next(nodeM);
298         }
299         return 0;
300 }
301
302 static gint books_compare(gconstpointer a, gconstpointer b)
303 {
304         const AddrDupListEntry *entry1;
305         const AddrDupListEntry *entry2;
306         entry1 = a;
307         entry2 = b;
308         return strcmp(entry1->book_path, entry2->book_path);
309 }
310
311 static void present_finder_results(GtkWindow *parent)
312 {
313         GtkWidget *scrolled_win;
314         GtkWidget *vbox;
315         GtkWidget *hbox;
316         GtkWidget *hpaned;
317         GtkWidget *vpaned;
318         GtkWidget *close;
319         gint pos;
320         GtkTreeSelection *email_select;
321         GtkTreeSelection *detail_select;
322         static GdkGeometry geometry;
323
324         if(g_hash_table_size(addr_hash) == 0) {
325                 alertpanel_notice(_("No duplicate email addresses found in the address book"));
326                 return;
327         }
328
329         email_store = gtk_list_store_new(1, G_TYPE_STRING);
330         refresh_stores(NULL,NULL);
331         email_view = create_email_view(email_store);
332         email_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(email_view));
333         gtk_tree_selection_set_mode(email_select,GTK_SELECTION_SINGLE);
334
335         g_signal_connect(email_select, "changed",
336                          (GCallback)email_selection_changed, NULL);
337
338         detail_store = gtk_list_store_new(NUM_COLS, G_TYPE_STRING, G_TYPE_STRING,
339                                           G_TYPE_POINTER, G_TYPE_POINTER);
340         detail_view = create_detail_view(detail_store);
341         detail_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
342         gtk_tree_selection_set_mode(detail_select,GTK_SELECTION_MULTIPLE);
343
344         g_signal_connect(detail_select, "changed",
345                          (GCallback)detail_selection_changed, NULL);
346
347         dialog = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "address_dupes_finder");
348         gtk_window_set_transient_for(GTK_WINDOW(dialog),parent);
349         gtk_window_set_modal(GTK_WINDOW(dialog),TRUE);
350         if(!geometry.min_height) {
351                 geometry.min_width = 600;
352                 geometry.min_height = 400;
353         }
354         gtk_window_set_geometry_hints(GTK_WINDOW(dialog), NULL, &geometry,
355                                       GDK_HINT_MIN_SIZE);
356         gtk_window_set_title(GTK_WINDOW(dialog), _("Duplicate email addresses"));
357
358         vbox = gtk_vbox_new(FALSE, 0);
359         gtk_container_add(GTK_CONTAINER(dialog), vbox);
360
361         hpaned = gtk_hpaned_new();
362         gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
363
364         scrolled_win = gtk_scrolled_window_new(NULL,NULL);
365         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
366                                        GTK_POLICY_AUTOMATIC,
367                                        GTK_POLICY_AUTOMATIC);
368         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_win),
369                                               email_view);
370
371         gtk_paned_add1(GTK_PANED(hpaned), scrolled_win);
372
373         scrolled_win = gtk_scrolled_window_new(NULL,NULL);
374         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
375                                        GTK_POLICY_AUTOMATIC,
376                                        GTK_POLICY_AUTOMATIC);
377         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_win),
378                                               detail_view);
379
380         if (prefs_common.addressbook_use_editaddress_dialog) {
381                 gtk_paned_add2(GTK_PANED(hpaned), scrolled_win);
382                 inline_edit_vbox = NULL;
383         } else {
384                 inline_edit_vbox = gtk_vbox_new(FALSE, 4);
385                 vpaned = gtk_vpaned_new();
386                 gtk_paned_pack1(GTK_PANED(vpaned), scrolled_win, FALSE, FALSE);
387                 gtk_paned_pack2(GTK_PANED(vpaned), inline_edit_vbox, TRUE, FALSE);
388                 gtk_paned_pack2(GTK_PANED(hpaned), vpaned, TRUE, FALSE);
389         }
390
391         g_object_get(G_OBJECT(hpaned),
392                      "position", &pos, NULL);
393         if(pos < 200)
394                 gtk_paned_set_position(GTK_PANED(hpaned), 200);
395
396         hbox = gtk_hbutton_box_new();
397         gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
398         gtk_box_set_spacing(GTK_BOX(hbox), 2);
399         gtk_container_set_border_width(GTK_CONTAINER(hbox), 4);
400         gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
401
402         edit_btn = gtk_button_new_from_stock(GTK_STOCK_EDIT);
403         gtk_box_pack_start(GTK_BOX(hbox), edit_btn, TRUE, TRUE, 0);
404         gtk_widget_set_sensitive(edit_btn, FALSE);
405
406         del_btn = gtk_button_new_from_stock(GTK_STOCK_DELETE);
407         gtk_box_pack_start(GTK_BOX(hbox), del_btn, TRUE, TRUE, 0);
408         gtk_widget_set_sensitive(del_btn, FALSE);
409
410         close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
411         gtk_box_pack_start(GTK_BOX(hbox), close, TRUE, TRUE, 0);
412
413         g_signal_connect(dialog, "destroy",
414                          G_CALLBACK(cb_finder_results_dialog_destroy), NULL);
415         g_signal_connect(G_OBJECT(dialog), "key-press-event",
416                          G_CALLBACK(cb_finder_results_dialog_key_pressed), NULL);
417         g_signal_connect_swapped(close, "clicked",
418                                  G_CALLBACK(gtk_widget_destroy), dialog);
419         g_signal_connect(del_btn, "clicked",
420                          G_CALLBACK(cb_del_btn_clicked), detail_view);
421         g_signal_connect(edit_btn, "clicked",
422                          G_CALLBACK(cb_edit_btn_clicked), detail_view);
423
424         inc_lock();
425         gtk_widget_show_all(dialog);
426 }
427
428 static void cb_finder_results_dialog_destroy(GtkWindow *win, gpointer data)
429 {
430         email_store = NULL;
431         detail_store = NULL;
432         email_view = NULL;
433         inline_edit_vbox = NULL;
434
435         if(addr_hash) {
436                 g_hash_table_destroy(addr_hash);
437                 addr_hash = NULL;
438         }
439         dialog = NULL;
440         addressbook_refresh();
441         inc_unlock();
442 }
443
444 static GtkWidget* create_email_view(GtkListStore *store)
445 {
446         GtkWidget *view;
447         GtkCellRenderer *renderer;
448
449         view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
450         renderer = gtk_cell_renderer_text_new();
451         gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
452                 -1,
453                 _("Address"),
454                 renderer,
455                 "text", 0,
456                 NULL);
457         g_object_unref(store);
458         return view;
459 }
460
461 static GtkWidget* create_detail_view(GtkListStore *store)
462 {
463         GtkWidget *view;
464         GtkCellRenderer *renderer;
465         GList *cols;
466         GList *walk;
467
468         view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
469         renderer = gtk_cell_renderer_text_new();
470
471         /* col 1 */
472         gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
473                 -1,
474                 _("Address book path"),
475                 renderer,
476                 "text", COL_BOOKPATH,
477                 NULL);
478         /* col 2 */
479         gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
480                 -1,
481                 _("Name"),
482                 renderer,
483                 "text", COL_NAME,
484                 NULL);
485
486         cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(view));
487         for(walk = cols; walk; walk = walk->next)
488                 gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(walk->data),
489                                                    TRUE);
490         g_list_free(cols);
491
492         g_signal_connect(view, "row-activated",
493                          G_CALLBACK(detail_row_activated), NULL);
494
495         g_signal_connect(view, "focus-in-event",
496                          G_CALLBACK(detail_focus_in), NULL);
497         g_signal_connect(view, "focus-out-event",
498                          G_CALLBACK(detail_focus_out), NULL);
499
500
501         return view;
502 }
503
504 static void append_to_email_store(gpointer key,gpointer value,gpointer data)
505 {
506         GtkTreeIter iter;
507         GtkListStore *store = (GtkListStore*) data;
508
509         gtk_list_store_append(store, &iter);
510         gtk_list_store_set(store, &iter, 0, (gchar*) key, -1);
511 }
512
513 static gboolean is_editing_entry_only_selection(void)
514 {
515         GtkTreeSelection *sel_detail;
516         GtkTreeIter iter;
517         GList *selected;
518         GtkTreeModel *model;
519         ItemPerson *item;
520
521         sel_detail = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
522
523         if(gtk_tree_selection_count_selected_rows(sel_detail) > 1)
524                 return FALSE;
525
526         selected = gtk_tree_selection_get_selected_rows(sel_detail,&model);
527         if(!selected)
528                 return FALSE;
529
530         gtk_tree_model_get_iter(model, &iter, (GtkTreePath*)selected->data);
531         g_list_foreach(selected, (GFunc)gtk_tree_path_free, NULL);
532         g_list_free(selected);
533
534         gtk_tree_model_get(model, &iter, COL_ITEM, &item,-1);
535         if(ADDRITEM_ID(item) && editing_uid &&
536                 strcmp(ADDRITEM_ID(item),editing_uid) == 0)
537                 return TRUE;
538         else
539                 return FALSE;
540 }
541
542 static void detail_selection_changed(GtkTreeSelection *selection, gpointer data)
543 {
544         gint num_selected;
545         num_selected = gtk_tree_selection_count_selected_rows(selection);
546
547         if(num_selected > 0)
548                 gtk_widget_set_sensitive(del_btn,TRUE);
549         else
550                 gtk_widget_set_sensitive(del_btn,FALSE);
551
552         if(num_selected == 1)
553                 gtk_widget_set_sensitive(edit_btn,TRUE);
554         else
555                 gtk_widget_set_sensitive(edit_btn,FALSE);
556
557         if(!is_editing_entry_only_selection())
558                 addressbook_edit_person_widgetset_hide();
559 }
560
561 static void email_selection_changed(GtkTreeSelection *selection, gpointer data)
562 {
563         GtkTreeIter iter;
564         GtkTreeModel *model;
565         gchar *email;
566
567         if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
568                 GSList *hashval;
569                 GSList *walk;
570
571                 gtk_tree_model_get(model, &iter, 0, &email, -1);
572
573                 hashval = g_hash_table_lookup(addr_hash, email);
574                 gtk_list_store_clear(detail_store);
575                 for(walk = hashval; walk; walk = walk->next) {
576                         AddrDupListEntry *entry = walk->data;
577                         if(!entry)
578                                 continue;
579                         gtk_list_store_append(detail_store, &iter);
580                         gtk_list_store_set(detail_store, &iter,
581                                            COL_BOOKPATH, entry->book_path,
582                                            COL_NAME, addressbook_set_col_name_guard(ADDRITEM_NAME(entry->person)),
583                                            COL_ITEM, entry->person,
584                                            COL_DS, entry->ds,
585                                            -1);
586                 }
587                 g_free(email);
588         }
589 }
590
591 static gchar* get_bookpath(ItemPerson *itemPerson, AddressDataSource *ds)
592 {
593         gchar *path;
594         gchar *tmp;
595         AddrItemObject *item;
596
597         item = (AddrItemObject*)itemPerson;
598         path = g_strdup("");
599         while((item = ADDRITEM_PARENT(item)) != NULL) {
600
601                 if(ADDRITEM_TYPE(item) == ITEMTYPE_FOLDER) {
602                         ItemFolder *folder = (ItemFolder*) item;
603                         tmp = path;
604                         path = g_strdup_printf("%s%s%s",
605                                                folder->isRoot ? addrindex_ds_get_name(ds) :
606                                                ADDRITEM_NAME(folder),
607                                                (*tmp == '\0') ? "" : "/", tmp);
608                         g_free(tmp);
609                 }
610
611         }
612
613         /* prepend bookpath */
614         if(ds && ds->interface && ds->interface->name) {
615                 tmp = path;
616                 path = g_strdup_printf("%s%s%s", ds->interface->name,
617                                        (*tmp == '\0') ? "" : "/", tmp);
618                 g_free(tmp);
619         }
620
621         return path;
622 }
623
624 static void refresh_stores(gchar *email_to_select, GSList *detail_to_select)
625 {
626         refresh_addr_hash();
627         if(email_store)
628                 gtk_list_store_clear(email_store);
629         if(detail_store)
630                 gtk_list_store_clear(detail_store);
631         g_hash_table_foreach(addr_hash,append_to_email_store,email_store);
632
633         /* sort the email store */
634         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(email_store),
635                                              0, GTK_SORT_ASCENDING);
636
637         /* try to select email address */
638         if(email_to_select) {
639                 /* Search email in email store */
640                 GtkTreeIter iter;
641                 GtkTreeSelection *selection;
642
643                 if(!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(email_store), &iter))
644                         return;
645                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(email_view));
646
647                 do {
648                         gint retVal;
649                         gchar *email;
650
651                         gtk_tree_model_get(GTK_TREE_MODEL(email_store), &iter, 0, &email, -1);
652                         retVal = g_ascii_strncasecmp(email,email_to_select,strlen(email));
653                         g_free(email);
654                         if(retVal == 0) {
655                                 gtk_tree_selection_select_iter(selection,&iter);
656                                 break;
657                         }
658                 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(email_store), &iter));
659
660         }
661
662         /* try to select detail rows */
663         if(detail_to_select) {
664                 GtkTreeIter iter;
665                 GtkTreeSelection *sel;
666                 if(!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(detail_store), &iter))
667                         return;
668                 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
669
670                 do {
671                         GSList *walk;
672                         ItemPerson *person;
673                         gtk_tree_model_get(GTK_TREE_MODEL(detail_store), &iter,
674                                            COL_ITEM, &person, -1);
675                         for(walk = detail_to_select; walk; walk = walk->next) {
676                                 gchar *uid = walk->data;
677                                 if(uid && ADDRITEM_ID(person) &&
678                                         (strcmp(uid,ADDRITEM_ID(person)) == 0))
679                                         gtk_tree_selection_select_iter(sel,&iter);
680                         }
681                 } while(gtk_tree_model_iter_next(GTK_TREE_MODEL(detail_store), &iter));
682         }
683 }
684
685 static void detail_row_activated(GtkTreeView       *tree_view,
686                                  GtkTreePath       *path,
687                                  GtkTreeViewColumn *column,
688                                  gpointer           user_data)
689 {
690         GtkTreeIter iter;
691         ItemPerson *person;
692         AddressDataSource *ds;
693         GtkTreeModel *model;
694         AddressBookFile *abf;
695
696         model = gtk_tree_view_get_model(tree_view);
697
698         if(!gtk_tree_model_get_iter(model,&iter,path))
699                 return;
700
701         gtk_tree_model_get(model, &iter, COL_ITEM, &person, COL_DS, &ds, -1);
702
703
704         if(!((ds->type == ADDR_IF_BOOK) || ds->type == ADDR_IF_LDAP)) {
705                 debug_print("Unsupported address datasource type for editing\n");
706                 return;
707         }
708
709         abf = ds->rawDataSource;
710         if(inline_edit_vbox)
711                 gtk_widget_show_all(inline_edit_vbox);
712         if(editing_uid)
713                 g_free(editing_uid);
714         editing_uid = g_strdup(ADDRITEM_ID(person));
715         addressbook_edit_person(abf,NULL,person,FALSE,inline_edit_vbox,
716                                 edit_post_update_cb,FALSE);
717 }
718
719 static void edit_post_update_cb(ItemPerson *item)
720 {
721         GtkTreeSelection *sel;
722         gchar *email;
723         GList *detail_sel;
724         GList *walk;
725         GSList *detail;
726         GtkTreeIter iter;
727         GtkTreeModel *model;
728         ItemPerson *person;
729
730         /* save selection for after the update */
731
732         /* email -> string of email address */
733         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(email_view));
734         if(gtk_tree_selection_get_selected(sel,NULL,&iter))
735                 gtk_tree_model_get(GTK_TREE_MODEL(email_store), &iter, 0, &email, -1);
736         else
737                 email = NULL;
738
739         /* detail -> GSList of ItemPerson UIDs */
740         detail = NULL;
741         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
742         detail_sel = gtk_tree_selection_get_selected_rows(sel, &model);
743         for(walk = detail_sel; walk; walk = walk->next) {
744                 GtkTreePath *path = walk->data;
745                 if(!gtk_tree_model_get_iter(model,&iter,path))
746                         continue;
747                 gtk_tree_model_get(model, &iter, COL_ITEM, &person,-1);
748                 detail = g_slist_prepend(detail, g_strdup(ADDRITEM_ID(person)));
749         }
750         g_list_foreach(detail_sel, (GFunc)gtk_tree_path_free, NULL);
751         g_list_free(detail_sel);
752
753         /* now refresh the stores, trying to keep the selections active */
754         refresh_stores(email,detail);
755
756         /* cleanup */
757         if(email)
758                 g_free(email);
759         g_slist_foreach(detail, (GFunc)g_free, NULL);
760         g_slist_free(detail);
761 }
762
763 static void cb_edit_btn_clicked(GtkButton *button, gpointer data)
764 {
765         GtkTreeSelection *selection;
766         GList *selected;
767         GtkTreeModel *model;
768
769         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
770         selected = gtk_tree_selection_get_selected_rows(selection,&model);
771         g_return_if_fail(selected);
772
773         /* we are guaranteed to have exactly one row selected */
774         gtk_tree_view_row_activated(GTK_TREE_VIEW(detail_view),(GtkTreePath*)selected->data,
775                                     gtk_tree_view_get_column(GTK_TREE_VIEW(detail_view),0));
776
777         g_list_foreach(selected, (GFunc)gtk_tree_path_free, NULL);
778         g_list_free(selected);
779 }
780
781 static void cb_del_btn_clicked(GtkButton *button, gpointer data)
782 {
783         GtkTreeIter iter;
784         GtkTreeModel *model;
785         GtkTreeSelection *selection;
786         ItemPerson *item;
787         AddressDataSource *ds;
788         GList *list;
789         GList *ref_list;
790         GList *walk;
791         GtkTreeRowReference *ref;
792         AlertValue aval;
793         GtkTreeSelection *sel;
794         gchar *email;
795
796         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(detail_view));
797
798         list = gtk_tree_selection_get_selected_rows(selection, &model);
799
800         if(!list)
801                 return;
802
803         aval = alertpanel(_("Delete address(es)"),
804                           _("Really delete the address(es)?"),
805                           GTK_STOCK_CANCEL, "+"GTK_STOCK_DELETE, NULL);
806         if(aval != G_ALERTALTERNATE)
807                 return;
808
809         ref_list = NULL;
810         for(walk = list; walk; walk = walk->next) {
811                 ref = gtk_tree_row_reference_new(model,(GtkTreePath*)(walk->data));
812                 ref_list = g_list_prepend(ref_list, ref);
813         }
814         g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
815         g_list_free(list);
816
817         for(walk = ref_list; walk; walk = walk->next) {
818                 GtkTreePath *path;
819                 ref = walk->data;
820                 if(!gtk_tree_row_reference_valid(ref))
821                         continue;
822                 path = gtk_tree_row_reference_get_path(ref);
823                 if(gtk_tree_model_get_iter(model, &iter, path)) {
824                         gtk_tree_model_get(model, &iter, COL_ITEM, &item, COL_DS, &ds, -1);
825                         addrduplicates_delete_item_person(item,ds);
826                 }
827                 gtk_tree_path_free(path);
828         }
829
830         g_list_foreach(ref_list, (GFunc)gtk_tree_row_reference_free, NULL);
831         g_list_free(ref_list);
832
833         sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(email_view));
834         if(gtk_tree_selection_get_selected(sel,NULL,&iter))
835                 gtk_tree_model_get(GTK_TREE_MODEL(email_store), &iter, 0, &email, -1);
836         else
837                 email = NULL;
838         refresh_stores(email,NULL);
839         if(email)
840                 g_free(email);
841 }
842
843 gboolean addrduplicates_delete_item_person(ItemPerson *item, AddressDataSource *ds)
844 {
845         AddressBookFile *abf;
846         AddressInterface *iface;
847
848         /* Test for read only */
849         iface = ds->interface;
850         if( 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                         g_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 }