src/addrgather.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2002-2011 Match Grun 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
  20 /*
  21 * Dialog for gathering EMail addresses from mail folder.
  22 */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include "config.h"
  26 #endif
  27
  28 #include "defs.h"
  29
  30 #include <glib.h>
  31 #include <glib/gi18n.h>
  32 #include <gdk/gdkkeysyms.h>
  33 #include <gtk/gtk.h>
  34
  35 #include "main.h"
  36 #include "inc.h"
  37 #include "mbox.h"
  38 #include "filesel.h"
  39 #include "foldersel.h"
  40 #include "gtkutils.h"
  41 #include "alertpanel.h"
  42 #include "manage_window.h"
  43 #include "folder.h"
  44 #include "utils.h"
  45 #include "prefs_common.h"
  46
  47 #include "addrharvest.h"
  48 #ifndef USE_NEW_ADDRBOOK
  49         #include "addrindex.h"
  50         #include "addrbook.h"
  51 #else
  52         #include "addressbook-dbus.h"
  53 #endif
  54 #define PAGE_FIELDS     0
  55 #define PAGE_FINISH     1
  56
  57 #define NUM_FIELDS      6
  58
  59 #define FIELDS_N_COLS              2
  60 #define FIELDS_COL_WIDTH_HEADER    100
  61 #define FIELDS_COL_WIDTH_COUNT     140
  62
  63 #define MIN_FOLDER_SIZE 20
  64 #define DFL_FOLDER_SIZE 50
  65
  66 typedef enum {
  67         FIELD_COL_HEADER = 0,
  68         FIELD_COL_COUNT  = 1
  69 } AddrHarvest;
  70
  71 /*
  72 * The dialog.
  73 */
  74 static struct _AddrHarvest {
  75         GtkWidget *window;
  76         GtkWidget *notebook;
  77         GtkWidget *labelFolder;
  78         GtkWidget *entryBook;
  79         GtkWidget *checkHeader[ NUM_FIELDS ];
  80 #ifndef USE_NEW_ADDRBOOK
  81         GtkWidget *spinbtnFolder;
  82 #endif
  83         GtkWidget *checkRecurse;
  84         GtkWidget *btnOk;
  85         GtkWidget *btnCancel;
  86         GtkWidget *statusbar;
  87         gint      status_cid;
  88         gboolean  cancelled;
  89         gboolean  done;
  90         gchar     *folderPath;
  91         GtkWidget *clistCount;
  92 } addrgather_dlg;
  93
  94 #ifndef USE_NEW_ADDRBOOK
  95 static AddressIndex *_harv_addressIndex_;
  96 static AddressBookFile *_harv_addressBook_;
  97 #endif
  98 static gchar *_harv_headerNames_[] = {
  99         HEADER_FROM,
 100         HEADER_REPLY_TO,
 101         HEADER_SENDER,
 102         HEADER_TO,
 103         HEADER_CC,
 104         HEADER_ERRORS_TO
 105 };
 106 static GList *_harv_messageList_;
 107
 108 static void addrgather_dlg_status_show( gchar *msg ) {
 109         if( addrgather_dlg.statusbar != NULL ) {
 110                 gtk_statusbar_pop( GTK_STATUSBAR(addrgather_dlg.statusbar),
 111                         addrgather_dlg.status_cid );
 112                 if( msg ) {
 113                         gtk_statusbar_push(
 114                                 GTK_STATUSBAR(addrgather_dlg.statusbar),
 115                                 addrgather_dlg.status_cid, msg );
 116                 }
 117         }
 118 }
 119
 120 static gint addrgather_dlg_delete_event(
 121         GtkWidget *widget, GdkEventAny *event, gpointer data )
 122 {
 123         addrgather_dlg.cancelled = TRUE;
 124         gtk_main_quit();
 125         return TRUE;
 126 }
 127
 128 static gboolean addrgather_dlg_key_pressed(
 129         GtkWidget *widget, GdkEventKey *event, gpointer data )
 130 {
 131         if( event && event->keyval == GDK_KEY_Escape ) {
 132                 addrgather_dlg.cancelled = TRUE;
 133                 gtk_main_quit();
 134         }
 135         return FALSE;
 136 }
 137
 138 static void addrgather_size_allocate(
 139         GtkWidget *widget, GtkAllocation *allocation )
 140 {
 141         cm_return_if_fail( allocation != NULL );
 142
 143         prefs_common.addrgather_width   = allocation->width;
 144         prefs_common.addrgather_height  = allocation->height;
 145 }
 146
 147 #define FMT_BUFSIZE 32
 148
 149 static gboolean addrgather_dlg_harvest() {
 150         GtkCMCList *clist;
 151         gchar *text[ FIELDS_N_COLS ];
 152         AddressHarvester *harvester;
 153         gchar *name;
 154 #ifndef USE_NEW_ADDRBOOK
 155         AddressBookFile *abf;
 156         gchar *newFile;
 157 #else
 158     GList* list;
 159     ContactData* contact;
 160     GError* error = NULL;
 161 #endif
 162         gchar str[ FMT_BUFSIZE ];
 163         gint cnt;
 164         gint i;
 165 #ifndef USE_NEW_ADDRBOOK
 166         gint sz;
 167
 168         name = gtk_editable_get_chars( GTK_EDITABLE(addrgather_dlg.entryBook), 0, -1 );
 169         if( name == NULL || strlen( name ) < 1 ) {
 170                 addrgather_dlg_status_show(
 171                         _( "Please specify name for address book." ) );
 172                 g_free( name );
 173                 return FALSE;
 174 #else
 175         name = gtk_combo_box_get_active_text(GTK_COMBO_BOX(addrgather_dlg.entryBook));
 176         if( name == NULL || strlen( name ) < 1 ) {
 177                 addrgather_dlg_status_show(
 178                         _("No available address book."));
 179                 g_free( name );
 180                 return FALSE;
 181 #endif
 182         }
 183
 184         /* Create harvest helper */
 185         harvester = addrharvest_create();
 186         addrharvest_set_path( harvester, addrgather_dlg.folderPath );
 187
 188         for( i = 0; i < NUM_FIELDS; i++ ) {
 189                 addrharvest_set_header( harvester, _harv_headerNames_[i],
 190                 gtk_toggle_button_get_active(
 191                         GTK_TOGGLE_BUTTON(addrgather_dlg.checkHeader[i]) ) );
 192         }
 193         addrharvest_set_recurse( harvester,
 194                 gtk_toggle_button_get_active(
 195                         GTK_TOGGLE_BUTTON( addrgather_dlg.checkRecurse ) ) );
 196
 197         if( addrharvest_check_header( harvester ) == FALSE ) {
 198                 addrgather_dlg_status_show(
 199                         _( "Please select the mail headers to search." ) );
 200                 addrharvest_free( harvester );
 201                 g_free( name );
 202                 return FALSE;
 203         }
 204
 205         /* Go fer it */
 206         addrgather_dlg_status_show( _( "Collecting addresses..." ) );
 207         GTK_EVENTS_FLUSH();
 208 #ifndef USE_NEW_ADDRBOOK
 209         sz = gtk_spin_button_get_value_as_int(
 210                 GTK_SPIN_BUTTON( addrgather_dlg.spinbtnFolder ) );
 211         addrharvest_set_folder_size( harvester, sz );
 212 #endif
 213
 214 #ifndef USE_NEW_ADDRBOOK
 215         /* Create address book */
 216         abf = addrbook_create_book();
 217         addrbook_set_path( abf, _harv_addressIndex_->filePath );
 218         newFile = addrbook_guess_next_file( abf );
 219         addrbook_set_file( abf, newFile );
 220         addrbook_set_name( abf, name );
 221         g_free( newFile );
 222         g_free( name );
 223 #endif
 224
 225         /* Harvest addresses */
 226 #ifndef USE_NEW_ADDRBOOK
 227         addrharvest_harvest(
 228                 harvester, abf->addressCache, _harv_messageList_ );
 229         /* save address book */
 230         addrbook_save_data( abf );
 231         _harv_addressBook_ = abf;
 232 #else
 233         addrharvest_harvest(
 234                 harvester, NULL, _harv_messageList_ );
 235         list = g_hash_table_get_values(harvester->dupTable);
 236         for (; list; list = g_list_next(list)) {
 237                 contact = g_new0(ContactData, 1);
 238                 ContactEntry* person = (ContactEntry *) list->data;
 239                 if (person->first_name)
 240                         contact->name = g_strconcat(
 241                                         person->first_name, " ", person->last_name, NULL);
 242                 else
 243                         contact->name = g_strdup(person->last_name);
 244                 if (! contact->name || strlen(contact->name) < 1)
 245                         contact->name = g_strdup(person->email);
 246                 contact->remarks = g_strdup(N_("address added by claws-mail"));
 247                 contact->email = g_strdup(person->email);
 248                 contact->book = g_strdup(name);
 249                 addressbook_dbus_add_contact(contact, &error);
 250                 contact_data_free(&contact);
 251         }
 252         g_list_free(list);
 253         g_free(name);
 254 #endif
 255
 256         /* Update summary count */
 257         clist = GTK_CMCLIST(addrgather_dlg.clistCount);
 258         gtk_cmclist_clear( clist );
 259         for( i = 0; i < NUM_FIELDS; i++ ) {
 260                 cnt = addrharvest_get_count( harvester, _harv_headerNames_[i] );
 261                 if( cnt < 1 ) {
 262                         strcpy( str, "-" );
 263                 }
 264                 else {
 265                         sprintf( str, "%d", cnt );
 266                 }
 267                 text[ FIELD_COL_HEADER ] = _harv_headerNames_[i];
 268                 text[ FIELD_COL_COUNT  ] = str;
 269                 gtk_cmclist_append( clist, text );
 270         }
 271
 272         addrharvest_free( harvester );
 273
 274         addrgather_dlg_status_show(_("Addresses collected successfully."));
 275
 276         /* Display summary page */
 277         gtk_notebook_set_current_page(
 278                 GTK_NOTEBOOK(addrgather_dlg.notebook), PAGE_FINISH );
 279         addrgather_dlg.done = TRUE;
 280         gtk_widget_set_sensitive( addrgather_dlg.btnCancel, FALSE );
 281         gtk_widget_grab_default( addrgather_dlg.btnOk );
 282
 283         return TRUE;
 284 }
 285
 286 static void addrgather_dlg_ok( GtkWidget *widget, gpointer data ) {
 287         if(addrgather_dlg.done) {
 288                 addrgather_dlg.done = FALSE;
 289                 gtk_main_quit();
 290                 return;
 291         }
 292         if( addrgather_dlg_harvest() ) {
 293                 addrgather_dlg.cancelled = FALSE;
 294         }
 295 }
 296
 297 static void addrgather_dlg_cancel( GtkWidget *widget, gpointer data ) {
 298         gtk_main_quit();
 299 }
 300
 301 #define PACK_CHECK_BUTTON(box, checkbtn, label) \
 302 { \
 303         checkbtn = gtk_check_button_new_with_label(label); \
 304         gtk_widget_show(checkbtn); \
 305         gtk_box_pack_start(GTK_BOX(box), checkbtn, FALSE, TRUE, 0); \
 306 }
 307
 308 /*
 309  * Create notebook page for mail headers.
 310  * Enter: pageNum Page number.
 311  *        pageLbl Page label.
 312  */
 313 static void addrgather_page_fields(gint pageNum, gchar *pageLbl)
 314 {
 315         GtkWidget *vbox;
 316         GtkWidget *vboxf;
 317         GtkWidget *table;
 318         GtkWidget *label;
 319         GtkWidget *labelFolder;
 320         GtkWidget *entryBook;
 321         GtkWidget *frameHeader;
 322         GtkWidget *checkHeader[NUM_FIELDS];
 323 #ifndef USE_NEW_ADDRBOOK
 324         GtkWidget *hboxs;
 325         GtkWidget *spinbtnFolder;
 326         GtkObject *adjFolder;
 327 #endif
 328         GtkWidget *checkRecurse;
 329         gint top;
 330         gint i;
 331 #ifdef USE_NEW_ADDRBOOK
 332         GError* error = NULL;
 333         GSList *books, *cur;
 334 #endif
 335
 336         /* Container */
 337         vbox = gtk_vbox_new(FALSE, 6);
 338         gtk_container_add(GTK_CONTAINER(addrgather_dlg.notebook), vbox);
 339         gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
 340
 341         /* Notebook page */
 342         label = gtk_label_new(pageLbl);
 343         gtk_widget_show(label);
 344         gtk_notebook_set_tab_label(GTK_NOTEBOOK(addrgather_dlg.notebook),
 345                                    gtk_notebook_get_nth_page(GTK_NOTEBOOK(addrgather_dlg.notebook),
 346                                                              pageNum), label);
 347
 348         /* Upper area - Field list */
 349         table = gtk_table_new(4, 2, FALSE);
 350         gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
 351         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
 352         gtk_table_set_col_spacings(GTK_TABLE(table), 4);
 353
 354         /* First row */
 355         top = 0;
 356         label = gtk_label_new(_("Current folder:"));
 357         gtk_table_attach( GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0 );
 358         gtk_misc_set_alignment( GTK_MISC(label), 1.0, 0.5 );
 359
 360         labelFolder = gtk_label_new("");
 361         gtk_table_attach( GTK_TABLE(table), labelFolder, 1, 2, top, (top + 1),
 362                 GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0 );
 363         gtk_misc_set_alignment( GTK_MISC(labelFolder), 0, 0.5 );
 364
 365         /* Second row */
 366         top = 1;
 367         label = gtk_label_new(_("Address book name:"));
 368         gtk_table_attach( GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0 );
 369         gtk_misc_set_alignment( GTK_MISC(label), 1.0, 0.5 );
 370
 371 #ifndef USE_NEW_ADDRBOOK
 372         entryBook = gtk_entry_new();
 373 #else
 374         books = addressbook_dbus_get_books(&error);
 375         entryBook = gtk_combo_box_new_text();
 376         if (books) {
 377             for (cur = books; cur; cur = g_slist_next(cur)) {
 378                 gchar* book = (gchar *) cur->data;
 379                 gtk_combo_box_prepend_text(GTK_COMBO_BOX(entryBook), book);
 380                 g_free(book);
 381             }
 382             g_slist_free(books);
 383         }
 384         else
 385             gtk_combo_box_prepend_text(GTK_COMBO_BOX(entryBook), "");
 386         gtk_combo_box_set_active(GTK_COMBO_BOX(entryBook), 0);
 387 #endif
 388         gtk_table_attach( GTK_TABLE(table), entryBook, 1, 2, top, (top + 1),
 389                 GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0 );
 390
 391 #ifndef USE_NEW_ADDRBOOK
 392         /* Third row */
 393         top = 2;
 394         label = gtk_label_new(_("Address book folder size:"));
 395         gtk_table_attach( GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0 );
 396         gtk_misc_set_alignment( GTK_MISC(label), 1.0, 0.5 );
 397         CLAWS_SET_TIP(label,
 398                         _("Maximum amount of entries per folder within the newly created address book"));
 399
 400         hboxs = gtk_hbox_new(FALSE, 8);
 401         adjFolder = gtk_adjustment_new(DFL_FOLDER_SIZE, MIN_FOLDER_SIZE, G_MAXINT, 1, 10, 0);
 402         spinbtnFolder = gtk_spin_button_new(GTK_ADJUSTMENT(adjFolder), 1, 0);
 403         gtk_box_pack_start(GTK_BOX(hboxs), spinbtnFolder, FALSE, FALSE, 0);
 404         gtk_widget_set_size_request(spinbtnFolder, 100, -1);
 405         gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spinbtnFolder), TRUE);
 406         gtk_table_attach(GTK_TABLE(table), hboxs, 1, 2, top, (top + 1), GTK_FILL, 0, 0, 0);
 407         CLAWS_SET_TIP(spinbtnFolder,
 408                         _("Maximum amount of entries per folder within the newly created address book"));
 409 #endif
 410         /* Fourth row */
 411         top = 3;
 412         frameHeader = gtk_frame_new(_("Process these mail header fields"));
 413         gtk_widget_show(frameHeader);
 414         gtk_table_attach(GTK_TABLE(table), frameHeader, 0, 2, top, (top + 4), GTK_FILL, 0, 0, 0);
 415         gtk_frame_set_label_align(GTK_FRAME(frameHeader), 0.01, 0.5);
 416
 417         /* Check boxes */
 418         vboxf = gtk_vbox_new(FALSE, 0);
 419         gtk_widget_show(vboxf);
 420         gtk_container_add(GTK_CONTAINER(frameHeader), vboxf);
 421         gtk_container_set_border_width(GTK_CONTAINER(vboxf), 8);
 422
 423         for (i = 0; i < NUM_FIELDS; i++) {
 424                 PACK_CHECK_BUTTON(vboxf, checkHeader[i],
 425                         prefs_common_translated_header_name(_harv_headerNames_[i]));
 426                 addrgather_dlg.checkHeader[i] = checkHeader[i];
 427         }
 428
 429         /* Recurse folders */
 430         top += 4;
 431         checkRecurse = gtk_check_button_new_with_label( _("Include subfolders" ) );
 432         gtk_table_attach( GTK_TABLE(table), checkRecurse, 0, 2, top, (top + 1),
 433                         GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0 );
 434
 435         addrgather_dlg.labelFolder   = labelFolder;
 436         addrgather_dlg.entryBook     = entryBook;
 437 #ifndef USE_NEW_ADDRBOOK
 438         addrgather_dlg.spinbtnFolder = spinbtnFolder;
 439 #endif
 440         addrgather_dlg.checkRecurse  = checkRecurse;
 441 }
 442
 443 /*
 444  * Create notebook page for summary counts.
 445  * Enter: pageNum Page number.
 446  *        pageLbl Page label.
 447  */
 448 static void addrgather_page_finish( gint pageNum, gchar *pageLbl ) {
 449         GtkWidget *label;
 450         GtkWidget *vbox;
 451         GtkWidget *clistSWin;
 452         GtkWidget *clistCount;
 453         gchar *titles[ FIELDS_N_COLS ];
 454         gint i;
 455         titles[ FIELD_COL_HEADER ] = _("Header Name");
 456         titles[ FIELD_COL_COUNT  ] = _("Address Count");
 457
 458         vbox = gtk_vbox_new(FALSE, 8);
 459         gtk_container_add( GTK_CONTAINER( addrgather_dlg.notebook ), vbox );
 460         gtk_container_set_border_width( GTK_CONTAINER (vbox), 8 );
 461
 462         label = gtk_label_new( pageLbl );
 463         gtk_widget_show( label );
 464         gtk_notebook_set_tab_label(
 465                 GTK_NOTEBOOK( addrgather_dlg.notebook ),
 466                 gtk_notebook_get_nth_page( GTK_NOTEBOOK( addrgather_dlg.notebook ), pageNum ),
 467                 label );
 468
 469         /* Summary count */
 470         clistSWin = gtk_scrolled_window_new( NULL, NULL );
 471         gtk_container_add( GTK_CONTAINER(vbox), clistSWin );
 472         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clistSWin),
 473                                        GTK_POLICY_AUTOMATIC,
 474                                        GTK_POLICY_AUTOMATIC);
 475
 476         clistCount = gtk_cmclist_new_with_titles( FIELDS_N_COLS, titles );
 477         gtk_container_add( GTK_CONTAINER(clistSWin), clistCount );
 478         gtk_cmclist_set_selection_mode( GTK_CMCLIST(clistCount), GTK_SELECTION_BROWSE );
 479         gtk_cmclist_set_column_width(
 480                         GTK_CMCLIST(clistCount), FIELD_COL_HEADER, FIELDS_COL_WIDTH_HEADER );
 481         gtk_cmclist_set_column_width(
 482                         GTK_CMCLIST(clistCount), FIELD_COL_COUNT, FIELDS_COL_WIDTH_COUNT );
 483
 484         for( i = 0; i < FIELDS_N_COLS; i++ )
 485                 gtkut_widget_set_can_focus(GTK_CMCLIST(clistCount)->column[i].button, FALSE);
 486
 487         addrgather_dlg.clistCount = clistCount;
 488 }
 489
 490 /*
 491  * Create notebook page for warning message.
 492  * Enter: pageNum Page number.
 493  *        pageLbl Page label.
 494  */
 495 static void addrgather_dlg_create(void)
 496 {
 497         GtkWidget *window;
 498         GtkWidget *notebook;
 499         GtkWidget *btnOk;
 500         GtkWidget *btnCancel;
 501         GtkWidget *statusbar;
 502         GtkWidget *vbox;
 503         GtkWidget *hbbox;
 504         GtkWidget *hsbox;
 505         static GdkGeometry geometry;
 506
 507         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "addrgather");
 508         gtk_container_set_border_width(GTK_CONTAINER(window), 4);
 509         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 510         gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
 511
 512         g_signal_connect(G_OBJECT(window), "delete_event",
 513                          G_CALLBACK(addrgather_dlg_delete_event), NULL);
 514         g_signal_connect(G_OBJECT(window), "key_press_event",
 515                          G_CALLBACK(addrgather_dlg_key_pressed), NULL);
 516         g_signal_connect(G_OBJECT(window), "size_allocate",
 517                          G_CALLBACK(addrgather_size_allocate), NULL);
 518
 519         vbox = gtk_vbox_new(FALSE, 6);
 520         gtk_container_add(GTK_CONTAINER(window), vbox);
 521
 522         /* Notebook */
 523         notebook = gtk_notebook_new();
 524         gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
 525         gtk_widget_show(notebook);
 526         gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
 527         gtk_container_set_border_width(GTK_CONTAINER(notebook), 6);
 528
 529         /* Status line */
 530         hsbox = gtk_hbox_new(FALSE, 0);
 531         gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, 0);
 532         statusbar = gtk_statusbar_new();
 533         gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, 0);
 534
 535         /* Button panel */
 536         gtkut_stock_button_set_create(&hbbox, &btnCancel, GTK_STOCK_CANCEL,
 537                                       &btnOk, GTK_STOCK_OK,
 538                                       NULL, NULL);
 539         gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
 540
 541         /* Signal handlers */
 542         g_signal_connect(G_OBJECT(btnOk), "clicked",
 543                          G_CALLBACK(addrgather_dlg_ok), NULL);
 544         g_signal_connect(G_OBJECT(btnCancel), "clicked",
 545                          G_CALLBACK(addrgather_dlg_cancel), NULL);
 546
 547         if (!geometry.min_width) {
 548                 geometry.min_width = 450;
 549                 geometry.min_height = -1;
 550         }
 551
 552         gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
 553                                       GDK_HINT_MIN_SIZE);
 554         gtk_window_set_default_size(GTK_WINDOW(window), prefs_common.addrgather_width,
 555                                     prefs_common.addrgather_height);
 556
 557         addrgather_dlg.window     = window;
 558         addrgather_dlg.notebook   = notebook;
 559         addrgather_dlg.btnOk      = btnOk;
 560         addrgather_dlg.btnCancel  = btnCancel;
 561         addrgather_dlg.statusbar  = statusbar;
 562         addrgather_dlg.status_cid = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar),
 563                                                                  "Collect Email Address Dialog");
 564
 565         /* Create notebook pages */
 566         addrgather_page_fields(PAGE_FIELDS, _("Header Fields"));
 567         addrgather_page_finish(PAGE_FINISH, _("Finish"));
 568         gtk_widget_show_all(addrgather_dlg.window);
 569 }
 570
 571 /*
 572  * Harvest addresses main window.
 573  * Enter: folderItem Source folder.
 574  *        addrIndex  Address index.
 575  *        sourceInd  Source indicator: FALSE - Folder, TRUE - Messages.
 576  *        msgList    List of message numbers, or NULL to process folder.
 577  * Return: Populated address book file, or NULL if none created.
 578  */
 579 #ifndef USE_NEW_ADDRBOOK
 580 AddressBookFile *addrgather_dlg_execute(FolderItem *folderItem, AddressIndex *addrIndex,
 581                                         gboolean sourceInd, GList *msgList)
 582 #else
 583 void addrgather_dlg_execute(FolderItem *folderItem, gboolean sourceInd, GList *msgList)
 584 #endif
 585 {
 586         gint i;
 587
 588 #ifndef USE_NEW_ADDRBOOK
 589         _harv_addressIndex_ = addrIndex;
 590         _harv_addressBook_ = NULL;
 591 #endif
 592         _harv_messageList_ = msgList;
 593
 594         /* Create dialog */
 595         if (!addrgather_dlg.window)
 596                 addrgather_dlg_create();
 597
 598         addrgather_dlg.done = FALSE;
 599
 600         gtk_notebook_set_current_page(GTK_NOTEBOOK(addrgather_dlg.notebook), PAGE_FIELDS);
 601         addrgather_dlg.folderPath = folder_item_get_path(folderItem);
 602
 603         /* Setup some default values */
 604
 605         gtk_label_set_text(GTK_LABEL(addrgather_dlg.labelFolder), folderItem->path);
 606 #ifndef USE_NEW_ADDRBOOK
 607         gtk_entry_set_text(GTK_ENTRY(addrgather_dlg.entryBook), folderItem->path);
 608 #endif
 609
 610         for (i = 0; i < NUM_FIELDS; i++) {
 611                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(addrgather_dlg.checkHeader[i]),
 612                                              FALSE);
 613                 if (g_utf8_collate(_harv_headerNames_[i], HEADER_FROM) == 0)
 614                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(addrgather_dlg.checkHeader[i]),
 615                                                     TRUE);
 616         }
 617
 618         gtk_widget_set_sensitive(addrgather_dlg.btnOk, TRUE);
 619         gtk_widget_set_sensitive(addrgather_dlg.btnCancel, TRUE);
 620         gtk_widget_grab_default(addrgather_dlg.btnOk);
 621
 622         /* Apply window title */
 623         if (sourceInd) {
 624                 gtk_window_set_title(GTK_WINDOW(addrgather_dlg.window),
 625                                      _("Collect email addresses from selected messages"));
 626                 gtk_widget_set_sensitive(addrgather_dlg.checkRecurse, FALSE);
 627         } else {
 628                 gtk_window_set_title(GTK_WINDOW(addrgather_dlg.window),
 629                                      _("Collect email addresses from folder"));
 630                 gtk_widget_set_sensitive(addrgather_dlg.checkRecurse, TRUE);
 631         }
 632         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(addrgather_dlg.checkRecurse), FALSE);
 633
 634         addrgather_dlg_status_show("");
 635         gtk_widget_show(addrgather_dlg.window);
 636         gtk_window_set_modal(GTK_WINDOW(addrgather_dlg.window), TRUE);
 637         gtk_widget_grab_focus(addrgather_dlg.entryBook);
 638         manage_window_set_transient(GTK_WINDOW(addrgather_dlg.window));
 639         gtk_main();
 640
 641         g_free(addrgather_dlg.folderPath);
 642         addrgather_dlg.folderPath = NULL;
 643         gtk_widget_hide(addrgather_dlg.window);
 644         gtk_window_set_modal(GTK_WINDOW(addrgather_dlg.window), FALSE);
 645 #ifndef USE_NEW_ADDRBOOK
 646         _harv_addressIndex_ = NULL;
 647
 648         if (addrgather_dlg.cancelled == TRUE)
 649                 return NULL;
 650
 651         return _harv_addressBook_;
 652 #endif
 653 }
 654 /*
 655 * End of Source.
 656 */
 657
 658