src/selective_download.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2002 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <gtk/gtk.h>
  28 #include <gtk/gtkoptionmenu.h>
  29 #include <gdk/gdkkeysyms.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32
  33 #include "intl.h"
  34 #include "main.h"
  35 #include "prefs.h"
  36 #include "prefs_matcher.h"
  37 #include "prefs_filtering.h"
  38 #include "prefs_account.h"
  39 #include "account.h"
  40 #include "mainwindow.h"
  41 #include "manage_window.h"
  42 #include "menu.h"
  43 #include "stock_pixmap.h"
  44 #include "inc.h"
  45 #include "utils.h"
  46 #include "gtkutils.h"
  47 #include "alertpanel.h"
  48 #include "folder.h"
  49 #include "inc.h"
  50 #include "filtering.h"
  51 #include "matcher_parser.h"
  52 #include "selective_download.h"
  53 #include "procheader.h"
  54
  55 static struct _SDView {
  56         MainWindow *mainwin;
  57
  58         GtkWidget *window;
  59         GtkWidget *clist;
  60         GtkWidget *preview_btn;
  61         GtkWidget *remove_btn;
  62         GtkWidget *download_btn;
  63         GtkWidget *ac_button;
  64         GtkWidget *ac_label;
  65         GtkWidget *ac_menu;
  66         GtkWidget *preview_popup;
  67         GtkWidget *msgs_label;
  68         GtkWidget *show_old_chkbtn;
  69
  70 }selective;
  71
  72 static GdkPixmap *checkboxonxpm;
  73 static GdkBitmap *checkboxonxpmmask;
  74 static GdkPixmap *checkboxoffxpm;
  75 static GdkBitmap *checkboxoffxpmmask;
  76 static GdkPixmap *markxpm;
  77 static GdkBitmap *markxpmmask;
  78 static GdkPixmap *deletedxpm;
  79 static GdkBitmap *deletedxpmmask;
  80 static GdkPixmap *continuexpm;
  81 static GdkBitmap *continuexpmmask;
  82
  83
  84 /* local functions */
  85 static void sd_clear_msglist();
  86 static void sd_remove_header_files();
  87 static void sd_toggle_btn();
  88 static SD_State sd_header_filter (MsgInfo *msginfo);
  89 static MsgInfo *sd_get_msginfo_from_file (const gchar *filename);
  90
  91 static void sd_clist_set_pixmap(HeaderItems *items, gint row);
  92 static void sd_clist_get_items();
  93 static void sd_clist_set_items();
  94 static void sd_update_msg_num(PrefsAccount *acc);
  95
  96 enum {
  97         PREVIEW_NEW,
  98         PREVIEW_ALL,
  99         REMOVE,
 100         DOWNLOAD,
 101         DONE,
 102         CHECKBTN,
 103 };
 104
 105 /* callbacks */
 106 static void sd_action_cb(GtkWidget *widget, guint action);
 107
 108 static void sd_select_row_cb (GtkCList *clist, gint row, gint column,
 109                               GdkEvent *event, gpointer user_data);
 110 static void sd_key_pressed (GtkWidget *widget,
 111                             GdkEventKey *event,
 112                             gpointer data);
 113 /* account menu */
 114 static void sd_ac_label_pressed(GtkWidget *widget,
 115                                 GdkEventButton *event,
 116                                 gpointer data);
 117
 118 static void sd_ac_menu_popup_closed(GtkMenuShell *menu_shell);
 119 static void sd_ac_menu_cb(GtkMenuItem *menuitem, gpointer data);
 120 static void sd_ac_menu_set();
 121
 122 /* preview popup */
 123 static void sd_preview_popup_closed(GtkMenuShell *menu_shell);
 124 static void sd_preview_popup_cb(GtkWidget *widget, GdkEventButton *event);
 125 static GtkItemFactoryEntry preview_popup_entries[] =
 126 {
 127         {N_("/Preview _new Messages"), NULL, sd_action_cb, PREVIEW_NEW, NULL},
 128         {N_("/Preview _all Messages"), NULL, sd_action_cb, PREVIEW_ALL, NULL}
 129 };
 130
 131 /* create dialog */
 132 static void sd_window_create (MainWindow *mainwin);
 133
 134 void selective_download(MainWindow *mainwin)
 135 {
 136         summary_write_cache(mainwin->summaryview);
 137
 138         sd_remove_header_files();
 139
 140         stock_pixmap_gdk(mainwin->window, STOCK_PIXMAP_CHECKBOX_OFF,
 141                          &checkboxoffxpm, &checkboxoffxpmmask);
 142         stock_pixmap_gdk(mainwin->window, STOCK_PIXMAP_CHECKBOX_ON,
 143                          &checkboxonxpm, &checkboxonxpmmask);
 144         stock_pixmap_gdk(mainwin->window, STOCK_PIXMAP_DELETED,
 145                          &deletedxpm, &deletedxpmmask);
 146         stock_pixmap_gdk(mainwin->window, STOCK_PIXMAP_CONTINUE,
 147                          &continuexpm, &continuexpmmask);
 148         stock_pixmap_gdk(mainwin->window, STOCK_PIXMAP_MARK,
 149                          &markxpm, &markxpmmask);
 150         inc_lock();
 151
 152         if (!selective.window)
 153             sd_window_create(mainwin);
 154
 155         manage_window_set_transient(GTK_WINDOW(selective.window));
 156         gtk_widget_show(selective.window);
 157         sd_clear_msglist();
 158         sd_ac_menu_set();
 159         gtk_clist_clear(GTK_CLIST(selective.clist));
 160
 161
 162 }
 163
 164 static void sd_clear_msglist()
 165 {
 166         PrefsAccount *acc = cur_account;
 167         while (acc->msg_list != NULL) {
 168                 HeaderItems *item = (HeaderItems*)acc->msg_list->data;
 169
 170                 acc->msg_list = g_slist_remove(acc->msg_list, item);
 171                 g_free(item->from);
 172                 g_free(item->subject);
 173                 g_free(item);
 174         }
 175         g_slist_free(acc->msg_list);
 176         sd_update_msg_num(acc);
 177 }
 178
 179 /* sd_remove_header_files()
 180  *
 181  * - removes any stale header files in HEADER_CACHE_DIR
 182  *
 183  */
 184 static void sd_remove_header_files()
 185 {
 186         gchar *path = g_strconcat(get_header_cache_dir(), G_DIR_SEPARATOR_S, NULL);
 187
 188         remove_all_files(path);
 189         g_free(path);
 190 }
 191
 192 /* sd_toggle_btn()
 193  *
 194  * - checks whether at least on email is selected
 195  *   if so, untoggle remove / download button
 196  */
 197 static void sd_toggle_btn()
 198 {
 199         PrefsAccount *acc = cur_account;
 200         GSList *cur;
 201
 202         for (cur = acc->msg_list; cur != NULL; cur = cur->next) {
 203                 HeaderItems *items = (HeaderItems*)cur->data;
 204
 205                 if (items->state == SD_CHECKED) {
 206                         gtk_widget_set_sensitive (selective.remove_btn, TRUE);
 207                         gtk_widget_set_sensitive (selective.download_btn, TRUE);
 208                         return;
 209                 }
 210         }
 211
 212         gtk_widget_set_sensitive (selective.remove_btn, FALSE);
 213 }
 214
 215 /* sd_header_filter(MsgInfo *msginfo)
 216  *
 217  * - parse header line and look for any applying filtering rules
 218  * - if message matches other MATCHACTION --> return
 219  *
 220  */
 221 SD_State sd_header_filter(MsgInfo *msginfo)
 222 {
 223         GSList *rules;
 224
 225         /* parse header line for line */
 226         for (rules = global_processing; rules != NULL; rules = rules->next) {
 227
 228                 FilteringProp *prop = (FilteringProp*) rules->data;
 229
 230                 if ( matcherlist_match(prop->matchers, msginfo) ) {
 231                         if (prop->action->type == MATCHACTION_DELETE_ON_SERVER) {
 232                                 debug_print(_("action matched\n"));
 233                                 return SD_CHECKED;
 234                         }
 235                         else {
 236                                 debug_print(_("action not matched\n"));
 237                                 return SD_UNCHECKED;
 238                         }
 239                 }
 240         }
 241         return SD_UNCHECKED;
 242 }
 243
 244 /* sd_get_msginfo_from_file(const gchar *filename)
 245  *
 246  * - retrieve msginfo from saved header files
 247  */
 248 static MsgInfo *sd_get_msginfo_from_file(const gchar *filename)
 249 {
 250         MsgInfo  *msginfo;
 251         MsgFlags  msgflags = { 0, 0 };
 252         gchar     date[HEADER_ITEM_MAX_DATE_SIZE];
 253
 254         msginfo = procheader_parse_file(filename, msgflags, TRUE, FALSE);
 255
 256         /*
 257          * ALF - we need to make sure we dynamically allocate interesting
 258          * members, otherwise we can't free the msginfo using
 259          * procmsg_msginfo_free() later on.
 260          */
 261
 262         if (msginfo) {
 263                 if (msginfo->date_t) {
 264                         procheader_date_get_localtime(date, sizeof date, msginfo->date_t);
 265                         msginfo->date = g_strdup(date);
 266                 }
 267         } else
 268                 msginfo = g_new0(MsgInfo, 1);
 269
 270         if (!msginfo->date)
 271                 msginfo->date = g_strdup(_("(No Date)"));
 272         if (!msginfo->from)
 273                 msginfo->from = g_strdup(_("(No Sender)"));
 274         if (!msginfo->subject)
 275                 msginfo->subject = g_strdup(_("(No Subject)"));
 276
 277         return msginfo;
 278 }
 279
 280 static void sd_clist_set_pixmap(HeaderItems *items, gint row)
 281 {
 282
 283         switch (items->state) {
 284         case SD_REMOVED:
 285                 gtk_clist_set_pixmap (GTK_CLIST (selective.clist),
 286                                       row, 0,
 287                                      deletedxpm, deletedxpmmask);
 288                 break;
 289         case SD_CHECKED:
 290                 gtk_clist_set_pixmap (GTK_CLIST (selective.clist),
 291                                       row, 0,
 292                                       checkboxonxpm, checkboxonxpmmask);
 293                 break;
 294         case SD_DOWNLOADED:
 295                 gtk_clist_set_pixmap (GTK_CLIST (selective.clist),
 296                                       row, 0,
 297                                       markxpm, markxpmmask);
 298                 break;
 299         default:
 300                 gtk_clist_set_pixmap (GTK_CLIST (selective.clist),
 301                                       row, 0,
 302                                       checkboxoffxpm, checkboxoffxpmmask);
 303                 break;
 304         }
 305 }
 306
 307 static void sd_clist_set_items()
 308 {
 309         PrefsAccount *acc = cur_account;
 310         GSList *cur;
 311         gboolean show_old =
 312                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(selective.show_old_chkbtn));
 313
 314         gtk_clist_clear(GTK_CLIST(selective.clist));
 315         gtk_clist_freeze(GTK_CLIST(selective.clist));
 316
 317         for (cur = acc->msg_list; cur != NULL; cur = cur->next) {
 318                 HeaderItems *items = (HeaderItems*)cur->data;
 319                 gchar *row[5];
 320                 gint row_num;
 321
 322                 row[0] = _("");
 323                 row[1] = items->from;
 324                 row[2] = items->subject;
 325                 row[3] = items->date;
 326                 row[4] = g_strdup_printf("%i KB", items->size/1024);
 327
 328                 switch (items->state) {
 329                 case SD_REMOVED:
 330                 case SD_DOWNLOADED:
 331                         items->del_by_old_session = TRUE;
 332                 default:
 333                         break;
 334                 }
 335                 if (show_old) {
 336                         if (items->received) {
 337                                 row_num = gtk_clist_append(GTK_CLIST(selective.clist), row);
 338                                 sd_clist_set_pixmap(items, row_num);
 339                         }
 340                 }
 341                 else {
 342                         row_num = gtk_clist_append(GTK_CLIST(selective.clist), row);
 343                         sd_clist_set_pixmap(items, row_num);
 344                 }
 345                 g_free(row[4]);
 346         }
 347
 348         gtk_clist_thaw(GTK_CLIST(selective.clist));
 349         sd_toggle_btn();
 350 }
 351
 352 /* sd_update_msg_num(PrefsAccount *acc)
 353  * - keep track of msgs still on server
 354  * - count UNCHECKED items as well as downloaded but not removed
 355  */
 356 static void sd_update_msg_num(PrefsAccount *acc)
 357 {
 358         GSList *cur;
 359         gint msg_num = g_slist_length(acc->msg_list);
 360         gchar *text;
 361
 362         for (cur = acc->msg_list; cur != NULL; cur = cur->next) {
 363                 HeaderItems *items = (HeaderItems*) cur->data;
 364
 365                 if (items->state != SD_UNCHECKED)
 366                         msg_num--;
 367                 if (items->state == SD_DOWNLOADED)
 368                         if (!acc->sd_rmmail_on_download)
 369                                 msg_num++;
 370         }
 371
 372         text = g_strdup_printf("%i Messages", msg_num);
 373         gtk_label_set_text(GTK_LABEL(selective.msgs_label), text);
 374
 375         g_free(text);
 376 }
 377
 378 /* sd_clist_get_items()
 379  *
 380  * - get items for clist from Files
 381  */
 382 static void sd_clist_get_items(void)
 383 {
 384         GSList *cur;
 385         PrefsAccount *acc = cur_account;
 386         gchar *path = g_strconcat(get_header_cache_dir(), G_DIR_SEPARATOR_S, NULL);
 387
 388         for (cur = acc->msg_list; cur != NULL; cur = cur->next) {
 389
 390                 HeaderItems *items = (HeaderItems*) cur->data;
 391                 gchar *filename    = g_strdup_printf("%s%i", path, items->index);
 392                 MsgInfo *msginfo   = sd_get_msginfo_from_file(filename);
 393
 394                 items->from        = g_strdup(msginfo->from);
 395                 items->subject     = g_strdup(msginfo->subject);
 396
 397                 strncpy2(items->date, msginfo->date, sizeof items->date);
 398
 399                 msginfo->folder = folder_get_default_processing();
 400
 401                 /* move msg file to drop folder */
 402                 if ((msginfo->msgnum = folder_item_add_msg(msginfo->folder,
 403                                                            filename, TRUE)) < 0) {
 404                         unlink(filename);
 405                         return;
 406                 }
 407
 408                 if (acc->sd_filter_on_recv)
 409                         items->state = sd_header_filter(msginfo);
 410
 411                 folder_item_remove_msg(msginfo->folder, msginfo->msgnum);
 412                 g_free(filename);
 413                 procmsg_msginfo_free(msginfo);
 414         }
 415
 416         g_free(path);
 417 }
 418
 419 static gint sd_deleted_cb(GtkWidget *widget, GdkEventAny *event, gpointer data)
 420 {
 421         sd_remove_header_files();
 422         sd_clear_msglist();
 423         gtk_widget_destroy(selective.window);
 424         selective.window = NULL;
 425         inc_unlock();
 426         return TRUE;
 427 }
 428
 429 /* --- Callbacks -- */
 430 static void sd_action_cb(GtkWidget *widget, guint action)
 431 {
 432         PrefsAccount *acc = cur_account;
 433
 434         switch(action) {
 435         case PREVIEW_NEW:
 436         case PREVIEW_ALL:
 437                 if ( (acc->protocol != A_APOP) &&
 438                      (acc->protocol != A_POP3) ) {
 439                         alertpanel_error(
 440                                 _("Selected Account \"%s\" is not a POP Mail Server.\nPlease select a different Account"), acc->account_name);
 441                         return;
 442                 }
 443                 sd_clear_msglist();
 444                 if (action == PREVIEW_NEW) {
 445                         gtk_widget_set_sensitive(selective.show_old_chkbtn, FALSE);
 446                         inc_selective_download(selective.mainwin, acc, STYPE_PREVIEW_NEW);
 447                 }
 448                 else {
 449                         gtk_widget_set_sensitive(selective.show_old_chkbtn, TRUE);
 450                         inc_selective_download(selective.mainwin, acc, STYPE_PREVIEW_ALL);
 451                 }
 452
 453                 gtk_clist_clear(GTK_CLIST(selective.clist));
 454                 sd_clist_get_items();
 455                 sd_clist_set_items();
 456                 break;
 457         case REMOVE:
 458                 inc_selective_download(selective.mainwin, acc, STYPE_DELETE);
 459                 sd_clist_set_items();
 460                 break;
 461         case DOWNLOAD:
 462                 inc_selective_download(selective.mainwin, acc, STYPE_DOWNLOAD);
 463                 sd_clist_set_items();
 464                 break;
 465         case DONE:
 466                 sd_remove_header_files();
 467                 sd_clear_msglist();
 468                 gtk_widget_hide(selective.window);
 469                 inc_unlock();
 470                 break;
 471         case CHECKBTN:
 472                 sd_clist_set_items();
 473                 break;
 474         default:
 475                 break;
 476         }
 477
 478         sd_update_msg_num(acc);
 479 }
 480
 481 /* Events */
 482 static void sd_select_row_cb(GtkCList *clist, gint row, gint column,
 483                              GdkEvent *event, gpointer user_data)
 484 {
 485         if ((row >= 0) && (column >= 0)) {
 486                 PrefsAccount *acc  = cur_account;
 487                 HeaderItems *items = (HeaderItems*) g_slist_nth_data (acc->msg_list, row);
 488
 489                 if (!items) return;
 490                 if (!gtk_clist_get_selectable(GTK_CLIST(selective.clist), row)) return;
 491
 492                 if (items->state == SD_UNCHECKED) {
 493                         items->state = SD_CHECKED;
 494                         gtk_clist_set_pixmap (GTK_CLIST (selective.clist), row, 0,
 495                                               checkboxonxpm, checkboxonxpmmask);
 496                 } else if (items->state == SD_CHECKED) {
 497                         items->state = SD_UNCHECKED;
 498                         gtk_clist_set_pixmap (GTK_CLIST (selective.clist), row, 0,
 499                                               checkboxoffxpm, checkboxoffxpmmask);
 500                 }
 501                 sd_toggle_btn();
 502         }
 503 }
 504
 505 static void sd_key_pressed(GtkWidget *widget,
 506                            GdkEventKey *event,
 507                            gpointer data)
 508 {
 509         if (event && event->keyval == GDK_Escape)
 510                 sd_action_cb(widget, DONE);
 511 }
 512
 513 /* account menu */
 514 static void sd_ac_label_pressed(GtkWidget *widget, GdkEventButton *event,
 515                                     gpointer data)
 516 {
 517         if (!event) return;
 518
 519         gtk_button_set_relief(GTK_BUTTON(widget), GTK_RELIEF_NORMAL);
 520         gtk_object_set_data(GTK_OBJECT(selective.ac_menu), "menu_button",
 521                             widget);
 522
 523         gtk_menu_popup(GTK_MENU(selective.ac_menu), NULL, NULL,
 524                        menu_button_position, widget,
 525                        event->button, event->time);
 526 }
 527
 528 static void sd_ac_menu_popup_closed(GtkMenuShell *menu_shell)
 529 {
 530         GtkWidget *button;
 531
 532         button = gtk_object_get_data(GTK_OBJECT(menu_shell), "menu_button");
 533         if (!button) return;
 534         gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
 535         gtk_clist_clear(GTK_CLIST(selective.clist));
 536         sd_clear_msglist();
 537         sd_toggle_btn();
 538         gtk_object_remove_data(GTK_OBJECT(selective.ac_menu), "menu_button");
 539 }
 540
 541 static void sd_ac_menu_cb(GtkMenuItem *menuitem, gpointer data)
 542 {
 543         cur_account = (PrefsAccount *)data;
 544         gtk_label_set_text(GTK_LABEL(selective.ac_label), cur_account->account_name);
 545         gtk_widget_queue_resize(selective.ac_button);
 546         main_window_reflect_prefs_all();
 547 }
 548
 549 static void sd_ac_menu_set()
 550 {
 551         GList *cur_ac, *cur_item;
 552         GtkWidget *menuitem;
 553         PrefsAccount *ac_prefs;
 554         GList *account_list = account_get_list();
 555
 556         /* destroy all previous menu item */
 557         cur_item = GTK_MENU_SHELL(selective.ac_menu)->children;
 558         while (cur_item != NULL) {
 559                 GList *next = cur_item->next;
 560                 gtk_widget_destroy(GTK_WIDGET(cur_item->data));
 561                 cur_item = next;
 562         }
 563
 564         gtk_label_set_text(GTK_LABEL(selective.ac_label), cur_account->account_name);
 565
 566         for (cur_ac = account_list; cur_ac != NULL; cur_ac = cur_ac->next) {
 567                 ac_prefs = (PrefsAccount *)cur_ac->data;
 568
 569                 menuitem = gtk_menu_item_new_with_label
 570                         (ac_prefs->account_name
 571                          ? ac_prefs->account_name : _("Untitled"));
 572                 gtk_widget_show(menuitem);
 573                 gtk_menu_append(GTK_MENU(selective.ac_menu), menuitem);
 574                 gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
 575                                            GTK_SIGNAL_FUNC(sd_ac_menu_cb),
 576                                            ac_prefs);
 577         }
 578 }
 579
 580 /* receive button popup */
 581 static void sd_preview_popup_closed(GtkMenuShell *menu_shell)
 582 {
 583         gtk_button_set_relief(GTK_BUTTON(selective.preview_btn), GTK_RELIEF_NORMAL);
 584         manage_window_focus_in(selective.window, NULL, NULL);
 585 }
 586
 587 static void sd_preview_popup_cb(GtkWidget *widget, GdkEventButton *event)
 588 {
 589         if (!event) return;
 590
 591         if (event->button == 1) {
 592                 gtk_button_set_relief(GTK_BUTTON(widget), GTK_RELIEF_NORMAL);
 593                 gtk_menu_popup(GTK_MENU(selective.preview_popup), NULL, NULL,
 594                        menu_button_position, widget,
 595                        event->button, event->time);
 596         }
 597 }
 598
 599 static void sd_window_create(MainWindow *mainwin)
 600 {
 601         GtkWidget *window;
 602         GtkWidget *table;
 603         GtkWidget *msgs_label;
 604         GtkWidget *bottom_hbox;
 605         GtkWidget *fixed_label;
 606         GtkWidget *expand_label;
 607         GtkWidget *ac_button;
 608         GtkWidget *ac_label;
 609         GtkWidget *ac_menu;
 610         GtkWidget *show_old_chkbtn;
 611         GtkWidget *scrolledwindow;
 612         GtkWidget *clist;
 613         GtkWidget *state_label;
 614         GtkWidget *from_label;
 615         GtkWidget *subject_label;
 616         GtkWidget *size_label;
 617         GtkWidget *date_label;
 618         GtkWidget *toolbar_hbox;
 619         GtkWidget *toolbar;
 620         GtkWidget *tmp_toolbar_icon;
 621         GtkWidget *preview_btn;
 622         GtkWidget *preview_popup;
 623         GtkWidget *remove_btn;
 624         GtkWidget *download_btn;
 625         GtkWidget *done_btn;
 626         gint n_menu_entries;
 627
 628         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 629         gtk_object_set_data (GTK_OBJECT (window), "window", window);
 630         gtk_window_set_title (GTK_WINDOW (window), _("Selective download"));
 631         gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
 632         gtk_window_set_modal (GTK_WINDOW (window), TRUE);
 633         gtk_window_set_policy (GTK_WINDOW (window), TRUE, TRUE, TRUE);
 634
 635         table = gtk_table_new (2, 2, FALSE);
 636         gtk_container_add (GTK_CONTAINER (window), table);
 637
 638         msgs_label = gtk_label_new (_("0 Messages"));
 639         gtk_table_attach (GTK_TABLE (table), msgs_label, 1, 2, 1, 2,
 640                           (GtkAttachOptions) (GTK_FILL),
 641                           (GtkAttachOptions) (0), 0, 0);
 642         gtk_misc_set_alignment (GTK_MISC (msgs_label), 0, 0.5);
 643
 644         bottom_hbox = gtk_hbox_new (FALSE, 0);
 645         gtk_table_attach (GTK_TABLE (table), bottom_hbox, 0, 1, 1, 2,
 646                           (GtkAttachOptions) (GTK_FILL),
 647                           (GtkAttachOptions) (GTK_FILL), 0, 0);
 648
 649         show_old_chkbtn = gtk_check_button_new_with_label("Show only old Messages");
 650         gtk_box_pack_start(GTK_BOX(bottom_hbox), show_old_chkbtn, FALSE, FALSE, 0);
 651
 652         gtk_signal_connect(GTK_OBJECT(show_old_chkbtn), "toggled",
 653                            GTK_SIGNAL_FUNC(sd_action_cb), GUINT_TO_POINTER(CHECKBTN));
 654         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(show_old_chkbtn), FALSE);
 655         GTK_WIDGET_UNSET_FLAGS(show_old_chkbtn, GTK_CAN_FOCUS);
 656
 657         expand_label = gtk_label_new (_(" "));
 658         gtk_box_pack_start (GTK_BOX (bottom_hbox), expand_label, TRUE, TRUE, 0);
 659
 660         fixed_label = gtk_label_new (_(" contains "));
 661         gtk_box_pack_end (GTK_BOX (bottom_hbox), fixed_label, FALSE, FALSE, 0);
 662
 663         ac_menu = gtk_menu_new();
 664         gtk_signal_connect(GTK_OBJECT(ac_menu), "selection_done",
 665                            GTK_SIGNAL_FUNC(sd_ac_menu_popup_closed), NULL);
 666         ac_button = gtk_button_new();
 667         gtk_button_set_relief(GTK_BUTTON(ac_button), GTK_RELIEF_NONE);
 668         GTK_WIDGET_UNSET_FLAGS(ac_button, GTK_CAN_FOCUS);
 669         gtk_widget_set_usize(ac_button, -1, 1);
 670         gtk_box_pack_start(GTK_BOX(bottom_hbox), ac_button, FALSE, FALSE, 0);
 671         gtk_signal_connect(GTK_OBJECT(ac_button), "button_press_event",
 672                            GTK_SIGNAL_FUNC(sd_ac_label_pressed), GTK_OBJECT(ac_menu));
 673
 674         ac_label = gtk_label_new("");
 675         gtk_container_add(GTK_CONTAINER(ac_button), ac_label);
 676
 677         scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
 678         gtk_table_attach (GTK_TABLE (table), scrolledwindow, 0, 1, 0, 1,
 679                           (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 680                           (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
 681         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
 682                                         GTK_POLICY_NEVER,
 683                                         GTK_POLICY_AUTOMATIC);
 684
 685         clist = gtk_clist_new (5);
 686         gtk_container_add (GTK_CONTAINER (scrolledwindow), clist);
 687         gtk_container_set_border_width (GTK_CONTAINER (clist), 5);
 688         gtk_clist_set_column_width (GTK_CLIST (clist), 0, 20);
 689         gtk_clist_set_column_width (GTK_CLIST (clist), 1, 150);
 690         gtk_clist_set_column_width (GTK_CLIST (clist), 2, 150);
 691         gtk_clist_set_column_width (GTK_CLIST (clist), 3, 100);
 692         gtk_clist_set_column_width (GTK_CLIST (clist), 4, 30);
 693         gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_BROWSE);
 694         gtk_clist_column_titles_show (GTK_CLIST (clist));
 695
 696         state_label = gtk_label_new (_("#"));
 697         gtk_clist_set_column_widget (GTK_CLIST (clist), 0, state_label);
 698
 699         from_label = gtk_label_new (_("From"));
 700         gtk_clist_set_column_widget (GTK_CLIST (clist), 1, from_label);
 701
 702         subject_label = gtk_label_new (_("Subject"));
 703         gtk_clist_set_column_widget (GTK_CLIST (clist), 2, subject_label);
 704
 705         date_label = gtk_label_new (_("Date"));
 706         gtk_clist_set_column_widget (GTK_CLIST (clist), 3, date_label);
 707
 708         size_label = gtk_label_new (_("Size"));
 709         gtk_widget_ref (size_label);
 710         gtk_clist_set_column_widget (GTK_CLIST (clist), 4, size_label);
 711
 712         toolbar_hbox = gtk_hbox_new (FALSE, 0);
 713
 714         gtk_table_attach (GTK_TABLE (table), toolbar_hbox, 1, 2, 0, 1,
 715                           (GtkAttachOptions) (GTK_FILL),
 716                           (GtkAttachOptions) (GTK_FILL), 0, 0);
 717
 718         toolbar = gtk_toolbar_new (GTK_ORIENTATION_VERTICAL, GTK_TOOLBAR_BOTH);
 719
 720         gtk_box_pack_end (GTK_BOX (toolbar_hbox), toolbar, FALSE, FALSE, 0);
 721         gtk_toolbar_set_space_size (GTK_TOOLBAR (toolbar), 30);
 722         gtk_toolbar_set_space_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_SPACE_LINE);
 723         gtk_container_set_border_width (GTK_CONTAINER (toolbar), 5);
 724
 725         tmp_toolbar_icon = stock_pixmap_widget(toolbar_hbox, STOCK_PIXMAP_MAIL_RECEIVE);
 726         preview_btn = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar),
 727                                                   GTK_TOOLBAR_CHILD_BUTTON,
 728                                                   NULL,
 729                                                   _("Preview Mail"),
 730                                                   _("preview old/new E-Mail on account"), NULL,
 731                                                   tmp_toolbar_icon, NULL, NULL);
 732
 733         n_menu_entries = sizeof(preview_popup_entries)/sizeof(preview_popup_entries[0]);
 734         preview_popup = popupmenu_create(preview_btn, preview_popup_entries, n_menu_entries,
 735                                       "<SelectiveDownload>", window);
 736
 737         gtk_signal_connect(GTK_OBJECT(preview_popup), "selection_done",
 738                            GTK_SIGNAL_FUNC(sd_preview_popup_closed), NULL);
 739
 740         gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 741
 742         tmp_toolbar_icon = stock_pixmap_widget(toolbar_hbox, STOCK_PIXMAP_CLOSE);
 743         remove_btn = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar),
 744                                                  GTK_TOOLBAR_CHILD_BUTTON,
 745                                                  NULL,
 746                                                  _("Remove"),
 747                                                  _("remove selected E-Mails"), NULL,
 748                                                  tmp_toolbar_icon, NULL, NULL);
 749
 750         gtk_widget_set_sensitive (remove_btn, FALSE);
 751
 752         tmp_toolbar_icon = stock_pixmap_widget(toolbar_hbox, STOCK_PIXMAP_DOWN_ARROW);
 753         download_btn = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar),
 754                                                  GTK_TOOLBAR_CHILD_BUTTON,
 755                                                  NULL,
 756                                                  _("Download"),
 757                                                  _("Download selected E-Mails"), NULL,
 758                                                  tmp_toolbar_icon, NULL, NULL);
 759
 760         gtk_widget_set_sensitive (download_btn, FALSE);
 761
 762         gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 763
 764         tmp_toolbar_icon = stock_pixmap_widget (toolbar_hbox, STOCK_PIXMAP_COMPLETE);
 765         done_btn = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar),
 766                                                GTK_TOOLBAR_CHILD_BUTTON,
 767                                                NULL,
 768                                                _("Done"),
 769                                                _("Exit Dialog"), NULL,
 770                                                tmp_toolbar_icon, NULL, NULL);
 771
 772         gtk_signal_connect (GTK_OBJECT (window), "delete_event",
 773                             GTK_SIGNAL_FUNC (gtk_widget_hide_on_delete),
 774                             NULL);
 775         gtk_signal_connect (GTK_OBJECT(window), "key_press_event",
 776                             GTK_SIGNAL_FUNC(sd_key_pressed),
 777                             NULL);
 778         MANAGE_WINDOW_SIGNALS_CONNECT(window);
 779         gtk_signal_connect (GTK_OBJECT (preview_btn), "button_press_event",
 780                             GTK_SIGNAL_FUNC (sd_preview_popup_cb),
 781                             NULL);
 782
 783         gtk_signal_connect (GTK_OBJECT (remove_btn), "clicked",
 784                             GTK_SIGNAL_FUNC (sd_action_cb),
 785                             GUINT_TO_POINTER(REMOVE));
 786         gtk_signal_connect (GTK_OBJECT (download_btn), "clicked",
 787                             GTK_SIGNAL_FUNC (sd_action_cb),
 788                             GUINT_TO_POINTER(DOWNLOAD));
 789         gtk_signal_connect (GTK_OBJECT (done_btn), "clicked",
 790                             GTK_SIGNAL_FUNC (sd_action_cb),
 791                             GUINT_TO_POINTER(DONE));
 792         gtk_signal_connect (GTK_OBJECT (clist), "select_row",
 793                             GTK_SIGNAL_FUNC (sd_select_row_cb),
 794                             NULL);
 795
 796
 797         selective.mainwin         = mainwin;
 798         selective.window          = window;
 799         selective.clist           = clist;
 800         selective.preview_btn     = preview_btn;
 801         selective.remove_btn      = remove_btn;
 802         selective.download_btn    = download_btn;
 803         selective.ac_label        = ac_label;
 804         selective.ac_button       = ac_button;
 805         selective.ac_menu         = ac_menu;
 806         selective.preview_popup   = preview_popup;
 807         selective.msgs_label      = msgs_label;
 808         selective.show_old_chkbtn = show_old_chkbtn;
 809
 810         gtk_widget_show_all(window);
 811 }
 812