src/prefs_filtering.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2003 Hiroyuki Yamamoto and the Sylpheed-Claws 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 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 #include <string.h>
  33 #include <errno.h>
  34
  35 #include "intl.h"
  36 #include "main.h"
  37 #include "prefs_gtk.h"
  38 #include "prefs_matcher.h"
  39 #include "prefs_filtering.h"
  40 #include "prefs_common.h"
  41 #include "mainwindow.h"
  42 #include "foldersel.h"
  43 #include "manage_window.h"
  44 #include "inc.h"
  45 #include "utils.h"
  46 #include "gtkutils.h"
  47 #include "alertpanel.h"
  48 #include "folder.h"
  49 #include "filtering.h"
  50 #include "addr_compl.h"
  51 #include "colorlabel.h"
  52
  53 #include "matcher_parser.h"
  54 #include "matcher.h"
  55
  56 static struct Filtering {
  57         GtkWidget *window;
  58
  59         GtkWidget *ok_btn;
  60         GtkWidget *cond_entry;
  61         GtkWidget *action_list;
  62         GtkWidget *action_combo;
  63         GtkWidget *account_label;
  64         GtkWidget *account_list;
  65         GtkWidget *account_combo;
  66         GtkWidget *dest_entry;
  67         GtkWidget *dest_btn;
  68         GtkWidget *dest_label;
  69         GtkWidget *recip_label;
  70         GtkWidget *exec_label;
  71         GtkWidget *exec_btn;
  72
  73         GtkWidget *color_label;
  74         GtkWidget *color_optmenu;
  75
  76         GtkWidget *cond_clist;
  77
  78         /* need this to make address completion entry work */
  79         gint current_action;
  80 } filtering;
  81
  82 /* widget creating functions */
  83 static void prefs_filtering_create              (void);
  84
  85 static void prefs_filtering_set_dialog  (const gchar *header,
  86                                          const gchar *key);
  87 static void prefs_filtering_set_list    (void);
  88
  89 /* callback functions */
  90 /* static void prefs_filtering_select_dest_cb   (void); */
  91 static void prefs_filtering_register_cb (void);
  92 static void prefs_filtering_substitute_cb       (void);
  93 static void prefs_filtering_delete_cb   (void);
  94 static void prefs_filtering_up          (void);
  95 static void prefs_filtering_down                (void);
  96 static void prefs_filtering_select              (GtkCList       *clist,
  97                                          gint            row,
  98                                          gint            column,
  99                                          GdkEvent       *event);
 100
 101 static gint prefs_filtering_deleted     (GtkWidget      *widget,
 102                                          GdkEventAny    *event,
 103                                          gpointer        data);
 104 static void prefs_filtering_key_pressed (GtkWidget      *widget,
 105                                          GdkEventKey    *event,
 106                                          gpointer        data);
 107 static void prefs_filtering_cancel              (void);
 108 static void prefs_filtering_ok          (void);
 109
 110 static void prefs_filtering_condition_define    (void);
 111 static gint prefs_filtering_clist_set_row(gint row, FilteringProp * prop);
 112 static void prefs_filtering_select_dest(void);
 113 static void prefs_filtering_action_select(GtkList *list,
 114                                           GtkWidget *widget,
 115                                           gpointer user_data);
 116 static void prefs_filtering_action_selection_changed(GtkList *list,
 117                                                      gpointer user_data);
 118
 119 static void prefs_filtering_reset_dialog(void);
 120 static gboolean prefs_filtering_rename_path_func(GNode *node, gpointer data);
 121 static gboolean prefs_filtering_delete_path_func(GNode *node, gpointer data);
 122
 123 static FolderItem * cur_item = NULL;
 124
 125 enum {
 126         ACTION_MOVE = 0,
 127         ACTION_COPY = 1,
 128         ACTION_DELETE = 2,
 129         ACTION_MARK = 3,
 130         ACTION_UNMARK = 4,
 131         ACTION_MARK_AS_READ = 5,
 132         ACTION_MARK_AS_UNREAD = 6,
 133         ACTION_FORWARD = 7,
 134         ACTION_FORWARD_AS_ATTACHMENT = 8,
 135         ACTION_REDIRECT = 9,
 136         ACTION_EXECUTE = 10,
 137         ACTION_COLOR = 11,
 138 };
 139
 140 static gint get_sel_from_list(GtkList * list)
 141 {
 142         gint row = 0;
 143         void * sel;
 144         GList * child;
 145
 146         if (list->selection == NULL)
 147                 return -1;
 148
 149         sel = list->selection->data;
 150         for(child = list->children ; child != NULL ;
 151             child = g_list_next(child)) {
 152                 if (child->data == sel)
 153                         return row;
 154                 row ++;
 155         }
 156
 157         return row;
 158 }
 159
 160 static gint get_account_id_from_list_id(gint list_id)
 161 {
 162         GList * accounts;
 163
 164         for (accounts = account_get_list() ; accounts != NULL;
 165              accounts = accounts->next) {
 166                 PrefsAccount *ac = (PrefsAccount *)accounts->data;
 167
 168                 if (list_id == 0)
 169                         return ac->account_id;
 170                 list_id--;
 171         }
 172         return 0;
 173 }
 174
 175 static gint get_list_id_from_account_id(gint account_id)
 176 {
 177         GList * accounts;
 178         gint list_id = 0;
 179
 180         for (accounts = account_get_list() ; accounts != NULL;
 181              accounts = accounts->next) {
 182                 PrefsAccount *ac = (PrefsAccount *)accounts->data;
 183
 184                 if (account_id == ac->account_id)
 185                         return list_id;
 186                 list_id++;
 187         }
 188         return 0;
 189 }
 190
 191 static gint prefs_filtering_get_matching_from_action(gint action_id)
 192 {
 193         switch(action_id) {
 194         case ACTION_MOVE:
 195                 return MATCHACTION_MOVE;
 196         case ACTION_COPY:
 197                 return MATCHACTION_COPY;
 198         case ACTION_DELETE:
 199                 return MATCHACTION_DELETE;
 200         case ACTION_MARK:
 201                 return MATCHACTION_MARK;
 202         case ACTION_UNMARK:
 203                 return MATCHACTION_UNMARK;
 204         case ACTION_MARK_AS_READ:
 205                 return MATCHACTION_MARK_AS_READ;
 206         case ACTION_MARK_AS_UNREAD:
 207                 return MATCHACTION_MARK_AS_UNREAD;
 208         case ACTION_FORWARD:
 209                 return MATCHACTION_FORWARD;
 210         case ACTION_FORWARD_AS_ATTACHMENT:
 211                 return MATCHACTION_FORWARD_AS_ATTACHMENT;
 212         case ACTION_REDIRECT:
 213                 return MATCHACTION_REDIRECT;
 214         case ACTION_EXECUTE:
 215                 return MATCHACTION_EXECUTE;
 216         case ACTION_COLOR:
 217                 return MATCHACTION_COLOR;
 218         default:
 219                 return -1;
 220         }
 221 }
 222
 223 static gchar * action_text [] = {
 224         N_("Move"),
 225         N_("Copy"),
 226         N_("Delete"),
 227         N_("Mark"),
 228         N_("Unmark"),
 229         N_("Mark as read"),
 230         N_("Mark as unread"),
 231         N_("Forward"),
 232         N_("Forward as attachment"),
 233         N_("Redirect"),
 234         N_("Execute"),
 235         N_("Color"),
 236 };
 237
 238 void prefs_filtering_open(FolderItem * item,
 239                           const gchar *header,
 240                           const gchar *key)
 241 {
 242         gchar *esckey;
 243
 244         if (prefs_rc_is_readonly(FILTERING_RC))
 245                 return;
 246
 247         inc_lock();
 248
 249         if (!filtering.window) {
 250                 prefs_filtering_create();
 251         }
 252
 253         manage_window_set_transient(GTK_WINDOW(filtering.window));
 254         gtk_widget_grab_focus(filtering.ok_btn);
 255
 256         cur_item = item;
 257
 258         esckey = matcher_escape_str(key);
 259         prefs_filtering_set_dialog(header, esckey);
 260         g_free(esckey);
 261
 262         gtk_widget_show(filtering.window);
 263
 264         start_address_completion();
 265 }
 266
 267 /* prefs_filtering_close() - just to have one common exit point */
 268 static void prefs_filtering_close(void)
 269 {
 270         end_address_completion();
 271
 272         gtk_widget_hide(filtering.window);
 273         inc_unlock();
 274 }
 275
 276 static void prefs_filtering_create(void)
 277 {
 278         GtkWidget *window;
 279         GtkWidget *vbox;
 280         GtkWidget *ok_btn;
 281         GtkWidget *cancel_btn;
 282         GtkWidget *confirm_area;
 283
 284         GtkWidget *vbox1;
 285         GtkWidget *hbox1;
 286         GtkWidget *reg_hbox;
 287         GtkWidget *arrow;
 288         GtkWidget *btn_hbox;
 289
 290         GtkWidget *cond_label;
 291         GtkWidget *cond_entry;
 292         GtkWidget *cond_btn;
 293         GtkWidget *action_label;
 294         GtkWidget *action_list;
 295         GtkWidget *action_combo;
 296         GtkWidget *account_label;
 297         GtkWidget *account_list;
 298         GtkWidget *account_combo;
 299         GtkWidget *dest_label;
 300         GtkWidget *recip_label;
 301         GtkWidget *exec_label;
 302         GtkWidget *dest_entry;
 303         GtkWidget *dest_btn;
 304         GtkWidget *exec_btn;
 305         GtkWidget *color_label;
 306         GtkWidget *color_optmenu;
 307
 308         GtkWidget *reg_btn;
 309         GtkWidget *subst_btn;
 310         GtkWidget *del_btn;
 311
 312         GtkWidget *cond_hbox;
 313         GtkWidget *cond_scrolledwin;
 314         GtkWidget *cond_clist;
 315
 316         GtkWidget *btn_vbox;
 317         GtkWidget *up_btn;
 318         GtkWidget *down_btn;
 319
 320
 321         GList *combo_items;
 322         gint i;
 323
 324         GList *accounts;
 325         GList * cur;
 326
 327         gchar *title[1];
 328
 329         debug_print("Creating filtering configuration window...\n");
 330
 331         window = gtk_window_new (GTK_WINDOW_DIALOG);
 332         gtk_container_set_border_width (GTK_CONTAINER (window), 8);
 333         gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
 334         gtk_window_set_modal (GTK_WINDOW (window), TRUE);
 335         gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE);
 336
 337         vbox = gtk_vbox_new (FALSE, 6);
 338         gtk_widget_show (vbox);
 339         gtk_container_add (GTK_CONTAINER (window), vbox);
 340
 341         gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
 342                                 &cancel_btn, _("Cancel"), NULL, NULL);
 343         gtk_widget_show (confirm_area);
 344         gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
 345         gtk_widget_grab_default (ok_btn);
 346
 347         gtk_window_set_title (GTK_WINDOW(window),
 348                                     _("Filtering/Processing configuration"));
 349
 350         gtk_signal_connect (GTK_OBJECT(window), "delete_event",
 351                             GTK_SIGNAL_FUNC(prefs_filtering_deleted), NULL);
 352         gtk_signal_connect (GTK_OBJECT(window), "key_press_event",
 353                             GTK_SIGNAL_FUNC(prefs_filtering_key_pressed), NULL);
 354         MANAGE_WINDOW_SIGNALS_CONNECT (window);
 355         gtk_signal_connect (GTK_OBJECT(ok_btn), "clicked",
 356                             GTK_SIGNAL_FUNC(prefs_filtering_ok), NULL);
 357         gtk_signal_connect (GTK_OBJECT(cancel_btn), "clicked",
 358                             GTK_SIGNAL_FUNC(prefs_filtering_cancel), NULL);
 359
 360         vbox1 = gtk_vbox_new (FALSE, VSPACING);
 361         gtk_widget_show (vbox1);
 362         gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0);
 363         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
 364
 365         cond_label = gtk_label_new (_("Condition"));
 366         gtk_widget_show (cond_label);
 367         gtk_misc_set_alignment (GTK_MISC (cond_label), 0, 0.5);
 368         gtk_box_pack_start (GTK_BOX (vbox1), cond_label, FALSE, FALSE, 0);
 369
 370         hbox1 = gtk_hbox_new (FALSE, VSPACING);
 371         gtk_widget_show (vbox1);
 372         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
 373         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
 374
 375         cond_entry = gtk_entry_new ();
 376         gtk_widget_show (cond_entry);
 377         gtk_box_pack_start (GTK_BOX (hbox1), cond_entry, TRUE, TRUE, 0);
 378
 379         cond_btn = gtk_button_new_with_label (_("Define ..."));
 380         gtk_widget_show (cond_btn);
 381         gtk_box_pack_start (GTK_BOX (hbox1), cond_btn, FALSE, FALSE, 0);
 382         gtk_signal_connect (GTK_OBJECT (cond_btn), "clicked",
 383                             GTK_SIGNAL_FUNC (prefs_filtering_condition_define),
 384                             NULL);
 385
 386         hbox1 = gtk_hbox_new (FALSE, VSPACING);
 387         gtk_widget_show (vbox1);
 388         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
 389         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
 390
 391         action_label = gtk_label_new (_("Action"));
 392         gtk_widget_show (action_label);
 393         gtk_misc_set_alignment (GTK_MISC (action_label), 0, 0.5);
 394         gtk_box_pack_start (GTK_BOX (hbox1), action_label, FALSE, FALSE, 0);
 395
 396         action_combo = gtk_combo_new ();
 397         gtk_widget_show (action_combo);
 398         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(action_combo)->entry),
 399                                FALSE);
 400
 401         combo_items = NULL;
 402
 403         for(i = 0 ; i < (gint) (sizeof(action_text) / sizeof(gchar *)) ;
 404             i++) {
 405                 combo_items = g_list_append(combo_items,
 406                                             (gpointer) _(action_text[i]));
 407         }
 408         gtk_combo_set_popdown_strings(GTK_COMBO(action_combo), combo_items);
 409
 410         g_list_free(combo_items);
 411
 412         gtk_box_pack_start (GTK_BOX (hbox1), action_combo,
 413                             TRUE, TRUE, 0);
 414         action_list = GTK_COMBO(action_combo)->list;
 415         gtk_signal_connect (GTK_OBJECT (action_list), "select-child",
 416                             GTK_SIGNAL_FUNC (prefs_filtering_action_select),
 417                             NULL);
 418
 419         gtk_signal_connect(GTK_OBJECT(action_list), "selection-changed",
 420                            GTK_SIGNAL_FUNC(prefs_filtering_action_selection_changed),
 421                            NULL);
 422
 423         /* accounts */
 424
 425         hbox1 = gtk_hbox_new (FALSE, VSPACING);
 426         gtk_widget_show (vbox1);
 427         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
 428         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
 429
 430         account_label = gtk_label_new (_("Account"));
 431         gtk_widget_show (account_label);
 432         gtk_misc_set_alignment (GTK_MISC (account_label), 0, 0.5);
 433         gtk_box_pack_start (GTK_BOX (hbox1), account_label, FALSE, FALSE, 0);
 434
 435         account_combo = gtk_combo_new ();
 436         gtk_widget_show (account_combo);
 437
 438         combo_items = NULL;
 439         for (accounts = account_get_list() ; accounts != NULL;
 440              accounts = accounts->next) {
 441                 PrefsAccount *ac = (PrefsAccount *)accounts->data;
 442                 gchar *name;
 443
 444                 name = g_strdup_printf("%s <%s> (%s)",
 445                                        ac->name, ac->address,
 446                                        ac->account_name);
 447                 combo_items = g_list_append(combo_items, (gpointer) name);
 448         }
 449
 450         gtk_combo_set_popdown_strings(GTK_COMBO(account_combo), combo_items);
 451
 452         for(cur = g_list_first(combo_items) ; cur != NULL ;
 453             cur = g_list_next(cur))
 454                 g_free(cur->data);
 455         g_list_free(combo_items);
 456
 457         gtk_box_pack_start (GTK_BOX (hbox1), account_combo,
 458                             TRUE, TRUE, 0);
 459         account_list = GTK_COMBO(account_combo)->list;
 460         gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(account_combo)->entry),
 461                                FALSE);
 462
 463         /* destination */
 464
 465         hbox1 = gtk_hbox_new (FALSE, VSPACING);
 466         gtk_widget_show (vbox1);
 467         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
 468         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
 469
 470         dest_label = gtk_label_new (_("Destination"));
 471         gtk_widget_show (dest_label);
 472         gtk_misc_set_alignment (GTK_MISC (dest_label), 0, 0.5);
 473         gtk_box_pack_start (GTK_BOX (hbox1), dest_label, FALSE, FALSE, 0);
 474
 475         recip_label = gtk_label_new (_("Recipient"));
 476         gtk_widget_show (recip_label);
 477         gtk_misc_set_alignment (GTK_MISC (recip_label), 0, 0.5);
 478         gtk_box_pack_start (GTK_BOX (hbox1), recip_label, FALSE, FALSE, 0);
 479
 480         exec_label = gtk_label_new (_("Execute"));
 481         gtk_widget_show (exec_label);
 482         gtk_misc_set_alignment (GTK_MISC (exec_label), 0, 0.5);
 483         gtk_box_pack_start (GTK_BOX (hbox1), exec_label, FALSE, FALSE, 0);
 484
 485         color_label = gtk_label_new (_("Color"));
 486         gtk_widget_show(color_label);
 487         gtk_misc_set_alignment(GTK_MISC(color_label), 0, 0.5);
 488         gtk_box_pack_start(GTK_BOX(hbox1), color_label, FALSE, FALSE, 0);
 489
 490         dest_entry = gtk_entry_new ();
 491         gtk_widget_show (dest_entry);
 492         gtk_box_pack_start (GTK_BOX (hbox1), dest_entry, TRUE, TRUE, 0);
 493
 494         color_optmenu = gtk_option_menu_new();
 495         gtk_option_menu_set_menu(GTK_OPTION_MENU(color_optmenu),
 496                                  colorlabel_create_color_menu());
 497         gtk_box_pack_start(GTK_BOX(hbox1), color_optmenu, TRUE, TRUE, 0);
 498
 499         dest_btn = gtk_button_new_with_label (_("Select ..."));
 500         gtk_widget_show (dest_btn);
 501         gtk_box_pack_start (GTK_BOX (hbox1), dest_btn, FALSE, FALSE, 0);
 502         gtk_signal_connect (GTK_OBJECT (dest_btn), "clicked",
 503                             GTK_SIGNAL_FUNC (prefs_filtering_select_dest),
 504                             NULL);
 505
 506         exec_btn = gtk_button_new_with_label (_("Info ..."));
 507         gtk_widget_show (exec_btn);
 508         gtk_box_pack_start (GTK_BOX (hbox1), exec_btn, FALSE, FALSE, 0);
 509         gtk_signal_connect (GTK_OBJECT (exec_btn), "clicked",
 510                             GTK_SIGNAL_FUNC (prefs_matcher_exec_info),
 511                             NULL);
 512
 513         /* register / substitute / delete */
 514
 515         reg_hbox = gtk_hbox_new (FALSE, 4);
 516         gtk_widget_show (reg_hbox);
 517         gtk_box_pack_start (GTK_BOX (vbox1), reg_hbox, FALSE, FALSE, 0);
 518
 519         arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
 520         gtk_widget_show (arrow);
 521         gtk_box_pack_start (GTK_BOX (reg_hbox), arrow, FALSE, FALSE, 0);
 522         gtk_widget_set_usize (arrow, -1, 16);
 523
 524         btn_hbox = gtk_hbox_new (TRUE, 4);
 525         gtk_widget_show (btn_hbox);
 526         gtk_box_pack_start (GTK_BOX (reg_hbox), btn_hbox, FALSE, FALSE, 0);
 527
 528         reg_btn = gtk_button_new_with_label (_("Add"));
 529         gtk_widget_show (reg_btn);
 530         gtk_box_pack_start (GTK_BOX (btn_hbox), reg_btn, FALSE, TRUE, 0);
 531         gtk_signal_connect (GTK_OBJECT (reg_btn), "clicked",
 532                             GTK_SIGNAL_FUNC (prefs_filtering_register_cb), NULL);
 533
 534         subst_btn = gtk_button_new_with_label (_("  Replace  "));
 535         gtk_widget_show (subst_btn);
 536         gtk_box_pack_start (GTK_BOX (btn_hbox), subst_btn, FALSE, TRUE, 0);
 537         gtk_signal_connect (GTK_OBJECT (subst_btn), "clicked",
 538                             GTK_SIGNAL_FUNC (prefs_filtering_substitute_cb),
 539                             NULL);
 540
 541         del_btn = gtk_button_new_with_label (_("Delete"));
 542         gtk_widget_show (del_btn);
 543         gtk_box_pack_start (GTK_BOX (btn_hbox), del_btn, FALSE, TRUE, 0);
 544         gtk_signal_connect (GTK_OBJECT (del_btn), "clicked",
 545                             GTK_SIGNAL_FUNC (prefs_filtering_delete_cb), NULL);
 546
 547         cond_hbox = gtk_hbox_new (FALSE, 8);
 548         gtk_widget_show (cond_hbox);
 549         gtk_box_pack_start (GTK_BOX (vbox1), cond_hbox, TRUE, TRUE, 0);
 550
 551         cond_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
 552         gtk_widget_show (cond_scrolledwin);
 553         gtk_widget_set_usize (cond_scrolledwin, -1, 150);
 554         gtk_box_pack_start (GTK_BOX (cond_hbox), cond_scrolledwin,
 555                             TRUE, TRUE, 0);
 556         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (cond_scrolledwin),
 557                                         GTK_POLICY_AUTOMATIC,
 558                                         GTK_POLICY_AUTOMATIC);
 559
 560         title[0] = _("Current filtering/processing rules");
 561         cond_clist = gtk_clist_new_with_titles(1, title);
 562         gtk_widget_show (cond_clist);
 563         gtk_container_add (GTK_CONTAINER (cond_scrolledwin), cond_clist);
 564         gtk_clist_set_column_width (GTK_CLIST (cond_clist), 0, 80);
 565         gtk_clist_set_selection_mode (GTK_CLIST (cond_clist),
 566                                       GTK_SELECTION_BROWSE);
 567         GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (cond_clist)->column[0].button,
 568                                 GTK_CAN_FOCUS);
 569         gtk_signal_connect (GTK_OBJECT (cond_clist), "select_row",
 570                             GTK_SIGNAL_FUNC (prefs_filtering_select), NULL);
 571
 572         btn_vbox = gtk_vbox_new (FALSE, 8);
 573         gtk_widget_show (btn_vbox);
 574         gtk_box_pack_start (GTK_BOX (cond_hbox), btn_vbox, FALSE, FALSE, 0);
 575
 576         up_btn = gtk_button_new_with_label (_("Up"));
 577         gtk_widget_show (up_btn);
 578         gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
 579         gtk_signal_connect (GTK_OBJECT (up_btn), "clicked",
 580                             GTK_SIGNAL_FUNC (prefs_filtering_up), NULL);
 581
 582         down_btn = gtk_button_new_with_label (_("Down"));
 583         gtk_widget_show (down_btn);
 584         gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
 585         gtk_signal_connect (GTK_OBJECT (down_btn), "clicked",
 586                             GTK_SIGNAL_FUNC (prefs_filtering_down), NULL);
 587
 588         gtk_widget_set_usize(window, 500, -1);
 589
 590         gtk_widget_show_all(window);
 591
 592         filtering.window    = window;
 593         filtering.ok_btn = ok_btn;
 594
 595         filtering.cond_entry = cond_entry;
 596         filtering.action_list = action_list;
 597         filtering.action_combo = action_combo;
 598         filtering.account_label = account_label;
 599         filtering.account_list = account_list;
 600         filtering.account_combo = account_combo;
 601         filtering.dest_entry = dest_entry;
 602         filtering.dest_btn = dest_btn;
 603         filtering.dest_label = dest_label;
 604         filtering.recip_label = recip_label;
 605         filtering.exec_label = exec_label;
 606         filtering.exec_btn = exec_btn;
 607
 608         filtering.cond_clist   = cond_clist;
 609
 610         filtering.color_label   = color_label;
 611         filtering.color_optmenu = color_optmenu;
 612 }
 613
 614 static void prefs_filtering_update_hscrollbar(void)
 615 {
 616         gint optwidth = gtk_clist_optimal_column_width(GTK_CLIST(filtering.cond_clist), 0);
 617         gtk_clist_set_column_width(GTK_CLIST(filtering.cond_clist), 0, optwidth);
 618 }
 619
 620 void prefs_filtering_rename_path(const gchar *old_path, const gchar *new_path)
 621 {
 622         GList * cur;
 623         gchar *paths[2] = {NULL, NULL};
 624         paths[0] = (gchar*)old_path;
 625         paths[1] = (gchar*)new_path;
 626         for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
 627                 Folder *folder;
 628                 folder = (Folder *) cur->data;
 629                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
 630                                 prefs_filtering_rename_path_func, paths);
 631         }
 632         prefs_filtering_rename_path_func(NULL, paths);
 633 }
 634
 635 static gboolean prefs_filtering_rename_path_func(GNode *node, gpointer data)
 636 {
 637         GSList *cur;
 638         gchar *old_path, *new_path;
 639         gchar *base;
 640         gchar *prefix;
 641         gchar *suffix;
 642         gchar *dest_path;
 643         gchar *old_path_with_sep;
 644         gint destlen;
 645         gint prefixlen;
 646         gint oldpathlen;
 647         FolderItem *item;
 648
 649         old_path = ((gchar **)data)[0];
 650         new_path = ((gchar **)data)[1];
 651
 652         g_return_val_if_fail(old_path != NULL, FALSE);
 653         g_return_val_if_fail(new_path != NULL, FALSE);
 654
 655         oldpathlen = strlen(old_path);
 656         old_path_with_sep = g_strconcat(old_path,G_DIR_SEPARATOR_S,NULL);
 657         if (node == NULL)
 658                 cur = global_processing;
 659         else {
 660                 item = node->data;
 661                 if (!item || !item->prefs)
 662                         return FALSE;
 663                 cur = item->prefs->processing;
 664         }
 665
 666         for (; cur != NULL; cur = cur->next) {
 667                 FilteringProp   *filtering = (FilteringProp *)cur->data;
 668                 FilteringAction *action = filtering->action;
 669
 670                 if (!action->destination) continue;
 671
 672                 destlen = strlen(action->destination);
 673
 674                 if (destlen > oldpathlen) {
 675                         prefixlen = destlen - oldpathlen;
 676                         suffix = action->destination + prefixlen;
 677
 678                         if (!strncmp(old_path, suffix, oldpathlen)) {
 679                                 prefix = g_malloc0(prefixlen + 1);
 680                                 strncpy2(prefix, action->destination, prefixlen);
 681
 682                                 base = suffix + oldpathlen;
 683                                 while (*base == G_DIR_SEPARATOR) base++;
 684                                 if (*base == '\0')
 685                                         dest_path = g_strconcat(prefix,
 686                                                                 G_DIR_SEPARATOR_S,
 687                                                                 new_path, NULL);
 688                                 else
 689                                         dest_path = g_strconcat(prefix,
 690                                                                 G_DIR_SEPARATOR_S,
 691                                                                 new_path,
 692                                                                 G_DIR_SEPARATOR_S,
 693                                                                 base, NULL);
 694
 695                                 g_free(prefix);
 696                                 g_free(action->destination);
 697                                 action->destination = dest_path;
 698                         } else { /* for non-leaf folders */
 699                                 /* compare with trailing slash */
 700                                 if (!strncmp(old_path_with_sep, action->destination, oldpathlen+1)) {
 701
 702                                         suffix = action->destination + oldpathlen + 1;
 703                                         dest_path = g_strconcat(new_path,
 704                                                                 G_DIR_SEPARATOR_S,
 705                                                                 suffix, NULL);
 706                                         g_free(action->destination);
 707                                         action->destination = dest_path;
 708                                 }
 709                         }
 710                 } else {
 711                         /* folder-moving a leaf */
 712                         if (!strcmp(old_path, action->destination)) {
 713                                 dest_path = g_strdup(new_path);
 714                                 g_free(action->destination);
 715                                 action->destination = dest_path;
 716                         }
 717                 }
 718         }
 719         g_free(old_path_with_sep);
 720         prefs_matcher_write_config();
 721
 722         return FALSE;
 723 }
 724
 725 void prefs_filtering_delete_path(const gchar *path)
 726 {
 727         GList * cur;
 728         for (cur = folder_get_list() ; cur != NULL ; cur = g_list_next(cur)) {
 729                 Folder *folder;
 730                 folder = (Folder *) cur->data;
 731                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
 732                                 prefs_filtering_delete_path_func, (gchar *)path);
 733         }
 734         prefs_filtering_delete_path_func(NULL, (gchar *)path);
 735 }
 736
 737 static gboolean prefs_filtering_delete_path_func(GNode *node, gpointer data)
 738 {
 739         GSList *cur, *orig;
 740         GSList *next;
 741         gchar *path = (gchar *)data;
 742         gchar *suffix;
 743         gint destlen;
 744         gint prefixlen;
 745         gint pathlen;
 746         FolderItem *item;
 747
 748         g_return_val_if_fail(path != NULL, FALSE);
 749
 750         pathlen = strlen(path);
 751         if (node == NULL)
 752                 cur = global_processing;
 753         else {
 754                 item = node->data;
 755                 if (!item || !item->prefs)
 756                         return FALSE;
 757                 cur = item->prefs->processing;
 758         }
 759         orig = cur;
 760
 761         for (; cur != NULL; cur = cur->next) {
 762                 FilteringProp *filtering = (FilteringProp *)cur->data;
 763                 FilteringAction *action;
 764                 if (!cur->data)
 765                         break;
 766
 767                 action = filtering->action;
 768                 next = cur->next;
 769
 770                 if (!action->destination) continue;
 771
 772                 destlen = strlen(action->destination);
 773
 774                 if (destlen > pathlen) {
 775                         prefixlen = destlen - pathlen;
 776                         suffix = action->destination + prefixlen;
 777
 778                         if (suffix && !strncmp(path, suffix, pathlen)) {
 779                                 filteringprop_free(filtering);
 780                                 orig = g_slist_remove(orig, filtering);
 781                         }
 782                 } else if (strcmp(action->destination, path) == 0) {
 783                         filteringprop_free(filtering);
 784                         orig = g_slist_remove(orig, filtering);
 785
 786                 }
 787         }
 788
 789         if (node == NULL)
 790                 global_processing = orig;
 791         else {
 792                 item = node->data;
 793                 if (!item || !item->prefs)
 794                         return FALSE;
 795                 item->prefs->processing = orig;
 796         }
 797
 798         prefs_matcher_write_config();
 799
 800         return FALSE;
 801 }
 802
 803 static void prefs_filtering_set_dialog(const gchar *header, const gchar *key)
 804 {
 805         GtkCList *clist = GTK_CLIST(filtering.cond_clist);
 806         GSList *cur;
 807         GSList * prefs_filtering;
 808         gchar *cond_str[1];
 809         gint row;
 810
 811         gtk_clist_freeze(clist);
 812         gtk_clist_clear(clist);
 813
 814         cond_str[0] = _("(New)");
 815         row = gtk_clist_append(clist, cond_str);
 816         gtk_clist_set_row_data(clist, row, NULL);
 817
 818         if (cur_item == NULL)
 819                 prefs_filtering = global_processing;
 820         else
 821                 prefs_filtering = cur_item->prefs->processing;
 822
 823         for(cur = prefs_filtering ; cur != NULL ; cur = g_slist_next(cur)) {
 824                 FilteringProp * prop = (FilteringProp *) cur->data;
 825
 826                 cond_str[0] = filteringprop_to_string(prop);
 827                 subst_char(cond_str[0], '\t', ':');
 828                 row = gtk_clist_append(clist, cond_str);
 829                 gtk_clist_set_row_data(clist, row, prop);
 830
 831                 g_free(cond_str[0]);
 832         }
 833
 834         prefs_filtering_update_hscrollbar();
 835         gtk_clist_thaw(clist);
 836
 837         prefs_filtering_reset_dialog();
 838
 839         if (header && key) {
 840                 gchar *match_str = g_strconcat(header, " ",
 841                         get_matchparser_tab_str(MATCHTYPE_MATCHCASE),
 842                         " \"", key, "\"", NULL);
 843                 gtk_entry_set_text(GTK_ENTRY(filtering.cond_entry), match_str);
 844                 g_free(match_str);
 845         }
 846 }
 847
 848 static void prefs_filtering_reset_dialog(void)
 849 {
 850         gtk_list_select_item(GTK_LIST(filtering.action_list), 0);
 851         gtk_list_select_item(GTK_LIST(filtering.account_list), 0);
 852         gtk_entry_set_text(GTK_ENTRY(filtering.dest_entry), "");
 853         gtk_entry_set_text(GTK_ENTRY(filtering.cond_entry), "");
 854 }
 855
 856 static void prefs_filtering_set_list(void)
 857 {
 858         gint row = 1;
 859         FilteringProp *prop;
 860         GSList * cur;
 861         gchar * filtering_str;
 862         GSList * prefs_filtering;
 863
 864         if (cur_item == NULL)
 865                 prefs_filtering = global_processing;
 866         else
 867                 prefs_filtering = cur_item->prefs->processing;
 868
 869         for(cur = prefs_filtering ; cur != NULL ; cur = g_slist_next(cur))
 870                 filteringprop_free((FilteringProp *) cur->data);
 871         g_slist_free(prefs_filtering);
 872         prefs_filtering = NULL;
 873
 874         while (gtk_clist_get_text(GTK_CLIST(filtering.cond_clist),
 875                                   row, 0, &filtering_str)) {
 876                 if (strcmp(filtering_str, _("(New)")) != 0) {
 877                         /* tmp = filtering_str; */
 878                         prop = matcher_parser_get_filtering(filtering_str);
 879                         if (prop != NULL)
 880                                 prefs_filtering =
 881                                         g_slist_append(prefs_filtering, prop);
 882                 }
 883                 row++;
 884         }
 885
 886         if (cur_item == NULL)
 887                 global_processing = prefs_filtering;
 888         else
 889                 cur_item->prefs->processing = prefs_filtering;
 890 }
 891
 892 static gint prefs_filtering_clist_set_row(gint row, FilteringProp * prop)
 893 {
 894         GtkCList *clist = GTK_CLIST(filtering.cond_clist);
 895         gchar * str;
 896         gchar *cond_str[1];
 897
 898         if (prop == NULL) {
 899                 cond_str[0] = _("(New)");
 900                 return gtk_clist_append(clist, cond_str);
 901         }
 902
 903         str = filteringprop_to_string(prop);
 904         if (str == NULL) {
 905                 return -1;
 906         }
 907         cond_str[0] = str;
 908
 909         if (row < 0)
 910                 row = gtk_clist_append(clist, cond_str);
 911         else
 912                 gtk_clist_set_text(clist, row, 0, cond_str[0]);
 913         g_free(str);
 914
 915         return row;
 916 }
 917
 918 static void prefs_filtering_condition_define_done(MatcherList * matchers)
 919 {
 920         gchar * str;
 921
 922         if (matchers == NULL)
 923                 return;
 924
 925         str = matcherlist_to_string(matchers);
 926
 927         if (str != NULL) {
 928                 gtk_entry_set_text(GTK_ENTRY(filtering.cond_entry), str);
 929                 g_free(str);
 930         }
 931 }
 932
 933 static void prefs_filtering_condition_define(void)
 934 {
 935         gchar * cond_str;
 936         MatcherList * matchers = NULL;
 937
 938         cond_str = gtk_entry_get_text(GTK_ENTRY(filtering.cond_entry));
 939
 940         if (*cond_str != '\0') {
 941                 matchers = matcher_parser_get_cond(cond_str);
 942                 if (matchers == NULL)
 943                         alertpanel_error(_("Condition string is not valid."));
 944         }
 945
 946         prefs_matcher_open(matchers, prefs_filtering_condition_define_done);
 947
 948         if (matchers != NULL)
 949                 matcherlist_free(matchers);
 950 }
 951
 952
 953 /* register / substitute delete buttons */
 954
 955
 956 static FilteringProp * prefs_filtering_dialog_to_filtering(gboolean alert)
 957 {
 958         MatcherList * cond;
 959         gchar * cond_str;
 960         FilteringProp * prop;
 961         FilteringAction * action;
 962         gint list_id;
 963         gint action_id;
 964         gint action_type;
 965         gint account_id;
 966         gchar * destination;
 967         gint labelcolor = 0;
 968
 969         cond_str = gtk_entry_get_text(GTK_ENTRY(filtering.cond_entry));
 970         if (*cond_str == '\0') {
 971                 if(alert == TRUE) alertpanel_error(_("Condition string is empty."));
 972                 return NULL;
 973         }
 974
 975         action_id = get_sel_from_list(GTK_LIST(filtering.action_list));
 976         action_type = prefs_filtering_get_matching_from_action(action_id);
 977         list_id = get_sel_from_list(GTK_LIST(filtering.account_list));
 978         account_id = get_account_id_from_list_id(list_id);
 979
 980         switch (action_id) {
 981         case ACTION_MOVE:
 982         case ACTION_COPY:
 983         case ACTION_EXECUTE:
 984                 destination = gtk_entry_get_text(GTK_ENTRY(filtering.dest_entry));
 985                 if (*destination == '\0') {
 986                         if(alert == TRUE) alertpanel_error(_("Destination is not set."));
 987                         return NULL;
 988                 }
 989                 break;
 990         case ACTION_FORWARD:
 991         case ACTION_FORWARD_AS_ATTACHMENT:
 992         case ACTION_REDIRECT:
 993                 destination = gtk_entry_get_text(GTK_ENTRY(filtering.dest_entry));
 994                 if (*destination == '\0') {
 995                         if(alert == TRUE) alertpanel_error(_("Recipient is not set."));
 996                         return NULL;
 997                 }
 998                 break;
 999         case ACTION_COLOR:
1000                 labelcolor = colorlabel_get_color_menu_active_item(
1001                         gtk_option_menu_get_menu(GTK_OPTION_MENU(filtering.color_optmenu)));
1002                 destination = NULL;
1003                 break;
1004         default:
1005                 destination = NULL;
1006                 break;
1007         }
1008
1009         action = filteringaction_new(action_type, account_id, destination, labelcolor);
1010
1011         cond = matcher_parser_get_cond(cond_str);
1012
1013         if (cond == NULL) {
1014                 if(alert == TRUE) alertpanel_error(_("Condition string is not valid."));
1015                 filteringaction_free(action);
1016                 return NULL;
1017         }
1018
1019         prop = filteringprop_new(cond, action);
1020
1021         return prop;
1022 }
1023
1024 static void prefs_filtering_register_cb(void)
1025 {
1026         FilteringProp * prop;
1027
1028         prop = prefs_filtering_dialog_to_filtering(TRUE);
1029         if (prop == NULL)
1030                 return;
1031         prefs_filtering_clist_set_row(-1, prop);
1032
1033         filteringprop_free(prop);
1034
1035         prefs_filtering_update_hscrollbar();
1036 }
1037
1038 static void prefs_filtering_substitute_cb(void)
1039 {
1040         GtkCList *clist = GTK_CLIST(filtering.cond_clist);
1041         gint row;
1042         FilteringProp * prop;
1043
1044         if (!clist->selection) return;
1045
1046         row = GPOINTER_TO_INT(clist->selection->data);
1047         if (row == 0) return;
1048
1049         prop = prefs_filtering_dialog_to_filtering(TRUE);
1050         if (prop == NULL)
1051                 return;
1052         prefs_filtering_clist_set_row(row, prop);
1053
1054         filteringprop_free(prop);
1055
1056         prefs_filtering_update_hscrollbar();
1057 }
1058
1059 static void prefs_filtering_delete_cb(void)
1060 {
1061         GtkCList *clist = GTK_CLIST(filtering.cond_clist);
1062         gint row;
1063
1064         if (!clist->selection) return;
1065         row = GPOINTER_TO_INT(clist->selection->data);
1066         if (row == 0) return;
1067
1068         if (alertpanel(_("Delete rule"),
1069                        _("Do you really want to delete this rule?"),
1070                        _("Yes"), _("No"), NULL) == G_ALERTALTERNATE)
1071                 return;
1072
1073         gtk_clist_remove(clist, row);
1074
1075         prefs_filtering_reset_dialog();
1076
1077         prefs_filtering_update_hscrollbar();
1078 }
1079
1080 static void prefs_filtering_up(void)
1081 {
1082         GtkCList *clist = GTK_CLIST(filtering.cond_clist);
1083         gint row;
1084
1085         if (!clist->selection) return;
1086
1087         row = GPOINTER_TO_INT(clist->selection->data);
1088         if (row > 1) {
1089                 gtk_clist_row_move(clist, row, row - 1);
1090                 if(gtk_clist_row_is_visible(clist, row - 1) != GTK_VISIBILITY_FULL) {
1091                         gtk_clist_moveto(clist, row - 1, 0, 0, 0);
1092                 }
1093         }
1094 }
1095
1096 static void prefs_filtering_down(void)
1097 {
1098         GtkCList *clist = GTK_CLIST(filtering.cond_clist);
1099         gint row;
1100
1101         if (!clist->selection) return;
1102
1103         row = GPOINTER_TO_INT(clist->selection->data);
1104         if (row > 0 && row < clist->rows - 1) {
1105                 gtk_clist_row_move(clist, row, row + 1);
1106                 if(gtk_clist_row_is_visible(clist, row + 1) != GTK_VISIBILITY_FULL) {
1107                         gtk_clist_moveto(clist, row + 1, 0, 1, 0);
1108                 }
1109         }
1110 }
1111
1112 static void prefs_filtering_select_set(FilteringProp * prop)
1113 {
1114         FilteringAction * action;
1115         gchar * matcher_str;
1116         gint list_id;
1117
1118         prefs_filtering_reset_dialog();
1119
1120         action = prop->action;
1121
1122         matcher_str = matcherlist_to_string(prop->matchers);
1123         if (matcher_str == NULL) {
1124                 filteringprop_free(prop);
1125                 return;
1126         }
1127
1128         gtk_entry_set_text(GTK_ENTRY(filtering.cond_entry), matcher_str);
1129
1130         if (action->destination)
1131                 gtk_entry_set_text(GTK_ENTRY(filtering.dest_entry), action->destination);
1132         else
1133                 gtk_entry_set_text(GTK_ENTRY(filtering.dest_entry), "");
1134
1135         switch(action->type) {
1136         case MATCHACTION_MOVE:
1137                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1138                                      ACTION_MOVE);
1139                 break;
1140         case MATCHACTION_COPY:
1141                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1142                                      ACTION_COPY);
1143                 break;
1144         case MATCHACTION_DELETE:
1145                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1146                                      ACTION_DELETE);
1147                 break;
1148         case MATCHACTION_MARK:
1149                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1150                                      ACTION_MARK);
1151                 break;
1152         case MATCHACTION_UNMARK:
1153                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1154                                      ACTION_UNMARK);
1155                 break;
1156         case MATCHACTION_MARK_AS_READ:
1157                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1158                                      ACTION_MARK_AS_READ);
1159                 break;
1160         case MATCHACTION_MARK_AS_UNREAD:
1161                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1162                                      ACTION_MARK_AS_UNREAD);
1163                 break;
1164         case MATCHACTION_FORWARD:
1165                 list_id = get_list_id_from_account_id(action->account_id);
1166                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1167                                      ACTION_FORWARD);
1168                 gtk_list_select_item(GTK_LIST(filtering.account_list),
1169                                      list_id);
1170                 break;
1171         case MATCHACTION_FORWARD_AS_ATTACHMENT:
1172                 list_id = get_list_id_from_account_id(action->account_id);
1173                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1174                                      ACTION_FORWARD_AS_ATTACHMENT);
1175                 gtk_list_select_item(GTK_LIST(filtering.account_list),
1176                                      list_id);
1177                 break;
1178         case MATCHACTION_REDIRECT:
1179                 list_id = get_list_id_from_account_id(action->account_id);
1180                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1181                                      ACTION_REDIRECT);
1182                 gtk_list_select_item(GTK_LIST(filtering.account_list),
1183                                      list_id);
1184                 break;
1185         case MATCHACTION_EXECUTE:
1186                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1187                                      ACTION_EXECUTE);
1188                 break;
1189         case MATCHACTION_COLOR:
1190                 gtk_list_select_item(GTK_LIST(filtering.action_list),
1191                                      ACTION_COLOR);
1192                 gtk_option_menu_set_history(GTK_OPTION_MENU(filtering.color_optmenu), action->labelcolor);
1193                 break;
1194         }
1195
1196         g_free(matcher_str);
1197 }
1198
1199 static void prefs_filtering_select(GtkCList *clist, gint row, gint column,
1200                                 GdkEvent *event)
1201 {
1202         FilteringProp * prop;
1203         gchar * filtering_str;
1204
1205         if (row == 0) {
1206                 prefs_filtering_reset_dialog();
1207                 return;
1208         }
1209
1210         if (!gtk_clist_get_text(GTK_CLIST(filtering.cond_clist),
1211                                 row, 0, &filtering_str))
1212                 return;
1213
1214         prop = matcher_parser_get_filtering(filtering_str);
1215         if (prop == NULL)
1216                 return;
1217
1218         prefs_filtering_select_set(prop);
1219
1220         filteringprop_free(prop);
1221 }
1222
1223 static void prefs_filtering_select_dest(void)
1224 {
1225         FolderItem *dest;
1226         gchar * path;
1227
1228         dest = foldersel_folder_sel(NULL, FOLDER_SEL_COPY, NULL);
1229         if (!dest) return;
1230
1231         path = folder_item_get_identifier(dest);
1232
1233         gtk_entry_set_text(GTK_ENTRY(filtering.dest_entry), path);
1234         g_free(path);
1235 }
1236
1237 static void prefs_filtering_action_selection_changed(GtkList *list,
1238                                                      gpointer user_data)
1239 {
1240         gint value;
1241
1242         value = get_sel_from_list(GTK_LIST(filtering.action_list));
1243
1244         if (filtering.current_action != value) {
1245                 if (filtering.current_action == ACTION_FORWARD
1246                 ||  filtering.current_action == ACTION_FORWARD_AS_ATTACHMENT
1247                 ||  filtering.current_action == ACTION_REDIRECT) {
1248                         debug_print("unregistering address completion entry\n");
1249                         address_completion_unregister_entry(GTK_ENTRY(filtering.dest_entry));
1250                 }
1251                 if (value == ACTION_FORWARD || value == ACTION_FORWARD_AS_ATTACHMENT
1252                 ||  value == ACTION_REDIRECT) {
1253                         debug_print("registering address completion entry\n");
1254                         address_completion_register_entry(GTK_ENTRY(filtering.dest_entry));
1255                 }
1256                 filtering.current_action = value;
1257         }
1258 }
1259
1260 static void prefs_filtering_action_select(GtkList *list,
1261                                           GtkWidget *widget,
1262                                           gpointer user_data)
1263 {
1264         gint value;
1265
1266         value = get_sel_from_list(GTK_LIST(filtering.action_list));
1267
1268         switch (value) {
1269         case ACTION_MOVE:
1270                 gtk_widget_show(filtering.account_label);
1271                 gtk_widget_set_sensitive(filtering.account_label, FALSE);
1272                 gtk_widget_set_sensitive(filtering.account_combo, FALSE);
1273                 gtk_widget_show(filtering.dest_entry);
1274                 gtk_widget_set_sensitive(filtering.dest_entry, TRUE);
1275                 gtk_widget_show(filtering.dest_btn);
1276                 gtk_widget_set_sensitive(filtering.dest_btn, TRUE);
1277                 gtk_widget_show(filtering.dest_label);
1278                 gtk_widget_set_sensitive(filtering.dest_label, TRUE);
1279                 gtk_widget_hide(filtering.recip_label);
1280                 gtk_widget_hide(filtering.exec_label);
1281                 gtk_widget_hide(filtering.exec_btn);
1282                 gtk_widget_hide(filtering.color_optmenu);
1283                 gtk_widget_hide(filtering.color_label);
1284                 break;
1285         case ACTION_COPY:
1286                 gtk_widget_show(filtering.account_label);
1287                 gtk_widget_set_sensitive(filtering.account_label, FALSE);
1288                 gtk_widget_set_sensitive(filtering.account_combo, FALSE);
1289                 gtk_widget_show(filtering.dest_entry);
1290                 gtk_widget_set_sensitive(filtering.dest_entry, TRUE);
1291                 gtk_widget_show(filtering.dest_btn);
1292                 gtk_widget_set_sensitive(filtering.dest_btn, TRUE);
1293                 gtk_widget_show(filtering.dest_label);
1294                 gtk_widget_set_sensitive(filtering.dest_label, TRUE);
1295                 gtk_widget_hide(filtering.recip_label);
1296                 gtk_widget_hide(filtering.exec_label);
1297                 gtk_widget_hide(filtering.exec_btn);
1298                 gtk_widget_hide(filtering.color_optmenu);
1299                 gtk_widget_hide(filtering.color_label);
1300                 break;
1301         case ACTION_DELETE:
1302                 gtk_widget_show(filtering.account_label);
1303                 gtk_widget_set_sensitive(filtering.account_label, FALSE);
1304                 gtk_widget_set_sensitive(filtering.account_combo, FALSE);
1305                 gtk_widget_show(filtering.dest_entry);
1306                 gtk_widget_set_sensitive(filtering.dest_entry, FALSE);
1307                 gtk_widget_show(filtering.dest_btn);
1308                 gtk_widget_set_sensitive(filtering.dest_btn, FALSE);
1309                 gtk_widget_show(filtering.dest_label);
1310                 gtk_widget_set_sensitive(filtering.dest_label, FALSE);
1311                 gtk_widget_hide(filtering.recip_label);
1312                 gtk_widget_hide(filtering.exec_label);
1313                 gtk_widget_hide(filtering.exec_btn);
1314                 gtk_widget_hide(filtering.color_optmenu);
1315                 gtk_widget_hide(filtering.color_label);
1316                 break;
1317         case ACTION_MARK:
1318                 gtk_widget_show(filtering.account_label);
1319                 gtk_widget_set_sensitive(filtering.account_label, FALSE);
1320                 gtk_widget_set_sensitive(filtering.account_combo, FALSE);
1321                 gtk_widget_show(filtering.dest_entry);
1322                 gtk_widget_set_sensitive(filtering.dest_entry, FALSE);
1323                 gtk_widget_show(filtering.dest_btn);
1324                 gtk_widget_set_sensitive(filtering.dest_btn, FALSE);
1325                 gtk_widget_show(filtering.dest_label);
1326                 gtk_widget_set_sensitive(filtering.dest_label, FALSE);
1327                 gtk_widget_hide(filtering.recip_label);
1328                 gtk_widget_hide(filtering.exec_label);
1329                 gtk_widget_hide(filtering.exec_btn);
1330                 gtk_widget_hide(filtering.color_optmenu);
1331                 gtk_widget_hide(filtering.color_label);
1332                 break;
1333         case ACTION_UNMARK:
1334                 gtk_widget_show(filtering.account_label);
1335                 gtk_widget_set_sensitive(filtering.account_label, FALSE);
1336                 gtk_widget_set_sensitive(filtering.account_combo, FALSE);
1337                 gtk_widget_show(filtering.dest_entry);
1338                 gtk_widget_set_sensitive(filtering.dest_entry, FALSE);
1339                 gtk_widget_show(filtering.dest_btn);
1340                 gtk_widget_set_sensitive(filtering.dest_btn, FALSE);
1341                 gtk_widget_show(filtering.dest_label);
1342                 gtk_widget_set_sensitive(filtering.dest_label, FALSE);
1343                 gtk_widget_hide(filtering.recip_label);
1344                 gtk_widget_hide(filtering.exec_label);
1345                 gtk_widget_hide(filtering.exec_btn);
1346                 gtk_widget_hide(filtering.color_optmenu);
1347                 gtk_widget_hide(filtering.color_label);
1348                 break;
1349         case ACTION_MARK_AS_READ:
1350                 gtk_widget_show(filtering.account_label);
1351                 gtk_widget_set_sensitive(filtering.account_label, FALSE);
1352                 gtk_widget_set_sensitive(filtering.account_combo, FALSE);
1353                 gtk_widget_show(filtering.dest_entry);
1354                 gtk_widget_set_sensitive(filtering.dest_entry, FALSE);
1355                 gtk_widget_show(filtering.dest_btn);
1356                 gtk_widget_set_sensitive(filtering.dest_btn, FALSE);
1357                 gtk_widget_show(filtering.dest_label);
1358                 gtk_widget_set_sensitive(filtering.dest_label, FALSE);
1359                 gtk_widget_hide(filtering.recip_label);
1360                 gtk_widget_hide(filtering.exec_label);
1361                 gtk_widget_hide(filtering.exec_btn);
1362                 gtk_widget_hide(filtering.color_optmenu);
1363                 gtk_widget_hide(filtering.color_label);
1364                 break;
1365         case ACTION_MARK_AS_UNREAD:
1366                 gtk_widget_show(filtering.account_label);
1367                 gtk_widget_set_sensitive(filtering.account_label, FALSE);
1368                 gtk_widget_set_sensitive(filtering.account_combo, FALSE);
1369                 gtk_widget_show(filtering.dest_entry);
1370                 gtk_widget_set_sensitive(filtering.dest_entry, FALSE);
1371                 gtk_widget_show(filtering.dest_btn);
1372                 gtk_widget_set_sensitive(filtering.dest_btn, FALSE);
1373                 gtk_widget_show(filtering.dest_label);
1374                 gtk_widget_set_sensitive(filtering.dest_label, FALSE);
1375                 gtk_widget_hide(filtering.recip_label);
1376                 gtk_widget_hide(filtering.exec_label);
1377                 gtk_widget_hide(filtering.exec_btn);
1378                 gtk_widget_hide(filtering.color_optmenu);
1379                 gtk_widget_hide(filtering.color_label);
1380                 break;
1381         case ACTION_FORWARD:
1382                 gtk_widget_show(filtering.account_label);
1383                 gtk_widget_set_sensitive(filtering.account_label, TRUE);
1384                 gtk_widget_set_sensitive(filtering.account_combo, TRUE);
1385                 gtk_widget_show(filtering.dest_entry);
1386                 gtk_widget_set_sensitive(filtering.dest_entry, TRUE);
1387                 gtk_widget_show(filtering.dest_btn);
1388                 gtk_widget_set_sensitive(filtering.dest_btn, FALSE);
1389                 gtk_widget_hide(filtering.dest_label);
1390                 gtk_widget_show(filtering.recip_label);
1391                 gtk_widget_set_sensitive(filtering.recip_label, TRUE);
1392                 gtk_widget_hide(filtering.exec_label);
1393                 gtk_widget_hide(filtering.exec_btn);
1394                 gtk_widget_hide(filtering.color_optmenu);
1395                 gtk_widget_hide(filtering.color_label);
1396                 break;
1397         case ACTION_FORWARD_AS_ATTACHMENT:
1398                 gtk_widget_show(filtering.account_label);
1399                 gtk_widget_set_sensitive(filtering.account_label, TRUE);
1400                 gtk_widget_set_sensitive(filtering.account_combo, TRUE);
1401                 gtk_widget_show(filtering.dest_entry);
1402                 gtk_widget_set_sensitive(filtering.dest_entry, TRUE);
1403                 gtk_widget_show(filtering.dest_btn);
1404                 gtk_widget_set_sensitive(filtering.dest_btn, FALSE);
1405                 gtk_widget_hide(filtering.dest_label);
1406                 gtk_widget_show(filtering.recip_label);
1407                 gtk_widget_set_sensitive(filtering.recip_label, TRUE);
1408                 gtk_widget_hide(filtering.exec_label);
1409                 gtk_widget_hide(filtering.exec_btn);
1410                 gtk_widget_hide(filtering.color_optmenu);
1411                 gtk_widget_hide(filtering.color_label);
1412                 break;
1413         case ACTION_REDIRECT:
1414                 gtk_widget_show(filtering.account_label);
1415                 gtk_widget_set_sensitive(filtering.account_label, TRUE);
1416                 gtk_widget_set_sensitive(filtering.account_combo, TRUE);
1417                 gtk_widget_show(filtering.dest_entry);
1418                 gtk_widget_set_sensitive(filtering.dest_entry, TRUE);
1419                 gtk_widget_show(filtering.dest_btn);
1420                 gtk_widget_set_sensitive(filtering.dest_btn, FALSE);
1421                 gtk_widget_hide(filtering.dest_label);
1422                 gtk_widget_show(filtering.recip_label);
1423                 gtk_widget_set_sensitive(filtering.recip_label, TRUE);
1424                 gtk_widget_hide(filtering.exec_label);
1425                 gtk_widget_hide(filtering.exec_btn);
1426                 gtk_widget_hide(filtering.color_optmenu);
1427                 gtk_widget_hide(filtering.color_label);
1428                 break;
1429         case ACTION_EXECUTE:
1430                 gtk_widget_show(filtering.account_label);
1431                 gtk_widget_set_sensitive(filtering.account_label, FALSE);
1432                 gtk_widget_set_sensitive(filtering.account_combo, FALSE);
1433                 gtk_widget_show(filtering.dest_entry);
1434                 gtk_widget_set_sensitive(filtering.dest_entry, TRUE);
1435                 gtk_widget_hide(filtering.dest_btn);
1436                 gtk_widget_hide(filtering.dest_label);
1437                 gtk_widget_hide(filtering.recip_label);
1438                 gtk_widget_show(filtering.exec_label);
1439                 gtk_widget_set_sensitive(filtering.exec_btn, TRUE);
1440                 gtk_widget_show(filtering.exec_btn);
1441                 gtk_widget_hide(filtering.color_optmenu);
1442                 gtk_widget_hide(filtering.color_label);
1443                 break;
1444         case ACTION_COLOR:
1445                 gtk_widget_show(filtering.account_label);
1446                 gtk_widget_set_sensitive(filtering.account_label, FALSE);
1447                 gtk_widget_set_sensitive(filtering.account_combo, FALSE);
1448                 gtk_widget_hide(filtering.dest_entry);
1449                 gtk_widget_hide(filtering.dest_btn);
1450                 gtk_widget_hide(filtering.dest_label);
1451                 gtk_widget_hide(filtering.recip_label);
1452                 gtk_widget_hide(filtering.exec_label);
1453                 gtk_widget_show(filtering.exec_btn);
1454                 gtk_widget_set_sensitive(filtering.exec_btn, FALSE);
1455                 gtk_widget_show(filtering.color_optmenu);
1456                 gtk_widget_show(filtering.color_label);
1457                 break;
1458         }
1459 }
1460
1461 static gint prefs_filtering_deleted(GtkWidget *widget, GdkEventAny *event,
1462                                  gpointer data)
1463 {
1464         prefs_filtering_cancel();
1465         return TRUE;
1466 }
1467
1468 static void prefs_filtering_key_pressed(GtkWidget *widget, GdkEventKey *event,
1469                                      gpointer data)
1470 {
1471         if (event && event->keyval == GDK_Escape)
1472                 prefs_filtering_cancel();
1473 }
1474
1475 static void prefs_filtering_ok(void)
1476 {
1477         FilteringProp * prop;
1478         gchar * str;
1479         gchar * filtering_str;
1480         gint row = 1;
1481         AlertValue val;
1482
1483         prop = prefs_filtering_dialog_to_filtering(FALSE);
1484         if (prop != NULL) {
1485                 str = filteringprop_to_string(prop);
1486
1487                 while (gtk_clist_get_text(GTK_CLIST(filtering.cond_clist),
1488                                           row, 0, &filtering_str)) {
1489                         if (strcmp(filtering_str, str) == 0) break;
1490                         row++;
1491                 }
1492                 if (strcmp(filtering_str, str) != 0) {
1493                         val = alertpanel(_("Entry not saved"),
1494                                  _("The entry was not saved. Close anyway?"),
1495                                  _("Yes"), _("No"), NULL);
1496                         if (G_ALERTDEFAULT != val) {
1497                                 g_free(str);
1498                                 return;
1499                         }
1500                 }
1501                 g_free(str);
1502         }
1503         prefs_filtering_set_list();
1504         prefs_matcher_write_config();
1505         prefs_filtering_close();
1506 }
1507
1508 static void prefs_filtering_cancel(void)
1509 {
1510         prefs_matcher_read_config();
1511         prefs_filtering_close();
1512 }