src/prefs_scoring.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2001 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 <gdk/gdkkeysyms.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <errno.h>
  33
  34 #include "intl.h"
  35 #include "main.h"
  36 #include "prefs.h"
  37 #include "prefs_matcher.h"
  38 #include "prefs_scoring.h"
  39 #include "prefs_common.h"
  40 #include "mainwindow.h"
  41 #include "foldersel.h"
  42 #include "manage_window.h"
  43 #include "inc.h"
  44 #include "utils.h"
  45 #include "gtkutils.h"
  46 #include "alertpanel.h"
  47 #include "folder.h"
  48 #include "scoring.h"
  49
  50 static struct Scoring {
  51         GtkWidget *window;
  52
  53         GtkWidget *ok_btn;
  54         GtkWidget *cond_entry;
  55         GtkWidget *score_entry;
  56         GtkWidget *kill_score_label;
  57         GtkWidget *kill_score_entry;
  58         GtkWidget *important_score_entry;
  59
  60         GtkWidget *cond_clist;
  61 } scoring;
  62
  63 /*
  64    parameter name, default value, pointer to the prefs variable, data type,
  65    pointer to the widget pointer,
  66    pointer to the function for data setting,
  67    pointer to the function for widget setting
  68  */
  69
  70 #define VSPACING                12
  71 #define VSPACING_NARROW         4
  72 #define DEFAULT_ENTRY_WIDTH     80
  73 #define PREFSBUFSIZE            1024
  74
  75 /* widget creating functions */
  76 static void prefs_scoring_create                (void);
  77
  78 static void prefs_scoring_set_dialog    (ScoringProp * prop);
  79 static void prefs_scoring_set_list      (void);
  80
  81 /* callback functions */
  82 /* static void prefs_scoring_select_dest_cb     (void); */
  83 static void prefs_scoring_register_cb   (void);
  84 static void prefs_scoring_substitute_cb (void);
  85 static void prefs_scoring_delete_cb     (void);
  86 static void prefs_scoring_up            (void);
  87 static void prefs_scoring_down          (void);
  88 static void prefs_scoring_select                (GtkCList       *clist,
  89                                          gint            row,
  90                                          gint            column,
  91                                          GdkEvent       *event);
  92
  93 static gint prefs_scoring_deleted       (GtkWidget      *widget,
  94                                          GdkEventAny    *event,
  95                                          gpointer        data);
  96 static void prefs_scoring_key_pressed   (GtkWidget      *widget,
  97                                          GdkEventKey    *event,
  98                                          gpointer        data);
  99 static void prefs_scoring_cancel                (void);
 100 static void prefs_scoring_ok            (void);
 101
 102 static void prefs_scoring_condition_define      (void);
 103 static gint prefs_scoring_clist_set_row(gint row, ScoringProp * prop);
 104 static void prefs_scoring_select_set_dialog(ScoringProp * prop);
 105 static void prefs_scoring_reset_dialog(void);
 106
 107
 108 static FolderItem * cur_item = NULL;
 109 static gint cur_important_score;
 110 static gint cur_kill_score;
 111
 112 void prefs_scoring_open(FolderItem * item)
 113 {
 114         if (prefs_rc_is_readonly(SCORING_RC))
 115                 return;
 116
 117         inc_autocheck_timer_remove();
 118
 119         if (!scoring.window) {
 120                 prefs_scoring_create();
 121         }
 122
 123         manage_window_set_transient(GTK_WINDOW(scoring.window));
 124         gtk_widget_grab_focus(scoring.ok_btn);
 125
 126         cur_item = item;
 127
 128         prefs_scoring_set_dialog(NULL);
 129
 130         gtk_widget_show(scoring.window);
 131 }
 132
 133 void prefs_scoring_open_with_scoring(ScoringProp * prop)
 134 {
 135         inc_autocheck_timer_remove();
 136
 137         if (!scoring.window) {
 138                 prefs_scoring_create();
 139         }
 140
 141         manage_window_set_transient(GTK_WINDOW(scoring.window));
 142         gtk_widget_grab_focus(scoring.ok_btn);
 143
 144         prefs_scoring_set_dialog(prop);
 145
 146         gtk_widget_show(scoring.window);
 147 }
 148
 149 static void prefs_scoring_create(void)
 150 {
 151         GtkWidget *window;
 152         GtkWidget *vbox;
 153         GtkWidget *ok_btn;
 154         GtkWidget *cancel_btn;
 155         GtkWidget *confirm_area;
 156
 157         GtkWidget *vbox1;
 158         GtkWidget *hbox1;
 159         GtkWidget *reg_hbox;
 160         GtkWidget *arrow;
 161         GtkWidget *btn_hbox;
 162
 163         GtkWidget *cond_label;
 164         GtkWidget *cond_entry;
 165         GtkWidget *cond_btn;
 166         GtkWidget *score_label;
 167         GtkWidget *score_entry;
 168
 169         GtkWidget *reg_btn;
 170         GtkWidget *subst_btn;
 171         GtkWidget *del_btn;
 172
 173         GtkWidget *cond_hbox;
 174         GtkWidget *cond_scrolledwin;
 175         GtkWidget *cond_clist;
 176
 177         GtkWidget *btn_vbox;
 178         GtkWidget *up_btn;
 179         GtkWidget *down_btn;
 180
 181         GtkWidget *important_score_entry;
 182         GtkWidget *kill_score_entry;
 183         GtkWidget *kill_score_label;
 184
 185         gchar *title[] = {_("Registered rules")};
 186
 187         debug_print(_("Creating scoring setting window...\n"));
 188
 189         window = gtk_window_new (GTK_WINDOW_DIALOG);
 190         gtk_container_set_border_width (GTK_CONTAINER (window), 8);
 191         gtk_window_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
 192         gtk_window_set_modal (GTK_WINDOW (window), TRUE);
 193         gtk_window_set_policy (GTK_WINDOW (window), FALSE, TRUE, FALSE);
 194
 195         vbox = gtk_vbox_new (FALSE, 6);
 196         gtk_widget_show (vbox);
 197         gtk_container_add (GTK_CONTAINER (window), vbox);
 198
 199         gtkut_button_set_create(&confirm_area, &ok_btn, _("OK"),
 200                                 &cancel_btn, _("Cancel"), NULL, NULL);
 201         gtk_widget_show (confirm_area);
 202         gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
 203         gtk_widget_grab_default (ok_btn);
 204
 205         gtk_window_set_title (GTK_WINDOW(window),
 206                               _("Scoring setting"));
 207         gtk_signal_connect (GTK_OBJECT(window), "delete_event",
 208                             GTK_SIGNAL_FUNC(prefs_scoring_deleted), NULL);
 209         gtk_signal_connect (GTK_OBJECT(window), "key_press_event",
 210                             GTK_SIGNAL_FUNC(prefs_scoring_key_pressed), NULL);
 211         gtk_signal_connect (GTK_OBJECT(window), "focus_in_event",
 212                             GTK_SIGNAL_FUNC(manage_window_focus_in), NULL);
 213         gtk_signal_connect (GTK_OBJECT(window), "focus_out_event",
 214                             GTK_SIGNAL_FUNC(manage_window_focus_out), NULL);
 215         gtk_signal_connect (GTK_OBJECT(ok_btn), "clicked",
 216                             GTK_SIGNAL_FUNC(prefs_scoring_ok), NULL);
 217         gtk_signal_connect (GTK_OBJECT(cancel_btn), "clicked",
 218                             GTK_SIGNAL_FUNC(prefs_scoring_cancel), NULL);
 219
 220         vbox1 = gtk_vbox_new (FALSE, VSPACING);
 221         gtk_widget_show (vbox1);
 222         gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0);
 223         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
 224
 225         cond_label = gtk_label_new (_("Condition"));
 226         gtk_widget_show (cond_label);
 227         gtk_misc_set_alignment (GTK_MISC (cond_label), 0, 0.5);
 228         gtk_box_pack_start (GTK_BOX (vbox1), cond_label, FALSE, FALSE, 0);
 229
 230         hbox1 = gtk_hbox_new (FALSE, VSPACING);
 231         gtk_widget_show (vbox1);
 232         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
 233         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
 234
 235         cond_entry = gtk_entry_new ();
 236         gtk_widget_show (cond_entry);
 237         gtk_widget_set_usize (cond_entry, 300, -1);
 238         gtk_box_pack_start (GTK_BOX (hbox1), cond_entry, TRUE, TRUE, 0);
 239
 240         cond_btn = gtk_button_new_with_label (_("Define ..."));
 241         gtk_widget_show (cond_btn);
 242         gtk_box_pack_start (GTK_BOX (hbox1), cond_btn, FALSE, FALSE, 0);
 243         gtk_signal_connect (GTK_OBJECT (cond_btn), "clicked",
 244                             GTK_SIGNAL_FUNC (prefs_scoring_condition_define),
 245                             NULL);
 246
 247         hbox1 = gtk_hbox_new (FALSE, VSPACING);
 248         gtk_widget_show (vbox1);
 249         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
 250         gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2);
 251
 252         score_label = gtk_label_new (_("Score"));
 253         gtk_widget_show (score_label);
 254         gtk_misc_set_alignment (GTK_MISC (score_label), 0, 0.5);
 255         gtk_box_pack_start (GTK_BOX (hbox1), score_label, FALSE, FALSE, 0);
 256
 257         score_entry = gtk_entry_new ();
 258         gtk_widget_show (score_entry);
 259         gtk_widget_set_usize (score_entry, 50, -1);
 260         gtk_box_pack_start (GTK_BOX (hbox1), score_entry, FALSE, FALSE, 0);
 261
 262         /* register / substitute / delete */
 263
 264         reg_hbox = gtk_hbox_new (FALSE, 4);
 265         gtk_widget_show (reg_hbox);
 266         gtk_box_pack_start (GTK_BOX (vbox1), reg_hbox, FALSE, FALSE, 0);
 267
 268         arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
 269         gtk_widget_show (arrow);
 270         gtk_box_pack_start (GTK_BOX (reg_hbox), arrow, FALSE, FALSE, 0);
 271         gtk_widget_set_usize (arrow, -1, 16);
 272
 273         btn_hbox = gtk_hbox_new (TRUE, 4);
 274         gtk_widget_show (btn_hbox);
 275         gtk_box_pack_start (GTK_BOX (reg_hbox), btn_hbox, FALSE, FALSE, 0);
 276
 277         reg_btn = gtk_button_new_with_label (_("Register"));
 278         gtk_widget_show (reg_btn);
 279         gtk_box_pack_start (GTK_BOX (btn_hbox), reg_btn, FALSE, TRUE, 0);
 280         gtk_signal_connect (GTK_OBJECT (reg_btn), "clicked",
 281                             GTK_SIGNAL_FUNC (prefs_scoring_register_cb), NULL);
 282
 283         subst_btn = gtk_button_new_with_label (_(" Substitute "));
 284         gtk_widget_show (subst_btn);
 285         gtk_box_pack_start (GTK_BOX (btn_hbox), subst_btn, FALSE, TRUE, 0);
 286         gtk_signal_connect (GTK_OBJECT (subst_btn), "clicked",
 287                             GTK_SIGNAL_FUNC (prefs_scoring_substitute_cb),
 288                             NULL);
 289
 290         del_btn = gtk_button_new_with_label (_("Delete"));
 291         gtk_widget_show (del_btn);
 292         gtk_box_pack_start (GTK_BOX (btn_hbox), del_btn, FALSE, TRUE, 0);
 293         gtk_signal_connect (GTK_OBJECT (del_btn), "clicked",
 294                             GTK_SIGNAL_FUNC (prefs_scoring_delete_cb), NULL);
 295
 296         cond_hbox = gtk_hbox_new (FALSE, 8);
 297         gtk_widget_show (cond_hbox);
 298         gtk_box_pack_start (GTK_BOX (vbox1), cond_hbox, TRUE, TRUE, 0);
 299
 300         cond_scrolledwin = gtk_scrolled_window_new (NULL, NULL);
 301         gtk_widget_show (cond_scrolledwin);
 302         gtk_widget_set_usize (cond_scrolledwin, -1, 150);
 303         gtk_box_pack_start (GTK_BOX (cond_hbox), cond_scrolledwin,
 304                             TRUE, TRUE, 0);
 305         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (cond_scrolledwin),
 306                                         GTK_POLICY_AUTOMATIC,
 307                                         GTK_POLICY_AUTOMATIC);
 308
 309         cond_clist = gtk_clist_new_with_titles(1, title);
 310         gtk_widget_show (cond_clist);
 311         gtk_container_add (GTK_CONTAINER (cond_scrolledwin), cond_clist);
 312         gtk_clist_set_column_width (GTK_CLIST (cond_clist), 0, 80);
 313         gtk_clist_set_selection_mode (GTK_CLIST (cond_clist),
 314                                       GTK_SELECTION_BROWSE);
 315         GTK_WIDGET_UNSET_FLAGS (GTK_CLIST (cond_clist)->column[0].button,
 316                                 GTK_CAN_FOCUS);
 317         gtk_signal_connect (GTK_OBJECT (cond_clist), "select_row",
 318                             GTK_SIGNAL_FUNC (prefs_scoring_select), NULL);
 319
 320         btn_vbox = gtk_vbox_new (FALSE, 8);
 321         gtk_widget_show (btn_vbox);
 322         gtk_box_pack_start (GTK_BOX (cond_hbox), btn_vbox, FALSE, FALSE, 0);
 323
 324         up_btn = gtk_button_new_with_label (_("Up"));
 325         gtk_widget_show (up_btn);
 326         gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0);
 327         gtk_signal_connect (GTK_OBJECT (up_btn), "clicked",
 328                             GTK_SIGNAL_FUNC (prefs_scoring_up), NULL);
 329
 330         down_btn = gtk_button_new_with_label (_("Down"));
 331         gtk_widget_show (down_btn);
 332         gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0);
 333         gtk_signal_connect (GTK_OBJECT (down_btn), "clicked",
 334                             GTK_SIGNAL_FUNC (prefs_scoring_down), NULL);
 335
 336         hbox1 = gtk_hbox_new (FALSE, 8);
 337         gtk_widget_show (hbox1);
 338         gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
 339
 340         kill_score_label = gtk_label_new (_("Kill score"));
 341         gtk_widget_show (kill_score_label);
 342         gtk_misc_set_alignment (GTK_MISC (kill_score_label), 0, 0.5);
 343         gtk_box_pack_start (GTK_BOX (hbox1), kill_score_label,
 344                             FALSE, FALSE, 0);
 345
 346         kill_score_entry = gtk_entry_new ();
 347         gtk_widget_show (kill_score_entry);
 348         gtk_widget_set_usize (kill_score_entry, 50, -1);
 349         gtk_box_pack_start (GTK_BOX (hbox1), kill_score_entry,
 350                             FALSE, FALSE, 0);
 351
 352         score_label = gtk_label_new (_("Important score"));
 353         gtk_widget_show (score_label);
 354         gtk_misc_set_alignment (GTK_MISC (score_label), 0, 0.5);
 355         gtk_box_pack_start (GTK_BOX (hbox1), score_label, FALSE, FALSE, 0);
 356
 357         important_score_entry = gtk_entry_new ();
 358         gtk_widget_show (important_score_entry);
 359         gtk_widget_set_usize (important_score_entry, 50, -1);
 360         gtk_box_pack_start (GTK_BOX (hbox1), important_score_entry,
 361                             FALSE, FALSE, 0);
 362
 363         gtk_widget_show_all(window);
 364
 365         scoring.window    = window;
 366         scoring.ok_btn = ok_btn;
 367
 368         scoring.cond_entry = cond_entry;
 369         scoring.score_entry = score_entry;
 370         scoring.kill_score_entry = kill_score_entry;
 371         scoring.kill_score_label = kill_score_label;
 372         scoring.important_score_entry = important_score_entry;
 373
 374         scoring.cond_clist   = cond_clist;
 375 }
 376
 377 static void prefs_scoring_set_dialog(ScoringProp * cond)
 378 {
 379         GtkCList *clist = GTK_CLIST(scoring.cond_clist);
 380         GSList *cur;
 381         GSList * prefs_scoring;
 382         gchar * score_str;
 383
 384         if (cond == NULL)
 385                 prefs_scoring_reset_dialog();
 386         else
 387                 prefs_scoring_select_set_dialog(cond);
 388
 389         gtk_clist_freeze(clist);
 390         gtk_clist_clear(clist);
 391
 392         prefs_scoring_clist_set_row(-1, NULL);
 393         if (cur_item == NULL) {
 394                 prefs_scoring = global_scoring;
 395                 cur_kill_score = prefs_common.kill_score;
 396                 cur_important_score = prefs_common.important_score;
 397                 gtk_widget_show(scoring.kill_score_label);
 398                 gtk_widget_show(scoring.kill_score_entry);
 399         }
 400         else {
 401                 prefs_scoring = cur_item->prefs->scoring;
 402                 cur_kill_score = cur_item->prefs->kill_score;
 403                 cur_important_score = cur_item->prefs->important_score;
 404                 if (cur_item->folder->type != F_NEWS) {
 405                         gtk_widget_hide(scoring.kill_score_label);
 406                         gtk_widget_hide(scoring.kill_score_entry);
 407                 }
 408                 else {
 409                         gtk_widget_show(scoring.kill_score_label);
 410                         gtk_widget_show(scoring.kill_score_entry);
 411                 }
 412         }
 413
 414         for(cur = prefs_scoring ; cur != NULL ;
 415             cur = g_slist_next(cur)) {
 416                 ScoringProp * prop = (ScoringProp *) cur->data;
 417
 418                 prefs_scoring_clist_set_row(-1, prop);
 419         }
 420
 421         score_str = itos(cur_kill_score);
 422         gtk_entry_set_text(GTK_ENTRY(scoring.kill_score_entry),
 423                            score_str);
 424         score_str = itos(cur_important_score);
 425         gtk_entry_set_text(GTK_ENTRY(scoring.important_score_entry),
 426                            score_str);
 427
 428         gtk_clist_thaw(clist);
 429 }
 430
 431 static void prefs_scoring_reset_dialog(void)
 432 {
 433         gtk_entry_set_text(GTK_ENTRY(scoring.cond_entry), "");
 434         gtk_entry_set_text(GTK_ENTRY(scoring.score_entry), "");
 435 }
 436
 437 static void prefs_scoring_set_list(void)
 438 {
 439         gint row = 1;
 440         ScoringProp *prop;
 441         GSList * cur;
 442         gchar * scoring_str;
 443         gchar * tmp;
 444         GSList * prefs_scoring;
 445
 446         if (cur_item == NULL)
 447                 prefs_scoring = global_scoring;
 448         else
 449                 prefs_scoring = cur_item->prefs->scoring;
 450
 451         for(cur = prefs_scoring ; cur != NULL ;
 452             cur = g_slist_next(cur))
 453                 scoringprop_free((ScoringProp *) cur->data);
 454         g_slist_free(prefs_scoring);
 455         prefs_scoring = NULL;
 456
 457         while (gtk_clist_get_text(GTK_CLIST(scoring.cond_clist),
 458                                   row, 0, &scoring_str)) {
 459                 if (strcmp(scoring_str, _("(New)")) != 0) {
 460                         tmp = scoring_str;
 461                         prop = scoringprop_parse(&tmp);
 462                         if (prop != NULL)
 463                                 prefs_scoring = g_slist_append(prefs_scoring,
 464                                                                prop);
 465                 }
 466                 row++;
 467         }
 468
 469         cur_kill_score = atoi(gtk_entry_get_text(GTK_ENTRY(scoring.kill_score_entry)));
 470         cur_important_score = atoi(gtk_entry_get_text(GTK_ENTRY(scoring.important_score_entry)));
 471
 472         if (cur_item == NULL) {
 473                 global_scoring = prefs_scoring;
 474                 prefs_common.kill_score = cur_kill_score;
 475                 prefs_common.important_score = cur_important_score;
 476         }
 477         else {
 478                 cur_item->prefs->scoring = prefs_scoring;
 479                 cur_item->prefs->kill_score = cur_kill_score;
 480                 cur_item->prefs->important_score = cur_important_score;
 481         }
 482 }
 483
 484 static gint prefs_scoring_clist_set_row(gint row, ScoringProp * prop)
 485 {
 486         GtkCList *clist = GTK_CLIST(scoring.cond_clist);
 487         gchar * str;
 488         gchar *cond_str[1];
 489
 490         if (prop == NULL) {
 491                 cond_str[0] = _("(New)");
 492                 return gtk_clist_append(clist, cond_str);
 493         }
 494
 495         str = scoringprop_to_string(prop);
 496         if (str == NULL) {
 497                 return -1;
 498         }
 499         cond_str[0] = str;
 500
 501         if (row < 0)
 502                 row = gtk_clist_append(clist, cond_str);
 503         else
 504                 gtk_clist_set_text(clist, row, 0, cond_str[0]);
 505         g_free(str);
 506
 507         return row;
 508 }
 509
 510 static void prefs_scoring_condition_define_done(MatcherList * matchers)
 511 {
 512         gchar * str;
 513
 514         if (matchers == NULL)
 515                 return;
 516
 517         str = matcherlist_to_string(matchers);
 518
 519         if (str != NULL) {
 520                 gtk_entry_set_text(GTK_ENTRY(scoring.cond_entry), str);
 521                 g_free(str);
 522         }
 523 }
 524
 525 static void prefs_scoring_condition_define(void)
 526 {
 527         gchar * cond_str;
 528         MatcherList * matchers = NULL;
 529
 530         cond_str = gtk_entry_get_text(GTK_ENTRY(scoring.cond_entry));
 531
 532         if (*cond_str != '\0') {
 533                 gchar * tmp;
 534
 535                 tmp = cond_str;
 536                 matchers = matcherlist_parse(&tmp);
 537                 if (tmp == NULL)
 538                         alertpanel_error(_("Match string is not valid."));
 539         }
 540
 541         prefs_matcher_open(matchers, prefs_scoring_condition_define_done);
 542
 543         if (matchers != NULL)
 544                 matcherlist_free(matchers);
 545 }
 546
 547
 548 /* register / substitute delete buttons */
 549
 550 static void prefs_scoring_register_cb(void)
 551 {
 552         MatcherList * cond;
 553         gchar * cond_str;
 554         gchar * score_str;
 555         ScoringProp * prop;
 556         gint score;
 557         gchar * tmp;
 558
 559         cond_str = gtk_entry_get_text(GTK_ENTRY(scoring.cond_entry));
 560         if (*cond_str == '\0') {
 561                 alertpanel_error(_("Score is not set."));
 562                 return;
 563         }
 564
 565         score_str = gtk_entry_get_text(GTK_ENTRY(scoring.score_entry));
 566         if (*score_str == '\0') {
 567                 alertpanel_error(_("Match string is not set."));
 568                 return;
 569         }
 570
 571         score = atoi(score_str);
 572         tmp = cond_str;
 573         cond = matcherlist_parse(&tmp);
 574
 575         if (tmp == NULL) {
 576                 alertpanel_error(_("Match string is not valid."));
 577                 return;
 578         }
 579
 580         prop = scoringprop_new(cond, score);
 581
 582         prefs_scoring_clist_set_row(-1, prop);
 583
 584         scoringprop_free(prop);
 585
 586         prefs_scoring_reset_dialog();
 587 }
 588
 589 static void prefs_scoring_substitute_cb(void)
 590 {
 591         GtkCList *clist = GTK_CLIST(scoring.cond_clist);
 592         gint row;
 593         MatcherList * cond;
 594         gchar * cond_str;
 595         gchar * score_str;
 596         ScoringProp * prop;
 597         gint score;
 598         gchar * tmp;
 599
 600         if (!clist->selection) return;
 601
 602         row = GPOINTER_TO_INT(clist->selection->data);
 603         if (row == 0) return;
 604
 605         cond_str = gtk_entry_get_text(GTK_ENTRY(scoring.cond_entry));
 606         if (*cond_str == '\0') {
 607                 alertpanel_error(_("Score is not set."));
 608                 return;
 609         }
 610
 611         score_str = gtk_entry_get_text(GTK_ENTRY(scoring.score_entry));
 612         if (*score_str == '\0') {
 613                 alertpanel_error(_("Match string is not set."));
 614                 return;
 615         }
 616
 617         score = atoi(score_str);
 618         tmp = cond_str;
 619         cond = matcherlist_parse(&tmp);
 620
 621         if (tmp == NULL) {
 622                 alertpanel_error(_("Match string is not valid."));
 623                 return;
 624         }
 625
 626         prop = scoringprop_new(cond, score);
 627
 628         prefs_scoring_clist_set_row(row, prop);
 629
 630         scoringprop_free(prop);
 631
 632         prefs_scoring_reset_dialog();
 633 }
 634
 635 static void prefs_scoring_delete_cb(void)
 636 {
 637         GtkCList *clist = GTK_CLIST(scoring.cond_clist);
 638         gint row;
 639
 640         if (!clist->selection) return;
 641         row = GPOINTER_TO_INT(clist->selection->data);
 642         if (row == 0) return;
 643
 644         if (alertpanel(_("Delete rule"),
 645                        _("Do you really want to delete this rule?"),
 646                        _("Yes"), _("No"), NULL) == G_ALERTALTERNATE)
 647                 return;
 648
 649         gtk_clist_remove(clist, row);
 650 }
 651
 652 static void prefs_scoring_up(void)
 653 {
 654         GtkCList *clist = GTK_CLIST(scoring.cond_clist);
 655         gint row;
 656
 657         if (!clist->selection) return;
 658
 659         row = GPOINTER_TO_INT(clist->selection->data);
 660         if (row > 1) {
 661                 gtk_clist_row_move(clist, row, row - 1);
 662                 if(gtk_clist_row_is_visible(clist, row - 1) != GTK_VISIBILITY_FULL) {
 663                         gtk_clist_moveto(clist, row - 1, 0, 0, 0);
 664                 }
 665         }
 666 }
 667
 668 static void prefs_scoring_down(void)
 669 {
 670         GtkCList *clist = GTK_CLIST(scoring.cond_clist);
 671         gint row;
 672
 673         if (!clist->selection) return;
 674
 675         row = GPOINTER_TO_INT(clist->selection->data);
 676         if (row > 0 && row < clist->rows - 1) {
 677                 gtk_clist_row_move(clist, row, row + 1);
 678                 if(gtk_clist_row_is_visible(clist, row + 1) != GTK_VISIBILITY_FULL) {
 679                         gtk_clist_moveto(clist, row + 1, 0, 1, 0);
 680                 }
 681         }
 682 }
 683
 684 static void prefs_scoring_select_set_dialog(ScoringProp * prop)
 685 {
 686         gchar * matcher_str;
 687         gchar * score_str;
 688
 689         if (prop == NULL)
 690                 return;
 691
 692         matcher_str = matcherlist_to_string(prop->matchers);
 693         if (matcher_str == NULL) {
 694                 scoringprop_free(prop);
 695                 return;
 696         }
 697
 698         score_str = itos(prop->score);
 699
 700         gtk_entry_set_text(GTK_ENTRY(scoring.cond_entry), matcher_str);
 701         gtk_entry_set_text(GTK_ENTRY(scoring.score_entry), score_str);
 702
 703         g_free(matcher_str);
 704 }
 705
 706 static void prefs_scoring_select(GtkCList *clist, gint row, gint column,
 707                                 GdkEvent *event)
 708 {
 709         ScoringProp * prop;
 710         gchar * tmp;
 711
 712         gchar * scoring_str;
 713
 714         if (row == 0) {
 715                 prefs_scoring_reset_dialog();
 716                 return;
 717         }
 718
 719         if (!gtk_clist_get_text(GTK_CLIST(scoring.cond_clist),
 720                                 row, 0, &scoring_str))
 721                 return;
 722
 723         tmp = scoring_str;
 724         prop = scoringprop_parse(&tmp);
 725         if (tmp == NULL)
 726                 return;
 727
 728         prefs_scoring_select_set_dialog(prop);
 729
 730         scoringprop_free(prop);
 731 }
 732
 733 static gint prefs_scoring_deleted(GtkWidget *widget, GdkEventAny *event,
 734                                  gpointer data)
 735 {
 736         prefs_scoring_cancel();
 737         return TRUE;
 738 }
 739
 740 static void prefs_scoring_key_pressed(GtkWidget *widget, GdkEventKey *event,
 741                                      gpointer data)
 742 {
 743         if (event && event->keyval == GDK_Escape)
 744                 prefs_scoring_cancel();
 745 }
 746
 747 static void prefs_scoring_ok(void)
 748 {
 749         prefs_scoring_set_list();
 750         prefs_scoring_write_config();
 751         if (cur_item != NULL)
 752                 prefs_folder_item_save_config(cur_item);
 753         gtk_widget_hide(scoring.window);
 754 }
 755
 756 static void prefs_scoring_cancel(void)
 757 {
 758         prefs_scoring_read_config();
 759         gtk_widget_hide(scoring.window);
 760 }