Revision 195 src/prefs_filter.c
| prefs_filter.c (revision 195) | ||
|---|---|---|
| 53 | 53 |
static struct FilterRuleListWindow {
|
| 54 | 54 |
GtkWidget *window; |
| 55 | 55 |
|
| 56 |
GtkWidget *clist; |
|
| 56 |
GtkWidget *treeview; |
|
| 57 |
GtkListStore *store; |
|
| 58 |
GtkTreeSelection *selection; |
|
| 57 | 59 |
|
| 58 | 60 |
GtkWidget *add_btn; |
| 59 | 61 |
GtkWidget *edit_btn; |
| ... | ... | |
| 69 | 71 |
GtkWidget *close_btn; |
| 70 | 72 |
} rule_list_window; |
| 71 | 73 |
|
| 72 |
static GdkPixmap *markxpm; |
|
| 73 |
static GdkBitmap *markxpmmask; |
|
| 74 |
enum {
|
|
| 75 |
COL_ENABLED, |
|
| 76 |
COL_NAME, |
|
| 77 |
COL_FILTER_RULE, |
|
| 78 |
N_COLS |
|
| 79 |
}; |
|
| 74 | 80 |
|
| 75 | 81 |
static void prefs_filter_create (void); |
| 76 | 82 |
|
| 77 | 83 |
static void prefs_filter_set_dialog (void); |
| 78 |
static void prefs_filter_set_list_row (gint row,
|
|
| 84 |
static void prefs_filter_set_list_row (GtkTreeIter *iter,
|
|
| 79 | 85 |
FilterRule *rule, |
| 80 | 86 |
gboolean move_view); |
| 81 | 87 |
|
| ... | ... | |
| 95 | 101 |
static void prefs_filter_down (void); |
| 96 | 102 |
static void prefs_filter_bottom (void); |
| 97 | 103 |
|
| 98 |
static void prefs_filter_select (GtkCList *clist, |
|
| 99 |
gint row, |
|
| 100 |
gint column, |
|
| 101 |
GdkEvent *event); |
|
| 102 |
static void prefs_filter_row_move (GtkCList *clist, |
|
| 103 |
gint source_row, |
|
| 104 |
gint dest_row); |
|
| 104 |
static gboolean prefs_filter_select (GtkTreeSelection *selection, |
|
| 105 |
GtkTreeModel *model, |
|
| 106 |
GtkTreePath *path, |
|
| 107 |
gboolean cur_selected, |
|
| 108 |
gpointer data); |
|
| 109 |
static void prefs_filter_enable_toggled (GtkCellRenderer *cell, |
|
| 110 |
gchar *path, |
|
| 111 |
gpointer data); |
|
| 105 | 112 |
|
| 113 |
static void prefs_filter_row_activated (GtkTreeView *treeview, |
|
| 114 |
GtkTreePath *path, |
|
| 115 |
GtkTreeViewColumn *column, |
|
| 116 |
gpointer data); |
|
| 117 |
static void prefs_filter_row_reordered (GtkTreeModel *model, |
|
| 118 |
GtkTreePath *path, |
|
| 119 |
GtkTreeIter *iter, |
|
| 120 |
gpointer data, |
|
| 121 |
gpointer user_data); |
|
| 122 |
|
|
| 106 | 123 |
static gint prefs_filter_deleted (GtkWidget *widget, |
| 107 | 124 |
GdkEventAny *event, |
| 108 | 125 |
gpointer data); |
| ... | ... | |
| 134 | 151 |
rule = prefs_filter_edit_open(NULL, header); |
| 135 | 152 |
|
| 136 | 153 |
if (rule) {
|
| 137 |
prefs_filter_set_list_row(-1, rule, TRUE);
|
|
| 154 |
prefs_filter_set_list_row(NULL, rule, TRUE);
|
|
| 138 | 155 |
prefs_filter_set_list(); |
| 139 | 156 |
} |
| 140 | 157 |
} |
| ... | ... | |
| 149 | 166 |
|
| 150 | 167 |
GtkWidget *hbox; |
| 151 | 168 |
GtkWidget *scrolledwin; |
| 152 |
GtkWidget *clist; |
|
| 169 |
GtkWidget *treeview; |
|
| 170 |
GtkListStore *store; |
|
| 171 |
GtkTreeSelection *selection; |
|
| 172 |
GtkTreeViewColumn *column; |
|
| 173 |
GtkCellRenderer *renderer; |
|
| 153 | 174 |
|
| 154 | 175 |
GtkWidget *btn_vbox; |
| 155 | 176 |
GtkWidget *spc_vbox; |
| ... | ... | |
| 164 | 185 |
GtkWidget *copy_btn; |
| 165 | 186 |
GtkWidget *del_btn; |
| 166 | 187 |
|
| 167 |
gchar *title[2]; |
|
| 168 |
|
|
| 169 | 188 |
debug_print("Creating filter setting window...\n");
|
| 170 | 189 |
|
| 171 | 190 |
window = gtk_window_new(GTK_WINDOW_TOPLEVEL); |
| ... | ... | |
| 209 | 228 |
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), |
| 210 | 229 |
GTK_POLICY_AUTOMATIC, |
| 211 | 230 |
GTK_POLICY_AUTOMATIC); |
| 231 |
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin), |
|
| 232 |
GTK_SHADOW_IN); |
|
| 212 | 233 |
|
| 213 |
title[0] = _("Enabled");
|
|
| 214 |
title[1] = _("Name");
|
|
| 215 |
clist = gtk_clist_new_with_titles(2, title); |
|
| 216 |
gtk_widget_show(clist); |
|
| 217 |
gtk_container_add (GTK_CONTAINER(scrolledwin), clist); |
|
| 218 |
gtk_clist_set_column_width(GTK_CLIST(clist), 0, 64); |
|
| 219 |
gtk_clist_set_column_justification(GTK_CLIST(clist), 0, |
|
| 220 |
GTK_JUSTIFY_CENTER); |
|
| 221 |
gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_BROWSE); |
|
| 222 |
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[0].button, |
|
| 223 |
GTK_CAN_FOCUS); |
|
| 224 |
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(clist)->column[1].button, |
|
| 225 |
GTK_CAN_FOCUS); |
|
| 226 |
g_signal_connect(G_OBJECT(clist), "select_row", |
|
| 227 |
G_CALLBACK(prefs_filter_select), NULL); |
|
| 228 |
g_signal_connect_after(G_OBJECT(clist), "row_move", |
|
| 229 |
G_CALLBACK(prefs_filter_row_move), NULL); |
|
| 234 |
store = gtk_list_store_new |
|
| 235 |
(N_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER); |
|
| 230 | 236 |
|
| 237 |
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); |
|
| 238 |
g_object_unref(G_OBJECT(store)); |
|
| 239 |
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE); |
|
| 240 |
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); |
|
| 241 |
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COL_NAME); |
|
| 242 |
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview), TRUE); |
|
| 243 |
|
|
| 244 |
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); |
|
| 245 |
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); |
|
| 246 |
gtk_tree_selection_set_select_function(selection, prefs_filter_select, |
|
| 247 |
NULL, NULL); |
|
| 248 |
|
|
| 249 |
renderer = gtk_cell_renderer_toggle_new(); |
|
| 250 |
g_signal_connect(renderer, "toggled", |
|
| 251 |
G_CALLBACK(prefs_filter_enable_toggled), NULL); |
|
| 252 |
column = gtk_tree_view_column_new_with_attributes |
|
| 253 |
(_("Enabled"), renderer, "active", COL_ENABLED, NULL);
|
|
| 254 |
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); |
|
| 255 |
|
|
| 256 |
renderer = gtk_cell_renderer_text_new(); |
|
| 257 |
column = gtk_tree_view_column_new_with_attributes |
|
| 258 |
(_("Name"), renderer, "text", COL_NAME, NULL);
|
|
| 259 |
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); |
|
| 260 |
|
|
| 261 |
gtk_widget_show(treeview); |
|
| 262 |
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview); |
|
| 263 |
|
|
| 264 |
g_signal_connect(G_OBJECT(treeview), "row-activated", |
|
| 265 |
G_CALLBACK(prefs_filter_row_activated), NULL); |
|
| 266 |
g_signal_connect_after(G_OBJECT(store), "rows-reordered", |
|
| 267 |
G_CALLBACK(prefs_filter_row_reordered), NULL); |
|
| 268 |
|
|
| 231 | 269 |
/* Up / Down */ |
| 232 | 270 |
|
| 233 | 271 |
btn_vbox = gtk_vbox_new (FALSE, 8); |
| ... | ... | |
| 298 | 336 |
|
| 299 | 337 |
gtk_widget_show_all(window); |
| 300 | 338 |
|
| 301 |
stock_pixmap_gdk(clist, STOCK_PIXMAP_MARK, &markxpm, &markxpmmask); |
|
| 302 |
|
|
| 303 | 339 |
rule_list_window.window = window; |
| 304 | 340 |
rule_list_window.close_btn = close_btn; |
| 305 | 341 |
|
| 306 |
rule_list_window.clist = clist; |
|
| 342 |
rule_list_window.treeview = treeview; |
|
| 343 |
rule_list_window.store = store; |
|
| 344 |
rule_list_window.selection = selection; |
|
| 307 | 345 |
|
| 308 |
rule_list_window.default_hdr_list = NULL; |
|
| 309 |
rule_list_window.user_hdr_list = NULL; |
|
| 310 |
rule_list_window.msg_hdr_list = NULL; |
|
| 346 |
rule_list_window.add_btn = add_btn; |
|
| 347 |
rule_list_window.edit_btn = edit_btn; |
|
| 348 |
rule_list_window.copy_btn = copy_btn; |
|
| 349 |
rule_list_window.del_btn = del_btn; |
|
| 350 |
|
|
| 351 |
rule_list_window.default_hdr_list = NULL; |
|
| 352 |
rule_list_window.user_hdr_list = NULL; |
|
| 353 |
rule_list_window.msg_hdr_list = NULL; |
|
| 311 | 354 |
rule_list_window.msg_hdr_table = NULL; |
| 312 | 355 |
} |
| 313 | 356 |
|
| ... | ... | |
| 391 | 434 |
|
| 392 | 435 |
static void prefs_filter_set_dialog(void) |
| 393 | 436 |
{
|
| 394 |
GtkCList *clist = GTK_CLIST(rule_list_window.clist); |
|
| 395 | 437 |
GSList *cur; |
| 396 | 438 |
|
| 397 |
gtk_clist_freeze(clist); |
|
| 398 |
gtk_clist_clear(clist); |
|
| 439 |
gtk_list_store_clear(rule_list_window.store); |
|
| 399 | 440 |
|
| 400 | 441 |
for (cur = prefs_common.fltlist; cur != NULL; cur = cur->next) {
|
| 401 | 442 |
FilterRule *rule = (FilterRule *)cur->data; |
| 402 |
prefs_filter_set_list_row(-1, rule, FALSE);
|
|
| 443 |
prefs_filter_set_list_row(NULL, rule, FALSE);
|
|
| 403 | 444 |
} |
| 404 |
|
|
| 405 |
gtk_clist_thaw(clist); |
|
| 406 | 445 |
} |
| 407 | 446 |
|
| 408 |
static void prefs_filter_set_list_row(gint row, FilterRule *rule,
|
|
| 447 |
static void prefs_filter_set_list_row(GtkTreeIter *iter, FilterRule *rule,
|
|
| 409 | 448 |
gboolean move_view) |
| 410 | 449 |
{
|
| 411 |
GtkCList *clist = GTK_CLIST(rule_list_window.clist); |
|
| 412 |
gchar *cond_str[2] = {"", NULL};
|
|
| 450 |
GtkListStore *store = rule_list_window.store; |
|
| 451 |
gchar *rule_name; |
|
| 452 |
GtkTreeIter iter_; |
|
| 413 | 453 |
|
| 414 |
if (!rule) |
|
| 415 |
rule = gtk_clist_get_row_data(clist, row); |
|
| 416 |
|
|
| 417 | 454 |
g_return_if_fail(rule != NULL); |
| 418 | 455 |
|
| 419 | 456 |
if (rule->name && *rule->name) |
| 420 |
cond_str[1] = g_strdup(rule->name); |
|
| 421 |
else {
|
|
| 422 |
cond_str[1] = filter_get_str(rule); |
|
| 423 |
} |
|
| 457 |
rule_name = g_strdup(rule->name); |
|
| 458 |
else |
|
| 459 |
rule_name = filter_get_str(rule); |
|
| 424 | 460 |
|
| 425 |
if (row < 0) |
|
| 426 |
row = gtk_clist_append(clist, cond_str); |
|
| 427 |
else {
|
|
| 428 |
FilterRule *prev_rule; |
|
| 461 |
if (!iter) {
|
|
| 462 |
gtk_list_store_append(store, &iter_); |
|
| 463 |
gtk_list_store_set(store, &iter_, |
|
| 464 |
COL_ENABLED, rule->enabled, |
|
| 465 |
COL_NAME, rule_name, |
|
| 466 |
COL_FILTER_RULE, rule, -1); |
|
| 467 |
} else {
|
|
| 468 |
FilterRule *prev_rule = NULL; |
|
| 429 | 469 |
|
| 430 |
prev_rule = gtk_clist_get_row_data(clist, row); |
|
| 431 |
if (rule == prev_rule) |
|
| 432 |
gtk_clist_set_text(clist, row, 1, cond_str[1]); |
|
| 433 |
else if (prev_rule) {
|
|
| 434 |
gtk_clist_set_text(clist, row, 1, cond_str[1]); |
|
| 470 |
iter_ = *iter; |
|
| 471 |
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter_, |
|
| 472 |
COL_FILTER_RULE, &prev_rule, -1); |
|
| 473 |
if (!prev_rule) {
|
|
| 474 |
g_warning("rule at the row not found\n");
|
|
| 475 |
gtk_list_store_append(store, &iter_); |
|
| 476 |
} |
|
| 477 |
|
|
| 478 |
gtk_list_store_set(store, &iter_, |
|
| 479 |
COL_ENABLED, rule->enabled, |
|
| 480 |
COL_NAME, rule_name, |
|
| 481 |
COL_FILTER_RULE, rule, -1); |
|
| 482 |
|
|
| 483 |
if (prev_rule && prev_rule != rule) |
|
| 435 | 484 |
filter_rule_free(prev_rule); |
| 436 |
} else |
|
| 437 |
row = gtk_clist_append(clist, cond_str); |
|
| 438 | 485 |
} |
| 439 | 486 |
|
| 440 |
if (rule->enabled) |
|
| 441 |
gtk_clist_set_pixmap(clist, row, 0, markxpm, markxpmmask); |
|
| 442 |
else |
|
| 443 |
gtk_clist_set_text(clist, row, 0, ""); |
|
| 487 |
g_free(rule_name); |
|
| 444 | 488 |
|
| 445 |
gtk_clist_set_row_data(clist, row, rule);
|
|
| 446 |
g_free(cond_str[1]);
|
|
| 489 |
if (move_view) {
|
|
| 490 |
GtkTreePath *path;
|
|
| 447 | 491 |
|
| 448 |
if (move_view && |
|
| 449 |
gtk_clist_row_is_visible(clist, row) != GTK_VISIBILITY_FULL) |
|
| 450 |
gtk_clist_moveto(clist, row, -1, 0.5, 0.0); |
|
| 492 |
path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter_); |
|
| 493 |
gtk_tree_view_scroll_to_cell |
|
| 494 |
(GTK_TREE_VIEW(rule_list_window.treeview), |
|
| 495 |
path, NULL, TRUE, 0.5, 0.0); |
|
| 496 |
gtk_tree_path_free(path); |
|
| 497 |
} |
|
| 451 | 498 |
} |
| 452 | 499 |
|
| 453 | 500 |
#define APPEND_HDR_LIST(hdr_list) \ |
| ... | ... | |
| 619 | 666 |
|
| 620 | 667 |
static void prefs_filter_set_list(void) |
| 621 | 668 |
{
|
| 622 |
gint row = 0; |
|
| 623 | 669 |
FilterRule *rule; |
| 670 |
GtkTreeIter iter; |
|
| 671 |
GtkTreeModel *model = GTK_TREE_MODEL(rule_list_window.store); |
|
| 624 | 672 |
|
| 625 | 673 |
g_slist_free(prefs_common.fltlist); |
| 626 | 674 |
prefs_common.fltlist = NULL; |
| 627 | 675 |
|
| 628 |
while ((rule = gtk_clist_get_row_data |
|
| 629 |
(GTK_CLIST(rule_list_window.clist), row)) != NULL) {
|
|
| 630 |
prefs_common.fltlist = g_slist_append(prefs_common.fltlist, |
|
| 631 |
rule); |
|
| 632 |
row++; |
|
| 633 |
} |
|
| 676 |
if (!gtk_tree_model_get_iter_first(model, &iter)) |
|
| 677 |
return; |
|
| 678 |
|
|
| 679 |
do {
|
|
| 680 |
gtk_tree_model_get(model, &iter, COL_FILTER_RULE, &rule, -1); |
|
| 681 |
if (rule) |
|
| 682 |
prefs_common.fltlist = |
|
| 683 |
g_slist_append(prefs_common.fltlist, rule); |
|
| 684 |
} while (gtk_tree_model_iter_next(model, &iter)); |
|
| 634 | 685 |
} |
| 635 | 686 |
|
| 636 | 687 |
static void prefs_filter_add_cb(void) |
| ... | ... | |
| 640 | 691 |
rule = prefs_filter_edit_open(NULL, NULL); |
| 641 | 692 |
|
| 642 | 693 |
if (rule) {
|
| 643 |
prefs_filter_set_list_row(-1, rule, TRUE);
|
|
| 694 |
prefs_filter_set_list_row(NULL, rule, TRUE);
|
|
| 644 | 695 |
prefs_filter_set_list(); |
| 645 | 696 |
} |
| 646 | 697 |
} |
| 647 | 698 |
|
| 648 | 699 |
static void prefs_filter_edit_cb(void) |
| 649 | 700 |
{
|
| 650 |
GtkCList *clist = GTK_CLIST(rule_list_window.clist);
|
|
| 701 |
GtkTreeIter iter;
|
|
| 651 | 702 |
FilterRule *rule, *new_rule; |
| 652 |
gint row; |
|
| 653 | 703 |
|
| 654 |
if (!clist->selection) return; |
|
| 704 |
if (!gtk_tree_selection_get_selected(rule_list_window.selection, |
|
| 705 |
NULL, &iter)) |
|
| 706 |
return; |
|
| 655 | 707 |
|
| 656 |
row = GPOINTER_TO_INT(clist->selection->data); |
|
| 657 |
|
|
| 658 |
rule = gtk_clist_get_row_data(clist, row); |
|
| 708 |
gtk_tree_model_get(GTK_TREE_MODEL(rule_list_window.store), &iter, |
|
| 709 |
COL_FILTER_RULE, &rule, -1); |
|
| 659 | 710 |
g_return_if_fail(rule != NULL); |
| 660 | 711 |
|
| 661 | 712 |
new_rule = prefs_filter_edit_open(rule, NULL); |
| 662 | 713 |
|
| 663 | 714 |
if (new_rule) {
|
| 664 |
prefs_filter_set_list_row(row, new_rule, TRUE);
|
|
| 715 |
prefs_filter_set_list_row(&iter, new_rule, TRUE);
|
|
| 665 | 716 |
prefs_filter_set_list(); |
| 666 | 717 |
} |
| 667 | 718 |
} |
| 668 | 719 |
|
| 669 | 720 |
static void prefs_filter_copy_cb(void) |
| 670 | 721 |
{
|
| 671 |
GtkCList *clist = GTK_CLIST(rule_list_window.clist);
|
|
| 722 |
GtkTreeIter iter;
|
|
| 672 | 723 |
FilterRule *rule, *new_rule; |
| 673 |
gint row; |
|
| 674 | 724 |
|
| 675 |
if (!clist->selection) return; |
|
| 725 |
if (!gtk_tree_selection_get_selected(rule_list_window.selection, |
|
| 726 |
NULL, &iter)) |
|
| 727 |
return; |
|
| 676 | 728 |
|
| 677 |
row = GPOINTER_TO_INT(clist->selection->data); |
|
| 678 |
|
|
| 679 |
rule = gtk_clist_get_row_data(clist, row); |
|
| 729 |
gtk_tree_model_get(GTK_TREE_MODEL(rule_list_window.store), &iter, |
|
| 730 |
COL_FILTER_RULE, &rule, -1); |
|
| 680 | 731 |
g_return_if_fail(rule != NULL); |
| 681 | 732 |
|
| 682 | 733 |
new_rule = prefs_filter_edit_open(rule, NULL); |
| 683 | 734 |
|
| 684 | 735 |
if (new_rule) {
|
| 685 |
prefs_filter_set_list_row(-1, new_rule, TRUE);
|
|
| 736 |
prefs_filter_set_list_row(NULL, new_rule, TRUE);
|
|
| 686 | 737 |
prefs_filter_set_list(); |
| 687 | 738 |
} |
| 688 | 739 |
} |
| 689 | 740 |
|
| 690 | 741 |
static void prefs_filter_delete_cb(void) |
| 691 | 742 |
{
|
| 692 |
GtkCList *clist = GTK_CLIST(rule_list_window.clist);
|
|
| 743 |
GtkTreeIter iter;
|
|
| 693 | 744 |
FilterRule *rule; |
| 694 |
gint row; |
|
| 745 |
gchar buf[BUFFSIZE]; |
|
| 746 |
gboolean valid; |
|
| 695 | 747 |
|
| 696 |
if (!clist->selection) return; |
|
| 697 |
row = GPOINTER_TO_INT(clist->selection->data); |
|
| 748 |
if (!gtk_tree_selection_get_selected(rule_list_window.selection, |
|
| 749 |
NULL, &iter)) |
|
| 750 |
return; |
|
| 698 | 751 |
|
| 699 |
if (alertpanel(_("Delete rule"),
|
|
| 700 |
_("Do you really want to delete this rule?"),
|
|
| 752 |
gtk_tree_model_get(GTK_TREE_MODEL(rule_list_window.store), &iter, |
|
| 753 |
COL_FILTER_RULE, &rule, -1); |
|
| 754 |
g_return_if_fail(rule != NULL); |
|
| 755 |
|
|
| 756 |
g_snprintf(buf, sizeof(buf), |
|
| 757 |
_("Do you really want to delete the rule '%s'?"),
|
|
| 758 |
rule->name ? rule->name : _("(Untitled)"));
|
|
| 759 |
if (alertpanel(_("Delete rule"), buf,
|
|
| 701 | 760 |
GTK_STOCK_YES, GTK_STOCK_NO, NULL) != G_ALERTDEFAULT) |
| 702 | 761 |
return; |
| 703 | 762 |
|
| 704 |
rule = gtk_clist_get_row_data(clist, row); |
|
| 763 |
valid = gtk_list_store_remove(rule_list_window.store, &iter); |
|
| 764 |
if (valid) |
|
| 765 |
gtk_tree_selection_select_iter(rule_list_window.selection, |
|
| 766 |
&iter); |
|
| 767 |
|
|
| 768 |
prefs_common.fltlist = g_slist_remove(prefs_common.fltlist, rule); |
|
| 705 | 769 |
filter_rule_free(rule); |
| 706 |
gtk_clist_remove(clist, row); |
|
| 707 |
prefs_common.fltlist = g_slist_remove(prefs_common.fltlist, rule); |
|
| 708 |
if (!clist->selection) |
|
| 709 |
gtk_clist_select_row(clist, row - 1, -1); |
|
| 710 | 770 |
} |
| 711 | 771 |
|
| 712 | 772 |
static void prefs_filter_top(void) |
| 713 | 773 |
{
|
| 714 |
GtkCList *clist = GTK_CLIST(rule_list_window.clist); |
|
| 715 |
gint row; |
|
| 774 |
GtkTreeIter iter; |
|
| 716 | 775 |
|
| 717 |
if (!clist->selection) return; |
|
| 776 |
if (!gtk_tree_selection_get_selected(rule_list_window.selection, |
|
| 777 |
NULL, &iter)) |
|
| 778 |
return; |
|
| 718 | 779 |
|
| 719 |
row = GPOINTER_TO_INT(clist->selection->data); |
|
| 720 |
if (row > 0) |
|
| 721 |
gtk_clist_row_move(clist, row, 0); |
|
| 780 |
gtk_list_store_move_after(rule_list_window.store, &iter, NULL); |
|
| 722 | 781 |
} |
| 723 | 782 |
|
| 724 | 783 |
static void prefs_filter_up(void) |
| 725 | 784 |
{
|
| 726 |
GtkCList *clist = GTK_CLIST(rule_list_window.clist); |
|
| 727 |
gint row; |
|
| 785 |
GtkTreeModel *model = GTK_TREE_MODEL(rule_list_window.store); |
|
| 786 |
GtkTreeIter iter, prev; |
|
| 787 |
GtkTreePath *path; |
|
| 728 | 788 |
|
| 729 |
if (!clist->selection) return; |
|
| 789 |
if (!gtk_tree_selection_get_selected(rule_list_window.selection, |
|
| 790 |
NULL, &iter)) |
|
| 791 |
return; |
|
| 730 | 792 |
|
| 731 |
row = GPOINTER_TO_INT(clist->selection->data); |
|
| 732 |
if (row > 0) |
|
| 733 |
gtk_clist_row_move(clist, row, row - 1); |
|
| 793 |
path = gtk_tree_model_get_path(model, &iter); |
|
| 794 |
if (gtk_tree_path_prev(path)) {
|
|
| 795 |
gtk_tree_model_get_iter(model, &prev, path); |
|
| 796 |
gtk_list_store_swap(rule_list_window.store, &iter, &prev); |
|
| 797 |
} |
|
| 798 |
gtk_tree_path_free(path); |
|
| 734 | 799 |
} |
| 735 | 800 |
|
| 736 | 801 |
static void prefs_filter_down(void) |
| 737 | 802 |
{
|
| 738 |
GtkCList *clist = GTK_CLIST(rule_list_window.clist); |
|
| 739 |
gint row; |
|
| 803 |
GtkTreeIter iter, next; |
|
| 740 | 804 |
|
| 741 |
if (!clist->selection) return; |
|
| 805 |
if (!gtk_tree_selection_get_selected(rule_list_window.selection, |
|
| 806 |
NULL, &iter)) |
|
| 807 |
return; |
|
| 742 | 808 |
|
| 743 |
row = GPOINTER_TO_INT(clist->selection->data); |
|
| 744 |
if (row < clist->rows - 1) |
|
| 745 |
gtk_clist_row_move(clist, row, row + 1); |
|
| 809 |
next = iter; |
|
| 810 |
if (gtk_tree_model_iter_next(GTK_TREE_MODEL(rule_list_window.store), |
|
| 811 |
&next)) |
|
| 812 |
gtk_list_store_swap(rule_list_window.store, &iter, &next); |
|
| 746 | 813 |
} |
| 747 | 814 |
|
| 748 | 815 |
static void prefs_filter_bottom(void) |
| 749 | 816 |
{
|
| 750 |
GtkCList *clist = GTK_CLIST(rule_list_window.clist); |
|
| 751 |
gint row; |
|
| 817 |
GtkTreeIter iter; |
|
| 752 | 818 |
|
| 753 |
if (!clist->selection) return; |
|
| 819 |
if (!gtk_tree_selection_get_selected(rule_list_window.selection, |
|
| 820 |
NULL, &iter)) |
|
| 821 |
return; |
|
| 754 | 822 |
|
| 755 |
row = GPOINTER_TO_INT(clist->selection->data); |
|
| 756 |
if (row < clist->rows - 1) |
|
| 757 |
gtk_clist_row_move(clist, row, clist->rows - 1); |
|
| 823 |
gtk_list_store_move_before(rule_list_window.store, &iter, NULL); |
|
| 758 | 824 |
} |
| 759 | 825 |
|
| 760 |
static void prefs_filter_select(GtkCList *clist, gint row, gint column, |
|
| 761 |
GdkEvent *event) |
|
| 826 |
static gboolean prefs_filter_select(GtkTreeSelection *selection, |
|
| 827 |
GtkTreeModel *model, GtkTreePath *path, |
|
| 828 |
gboolean cur_selected, gpointer data) |
|
| 762 | 829 |
{
|
| 763 |
if (event && event->type == GDK_2BUTTON_PRESS) {
|
|
| 764 |
prefs_filter_edit_cb(); |
|
| 765 |
return; |
|
| 766 |
} |
|
| 830 |
return TRUE; |
|
| 831 |
} |
|
| 767 | 832 |
|
| 768 |
if (column == 0) {
|
|
| 769 |
FilterRule *rule; |
|
| 770 |
rule = gtk_clist_get_row_data(clist, row); |
|
| 771 |
rule->enabled ^= TRUE; |
|
| 772 |
prefs_filter_set_list_row(row, rule, FALSE); |
|
| 773 |
} |
|
| 833 |
static void prefs_filter_enable_toggled(GtkCellRenderer *cell, gchar *path_str, |
|
| 834 |
gpointer data) |
|
| 835 |
{
|
|
| 836 |
FilterRule *rule; |
|
| 837 |
GtkTreeIter iter; |
|
| 838 |
GtkTreePath *path; |
|
| 839 |
|
|
| 840 |
path = gtk_tree_path_new_from_string(path_str); |
|
| 841 |
gtk_tree_model_get_iter(GTK_TREE_MODEL(rule_list_window.store), |
|
| 842 |
&iter, path); |
|
| 843 |
gtk_tree_path_free(path); |
|
| 844 |
gtk_tree_model_get(GTK_TREE_MODEL(rule_list_window.store), &iter, |
|
| 845 |
COL_FILTER_RULE, &rule, -1); |
|
| 846 |
|
|
| 847 |
rule->enabled ^= TRUE; |
|
| 848 |
|
|
| 849 |
gtk_list_store_set(rule_list_window.store, &iter, |
|
| 850 |
COL_ENABLED, rule->enabled, -1); |
|
| 774 | 851 |
} |
| 775 | 852 |
|
| 776 |
static void prefs_filter_row_move(GtkCList *clist, gint source_row, |
|
| 777 |
gint dest_row) |
|
| 853 |
static void prefs_filter_row_activated(GtkTreeView *treeview, GtkTreePath *path, |
|
| 854 |
GtkTreeViewColumn *column, |
|
| 855 |
gpointer data) |
|
| 778 | 856 |
{
|
| 779 |
prefs_filter_set_list(); |
|
| 780 |
if (gtk_clist_row_is_visible(clist, dest_row) != GTK_VISIBILITY_FULL) |
|
| 781 |
gtk_clist_moveto(clist, dest_row, -1, 0.5, 0.0); |
|
| 857 |
gtk_button_clicked(GTK_BUTTON(rule_list_window.edit_btn)); |
|
| 782 | 858 |
} |
| 783 | 859 |
|
| 860 |
static void prefs_filter_row_reordered(GtkTreeModel *model, |
|
| 861 |
GtkTreePath *path, GtkTreeIter *iter, |
|
| 862 |
gpointer data, gpointer user_data) |
|
| 863 |
{
|
|
| 864 |
GtkTreeIter iter_; |
|
| 865 |
GtkTreePath *path_; |
|
| 866 |
|
|
| 867 |
if (!gtk_tree_selection_get_selected(rule_list_window.selection, |
|
| 868 |
NULL, &iter_)) |
|
| 869 |
return; |
|
| 870 |
path_ = gtk_tree_model_get_path |
|
| 871 |
(GTK_TREE_MODEL(rule_list_window.store), &iter_); |
|
| 872 |
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(rule_list_window.treeview), |
|
| 873 |
path_, NULL, FALSE, 0.0, 0.0); |
|
| 874 |
gtk_tree_path_free(path_); |
|
| 875 |
} |
|
| 876 |
|
|
| 784 | 877 |
static gint prefs_filter_deleted(GtkWidget *widget, GdkEventAny *event, |
| 785 | 878 |
gpointer data) |
| 786 | 879 |
{
|
| ... | ... | |
| 800 | 893 |
{
|
| 801 | 894 |
prefs_filter_set_msg_header_list(NULL); |
| 802 | 895 |
prefs_filter_write_user_header_list(); |
| 896 |
prefs_filter_set_list(); |
|
| 803 | 897 |
filter_write_config(prefs_common.fltlist); |
| 804 | 898 |
gtk_widget_hide(rule_list_window.window); |
| 805 |
gtk_clist_clear(GTK_CLIST(rule_list_window.clist));
|
|
| 899 |
gtk_list_store_clear(rule_list_window.store);
|
|
| 806 | 900 |
inc_unlock(); |
| 807 | 901 |
} |
Also available in: Unified diff