Revision 2767
| libsylph/filter.c (revision 2767) | ||
|---|---|---|
| 1453 | 1453 |
return fltinfo; |
| 1454 | 1454 |
} |
| 1455 | 1455 |
|
| 1456 |
FilterRule *filter_junk_rule_create(PrefsAccount *account, |
|
| 1457 |
FolderItem *default_junk, |
|
| 1458 |
gboolean is_manual) |
|
| 1459 |
{
|
|
| 1460 |
FilterRule *rule; |
|
| 1461 |
FilterCond *cond; |
|
| 1462 |
FilterAction *action; |
|
| 1463 |
GSList *cond_list = NULL, *action_list = NULL; |
|
| 1464 |
gchar *junk_id = NULL; |
|
| 1465 |
FolderItem *item = NULL; |
|
| 1466 |
|
|
| 1467 |
if (!prefs_common.junk_classify_cmd) |
|
| 1468 |
return NULL; |
|
| 1469 |
|
|
| 1470 |
if (prefs_common.junk_folder) |
|
| 1471 |
item = folder_find_item_from_identifier(prefs_common.junk_folder); |
|
| 1472 |
|
|
| 1473 |
if (!item && account) {
|
|
| 1474 |
Folder *folder = NULL; |
|
| 1475 |
GList *list; |
|
| 1476 |
|
|
| 1477 |
/* find most suitable Junk folder for account */ |
|
| 1478 |
|
|
| 1479 |
if (account->inbox && *account->inbox == '#') {
|
|
| 1480 |
FolderItem *inbox; |
|
| 1481 |
inbox = folder_find_item_from_identifier(account->inbox); |
|
| 1482 |
if (inbox) {
|
|
| 1483 |
folder = inbox->folder; |
|
| 1484 |
if (folder) |
|
| 1485 |
item = folder_get_junk(folder); |
|
| 1486 |
} |
|
| 1487 |
} |
|
| 1488 |
if (!item) {
|
|
| 1489 |
folder = FOLDER(account->folder); |
|
| 1490 |
if (folder) |
|
| 1491 |
item = folder_get_junk(folder); |
|
| 1492 |
} |
|
| 1493 |
if (!item) {
|
|
| 1494 |
for (list = folder_get_list(); list != NULL; list = list->next) {
|
|
| 1495 |
folder = FOLDER(list->data); |
|
| 1496 |
if (FOLDER_IS_LOCAL(folder)) {
|
|
| 1497 |
if (folder->account == account) |
|
| 1498 |
item = folder_get_junk(folder); |
|
| 1499 |
if (!item && folder->node) {
|
|
| 1500 |
item = FOLDER_ITEM(folder->node->data); |
|
| 1501 |
if (item && item->account == account && item->folder) |
|
| 1502 |
item = folder_get_junk(item->folder); |
|
| 1503 |
else |
|
| 1504 |
item = NULL; |
|
| 1505 |
} |
|
| 1506 |
} |
|
| 1507 |
if (item) |
|
| 1508 |
break; |
|
| 1509 |
} |
|
| 1510 |
} |
|
| 1511 |
} |
|
| 1512 |
|
|
| 1513 |
if (!item) |
|
| 1514 |
item = default_junk; |
|
| 1515 |
if (!item) |
|
| 1516 |
item = folder_get_default_junk(); |
|
| 1517 |
if (!item) |
|
| 1518 |
return NULL; |
|
| 1519 |
junk_id = folder_item_get_identifier(item); |
|
| 1520 |
if (!junk_id) |
|
| 1521 |
return NULL; |
|
| 1522 |
|
|
| 1523 |
debug_print("filter_junk_rule_create: junk folder: %s\n",
|
|
| 1524 |
junk_id); |
|
| 1525 |
|
|
| 1526 |
cond = filter_cond_new(FLT_COND_CMD_TEST, 0, 0, NULL, |
|
| 1527 |
prefs_common.junk_classify_cmd); |
|
| 1528 |
cond_list = g_slist_append(NULL, cond); |
|
| 1529 |
if (prefs_common.delete_junk_on_recv && !is_manual) {
|
|
| 1530 |
action = filter_action_new(FLT_ACTION_COPY, junk_id); |
|
| 1531 |
action_list = g_slist_append(NULL, action); |
|
| 1532 |
action = filter_action_new(FLT_ACTION_DELETE, NULL); |
|
| 1533 |
action_list = g_slist_append(action_list, action); |
|
| 1534 |
} else {
|
|
| 1535 |
action = filter_action_new(FLT_ACTION_MOVE, junk_id); |
|
| 1536 |
action_list = g_slist_append(NULL, action); |
|
| 1537 |
} |
|
| 1538 |
|
|
| 1539 |
if (prefs_common.mark_junk_as_read) {
|
|
| 1540 |
action = filter_action_new(FLT_ACTION_MARK_READ, NULL); |
|
| 1541 |
action_list = g_slist_append(action_list, action); |
|
| 1542 |
} |
|
| 1543 |
|
|
| 1544 |
if (is_manual) |
|
| 1545 |
rule = filter_rule_new(_("Junk mail filter (manual)"), FLT_OR,
|
|
| 1546 |
cond_list, action_list); |
|
| 1547 |
else |
|
| 1548 |
rule = filter_rule_new(_("Junk mail filter"), FLT_OR,
|
|
| 1549 |
cond_list, action_list); |
|
| 1550 |
|
|
| 1551 |
g_free(junk_id); |
|
| 1552 |
|
|
| 1553 |
return rule; |
|
| 1554 |
} |
|
| 1555 |
|
|
| 1456 | 1556 |
void filter_rule_rename_dest_path(FilterRule *rule, const gchar *old_path, |
| 1457 | 1557 |
const gchar *new_path) |
| 1458 | 1558 |
{
|
| libsylph/prefs_common.c (revision 2767) | ||
|---|---|---|
| 566 | 566 |
g_free(path); |
| 567 | 567 |
} |
| 568 | 568 |
|
| 569 |
static FilterRule *prefs_common_junk_filter_rule_create(gboolean is_manual) |
|
| 570 |
{
|
|
| 571 |
FilterRule *rule; |
|
| 572 |
FilterCond *cond; |
|
| 573 |
FilterAction *action; |
|
| 574 |
GSList *cond_list = NULL, *action_list = NULL; |
|
| 575 |
gchar *junk_id; |
|
| 576 |
|
|
| 577 |
if (prefs_common.junk_folder) |
|
| 578 |
junk_id = g_strdup(prefs_common.junk_folder); |
|
| 579 |
else {
|
|
| 580 |
FolderItem *item; |
|
| 581 |
item = folder_get_default_junk(); |
|
| 582 |
if (!item) |
|
| 583 |
return NULL; |
|
| 584 |
junk_id = folder_item_get_identifier(item); |
|
| 585 |
if (!junk_id) |
|
| 586 |
return NULL; |
|
| 587 |
} |
|
| 588 |
|
|
| 589 |
debug_print("prefs_common_junk_filter_rule_create: junk folder: %s\n",
|
|
| 590 |
junk_id); |
|
| 591 |
|
|
| 592 |
cond = filter_cond_new(FLT_COND_CMD_TEST, 0, 0, NULL, |
|
| 593 |
prefs_common.junk_classify_cmd); |
|
| 594 |
cond_list = g_slist_append(NULL, cond); |
|
| 595 |
if (prefs_common.delete_junk_on_recv && !is_manual) {
|
|
| 596 |
action = filter_action_new(FLT_ACTION_COPY, junk_id); |
|
| 597 |
action_list = g_slist_append(NULL, action); |
|
| 598 |
action = filter_action_new(FLT_ACTION_DELETE, NULL); |
|
| 599 |
action_list = g_slist_append(action_list, action); |
|
| 600 |
} else {
|
|
| 601 |
action = filter_action_new(FLT_ACTION_MOVE, junk_id); |
|
| 602 |
action_list = g_slist_append(NULL, action); |
|
| 603 |
} |
|
| 604 |
|
|
| 605 |
if (prefs_common.mark_junk_as_read) {
|
|
| 606 |
action = filter_action_new(FLT_ACTION_MARK_READ, NULL); |
|
| 607 |
action_list = g_slist_append(action_list, action); |
|
| 608 |
} |
|
| 609 |
|
|
| 610 |
if (is_manual) |
|
| 611 |
rule = filter_rule_new(_("Junk mail filter (manual)"), FLT_OR,
|
|
| 612 |
cond_list, action_list); |
|
| 613 |
else |
|
| 614 |
rule = filter_rule_new(_("Junk mail filter"), FLT_OR,
|
|
| 615 |
cond_list, action_list); |
|
| 616 |
|
|
| 617 |
g_free(junk_id); |
|
| 618 |
|
|
| 619 |
return rule; |
|
| 620 |
} |
|
| 621 |
|
|
| 622 | 569 |
void prefs_common_junk_filter_list_set(void) |
| 623 | 570 |
{
|
| 624 |
FilterRule *rule; |
|
| 625 |
|
|
| 626 |
debug_print("prefs_common_junk_filter_list_set\n");
|
|
| 627 |
|
|
| 628 |
if (prefs_common.junk_fltlist) {
|
|
| 629 |
filter_rule_list_free(prefs_common.junk_fltlist); |
|
| 630 |
prefs_common.junk_fltlist = NULL; |
|
| 631 |
} |
|
| 632 |
if (prefs_common.manual_junk_fltlist) {
|
|
| 633 |
filter_rule_list_free(prefs_common.manual_junk_fltlist); |
|
| 634 |
prefs_common.manual_junk_fltlist = NULL; |
|
| 635 |
} |
|
| 636 |
|
|
| 637 |
if (!prefs_common.junk_classify_cmd) |
|
| 638 |
return; |
|
| 639 |
|
|
| 640 |
rule = prefs_common_junk_filter_rule_create(FALSE); |
|
| 641 |
if (!rule) |
|
| 642 |
return; |
|
| 643 |
prefs_common.junk_fltlist = g_slist_append(NULL, rule); |
|
| 644 |
|
|
| 645 |
rule = prefs_common_junk_filter_rule_create(TRUE); |
|
| 646 |
if (!rule) |
|
| 647 |
return; |
|
| 648 |
prefs_common.manual_junk_fltlist = g_slist_append(NULL, rule); |
|
| 649 | 571 |
} |
| 650 | 572 |
|
| 651 | 573 |
void prefs_common_junk_folder_rename_path(const gchar *old_path, |
| ... | ... | |
| 677 | 599 |
dest_path); |
| 678 | 600 |
g_free(prefs_common.junk_folder); |
| 679 | 601 |
prefs_common.junk_folder = dest_path; |
| 680 |
prefs_common_junk_filter_list_set(); |
|
| 681 | 602 |
} |
| 682 | 603 |
} |
| libsylph/filter.h (revision 2767) | ||
|---|---|---|
| 213 | 213 |
const gchar *str); |
| 214 | 214 |
FilterInfo *filter_info_new (void); |
| 215 | 215 |
|
| 216 |
FilterRule *filter_junk_rule_create (PrefsAccount *account, |
|
| 217 |
FolderItem *default_junk, |
|
| 218 |
gboolean is_manual); |
|
| 219 |
|
|
| 216 | 220 |
void filter_rule_rename_dest_path (FilterRule *rule, |
| 217 | 221 |
const gchar *old_path, |
| 218 | 222 |
const gchar *new_path); |
| libsylph/prefs_common.h (revision 2767) | ||
|---|---|---|
| 300 | 300 |
|
| 301 | 301 |
/* Filtering */ |
| 302 | 302 |
GSList *fltlist; |
| 303 |
|
|
| 304 |
/* deprecated: do not use */ |
|
| 303 | 305 |
GSList *junk_fltlist; |
| 304 | 306 |
GSList *manual_junk_fltlist; |
| 305 | 307 |
|
| ... | ... | |
| 333 | 335 |
void prefs_common_read_config (void); |
| 334 | 336 |
void prefs_common_write_config (void); |
| 335 | 337 |
|
| 338 |
/* deprecated */ |
|
| 336 | 339 |
void prefs_common_junk_filter_list_set (void); |
| 340 |
|
|
| 337 | 341 |
void prefs_common_junk_folder_rename_path (const gchar *old_path, |
| 338 | 342 |
const gchar *new_path); |
| 339 | 343 |
|
| libsylph/libsylph-0.def (revision 2767) | ||
|---|---|---|
| 693 | 693 |
socks4_connect @ 691 |
| 694 | 694 |
socks5_connect @ 692 |
| 695 | 695 |
folder_remote_folder_destroy_all_sessions @ 693 |
| 696 |
filter_junk_rule_create @ 694 |
|
| libsylph/mbox.c (revision 2767) | ||
|---|---|---|
| 73 | 73 |
gint new_msgs = 0; |
| 74 | 74 |
gint count = 0; |
| 75 | 75 |
Folder *folder; |
| 76 |
FilterRule *junk_rule = NULL; |
|
| 77 |
GSList junk_fltlist = {NULL, NULL};
|
|
| 78 |
FolderItem *junk; |
|
| 76 | 79 |
|
| 77 | 80 |
g_return_val_if_fail(dest != NULL, -1); |
| 78 | 81 |
g_return_val_if_fail(dest->folder != NULL, -1); |
| ... | ... | |
| 111 | 114 |
|
| 112 | 115 |
tmp_file = get_tmp_file(); |
| 113 | 116 |
|
| 117 |
if (filter_junk) {
|
|
| 118 |
junk = folder_get_junk(folder); |
|
| 119 |
junk_rule = filter_junk_rule_create(NULL, junk, FALSE); |
|
| 120 |
junk_fltlist.data = junk_rule; |
|
| 121 |
} |
|
| 122 |
|
|
| 114 | 123 |
do {
|
| 115 | 124 |
FILE *tmp_fp; |
| 116 | 125 |
GSList *cur; |
| ... | ... | |
| 128 | 137 |
if ((tmp_fp = g_fopen(tmp_file, "wb")) == NULL) {
|
| 129 | 138 |
FILE_OP_ERROR(tmp_file, "fopen"); |
| 130 | 139 |
g_warning(_("can't open temporary file\n"));
|
| 140 |
filter_rule_free(junk_rule); |
|
| 131 | 141 |
g_free(tmp_file); |
| 132 | 142 |
fclose(mbox_fp); |
| 133 | 143 |
return -1; |
| ... | ... | |
| 214 | 224 |
if (fclose(tmp_fp) == EOF) {
|
| 215 | 225 |
FILE_OP_ERROR(tmp_file, "fclose"); |
| 216 | 226 |
g_warning(_("can't write to temporary file\n"));
|
| 227 |
filter_rule_free(junk_rule); |
|
| 217 | 228 |
g_unlink(tmp_file); |
| 218 | 229 |
g_free(tmp_file); |
| 219 | 230 |
fclose(mbox_fp); |
| ... | ... | |
| 229 | 240 |
if (!msginfo) {
|
| 230 | 241 |
g_warning("proc_mbox_full: procheader_parse_file failed");
|
| 231 | 242 |
filter_info_free(fltinfo); |
| 243 |
filter_rule_free(junk_rule); |
|
| 232 | 244 |
g_unlink(tmp_file); |
| 233 | 245 |
g_free(tmp_file); |
| 234 | 246 |
fclose(mbox_fp); |
| ... | ... | |
| 238 | 250 |
msginfo->file_path = g_strdup(tmp_file); |
| 239 | 251 |
|
| 240 | 252 |
if (filter_junk && prefs_common.enable_junk && |
| 241 |
prefs_common.filter_junk_before) {
|
|
| 242 |
filter_apply_msginfo(prefs_common.junk_fltlist, msginfo, |
|
| 243 |
fltinfo); |
|
| 253 |
prefs_common.filter_junk_before && junk_rule) {
|
|
| 254 |
filter_apply_msginfo(&junk_fltlist, msginfo, fltinfo); |
|
| 244 | 255 |
if (fltinfo->drop_done) |
| 245 | 256 |
is_junk = TRUE; |
| 246 | 257 |
} |
| ... | ... | |
| 251 | 262 |
|
| 252 | 263 |
if (!fltinfo->drop_done && |
| 253 | 264 |
filter_junk && prefs_common.enable_junk && |
| 254 |
!prefs_common.filter_junk_before) {
|
|
| 255 |
filter_apply_msginfo(prefs_common.junk_fltlist, msginfo, |
|
| 256 |
fltinfo); |
|
| 265 |
!prefs_common.filter_junk_before && junk_rule) {
|
|
| 266 |
filter_apply_msginfo(&junk_fltlist, msginfo, fltinfo); |
|
| 257 | 267 |
if (fltinfo->drop_done) |
| 258 | 268 |
is_junk = TRUE; |
| 259 | 269 |
} |
| ... | ... | |
| 264 | 274 |
if (folder_item_add_msg_msginfo(dest, msginfo, FALSE) < 0) {
|
| 265 | 275 |
procmsg_msginfo_free(msginfo); |
| 266 | 276 |
filter_info_free(fltinfo); |
| 277 |
filter_rule_free(junk_rule); |
|
| 267 | 278 |
g_unlink(tmp_file); |
| 268 | 279 |
g_free(tmp_file); |
| 269 | 280 |
fclose(mbox_fp); |
| ... | ... | |
| 301 | 312 |
g_unlink(tmp_file); |
| 302 | 313 |
} while (from_line[0] != '\0'); |
| 303 | 314 |
|
| 315 |
if (junk_rule) |
|
| 316 |
filter_rule_free(junk_rule); |
|
| 317 |
|
|
| 304 | 318 |
g_free(tmp_file); |
| 305 | 319 |
fclose(mbox_fp); |
| 306 | 320 |
debug_print("%d new messages found.\n", new_msgs);
|
| src/inc.c (revision 2767) | ||
|---|---|---|
| 253 | 253 |
FolderItem *inbox = FOLDER(account->folder)->inbox; |
| 254 | 254 |
GSList *mlist, *cur; |
| 255 | 255 |
FilterInfo *fltinfo; |
| 256 |
GSList junk_fltlist = {NULL, NULL};
|
|
| 257 |
FilterRule *junk_rule; |
|
| 256 | 258 |
gint n_filtered = 0; |
| 257 | 259 |
|
| 258 | 260 |
debug_print("inc_remote_account_mail(): filtering IMAP4 INBOX\n");
|
| 259 | 261 |
mlist = folder_item_get_uncached_msg_list(inbox); |
| 260 | 262 |
debug_print("inc_remote_account_mail(): uncached messages: %d\n", g_slist_length(mlist));
|
| 261 | 263 |
|
| 264 |
junk_rule = filter_junk_rule_create(account, NULL, TRUE); |
|
| 265 |
if (junk_rule) |
|
| 266 |
junk_fltlist.data = junk_rule; |
|
| 267 |
|
|
| 262 | 268 |
for (cur = mlist; cur != NULL; cur = cur->next) {
|
| 263 | 269 |
MsgInfo *msginfo = (MsgInfo *)cur->data; |
| 264 | 270 |
|
| ... | ... | |
| 268 | 274 |
|
| 269 | 275 |
if (prefs_common.enable_junk && |
| 270 | 276 |
prefs_common.filter_junk_on_recv && |
| 271 |
prefs_common.filter_junk_before) {
|
|
| 277 |
prefs_common.filter_junk_before && junk_rule) {
|
|
| 272 | 278 |
filter_apply_msginfo |
| 273 |
(prefs_common.manual_junk_fltlist, |
|
| 274 |
msginfo, fltinfo); |
|
| 279 |
(&junk_fltlist, msginfo, fltinfo); |
|
| 275 | 280 |
} |
| 276 | 281 |
|
| 277 | 282 |
if (!fltinfo->drop_done) {
|
| ... | ... | |
| 282 | 287 |
if (!fltinfo->drop_done && |
| 283 | 288 |
prefs_common.enable_junk && |
| 284 | 289 |
prefs_common.filter_junk_on_recv && |
| 285 |
!prefs_common.filter_junk_before) {
|
|
| 290 |
!prefs_common.filter_junk_before && junk_rule) {
|
|
| 286 | 291 |
filter_apply_msginfo |
| 287 |
(prefs_common.manual_junk_fltlist, |
|
| 288 |
msginfo, fltinfo); |
|
| 292 |
(&junk_fltlist, msginfo, fltinfo); |
|
| 289 | 293 |
} |
| 290 | 294 |
|
| 291 | 295 |
if (msginfo->flags.perm_flags != |
| ... | ... | |
| 323 | 327 |
filter_info_free(fltinfo); |
| 324 | 328 |
} |
| 325 | 329 |
|
| 330 |
if (junk_rule) |
|
| 331 |
filter_rule_free(junk_rule); |
|
| 332 |
|
|
| 326 | 333 |
procmsg_msg_list_free(mlist); |
| 327 | 334 |
|
| 328 | 335 |
debug_print("inc_remote_account_mail(): INBOX: %d new, %d filtered\n",
|
| ... | ... | |
| 585 | 592 |
static IncSession *inc_session_new(PrefsAccount *account) |
| 586 | 593 |
{
|
| 587 | 594 |
IncSession *session; |
| 595 |
FilterRule *rule; |
|
| 588 | 596 |
|
| 589 | 597 |
g_return_val_if_fail(account != NULL, NULL); |
| 590 | 598 |
|
| ... | ... | |
| 611 | 619 |
session->folder_table = g_hash_table_new(NULL, NULL); |
| 612 | 620 |
session->tmp_folder_table = g_hash_table_new(NULL, NULL); |
| 613 | 621 |
|
| 622 |
rule = filter_junk_rule_create(account, NULL, FALSE); |
|
| 623 |
if (rule) |
|
| 624 |
session->junk_fltlist = g_slist_append(NULL, rule); |
|
| 625 |
else |
|
| 626 |
session->junk_fltlist = NULL; |
|
| 627 |
|
|
| 614 | 628 |
session->cur_total_bytes = 0; |
| 615 | 629 |
session->new_msgs = 0; |
| 616 | 630 |
|
| ... | ... | |
| 629 | 643 |
session_destroy(session->session); |
| 630 | 644 |
g_hash_table_destroy(session->folder_table); |
| 631 | 645 |
g_hash_table_destroy(session->tmp_folder_table); |
| 646 |
if (session->junk_fltlist) |
|
| 647 |
filter_rule_list_free(session->junk_fltlist); |
|
| 632 | 648 |
g_free(session); |
| 633 | 649 |
} |
| 634 | 650 |
|
| ... | ... | |
| 1283 | 1299 |
|
| 1284 | 1300 |
if (prefs_common.enable_junk && |
| 1285 | 1301 |
prefs_common.filter_junk_on_recv && |
| 1286 |
prefs_common.filter_junk_before) {
|
|
| 1287 |
filter_apply_msginfo(prefs_common.junk_fltlist, msginfo, |
|
| 1302 |
prefs_common.filter_junk_before && |
|
| 1303 |
inc_session->junk_fltlist) {
|
|
| 1304 |
filter_apply_msginfo(inc_session->junk_fltlist, msginfo, |
|
| 1288 | 1305 |
fltinfo); |
| 1289 | 1306 |
if (fltinfo->drop_done) |
| 1290 | 1307 |
is_junk = TRUE; |
| ... | ... | |
| 1306 | 1323 |
if (!fltinfo->drop_done) {
|
| 1307 | 1324 |
if (prefs_common.enable_junk && |
| 1308 | 1325 |
prefs_common.filter_junk_on_recv && |
| 1309 |
!prefs_common.filter_junk_before) {
|
|
| 1310 |
filter_apply_msginfo(prefs_common.junk_fltlist, |
|
| 1326 |
!prefs_common.filter_junk_before && |
|
| 1327 |
inc_session->junk_fltlist) {
|
|
| 1328 |
filter_apply_msginfo(inc_session->junk_fltlist, |
|
| 1311 | 1329 |
msginfo, fltinfo); |
| 1312 | 1330 |
if (fltinfo->drop_done) |
| 1313 | 1331 |
is_junk = TRUE; |
| src/inc.h (revision 2767) | ||
|---|---|---|
| 73 | 73 |
GHashTable *folder_table; /* table of destination folders */ |
| 74 | 74 |
GHashTable *tmp_folder_table; /* for progressive update */ |
| 75 | 75 |
|
| 76 |
GSList *junk_fltlist; |
|
| 77 |
|
|
| 76 | 78 |
gint64 cur_total_bytes; |
| 77 | 79 |
gint new_msgs; |
| 78 | 80 |
|
| src/main.c (revision 2767) | ||
|---|---|---|
| 349 | 349 |
new_account = setup_account(); |
| 350 | 350 |
} |
| 351 | 351 |
|
| 352 |
prefs_common_junk_filter_list_set(); |
|
| 353 |
|
|
| 354 | 352 |
account_set_menu(); |
| 355 | 353 |
main_window_reflect_prefs_all(); |
| 356 | 354 |
|
| src/summaryview.c (revision 2767) | ||
|---|---|---|
| 4643 | 4643 |
|
| 4644 | 4644 |
fltinfo = filter_info_new(); |
| 4645 | 4645 |
fltinfo->flags = msginfo->flags; |
| 4646 |
filter_apply_msginfo(prefs_common.manual_junk_fltlist, |
|
| 4647 |
msginfo, fltinfo); |
|
| 4646 |
filter_apply_msginfo(summaryview->junk_fltlist, msginfo, fltinfo); |
|
| 4648 | 4647 |
|
| 4649 | 4648 |
if (fltinfo->actions[FLT_ACTION_MOVE] || |
| 4650 | 4649 |
fltinfo->actions[FLT_ACTION_COPY] || |
| ... | ... | |
| 4761 | 4760 |
|
| 4762 | 4761 |
void summary_filter_junk(SummaryView *summaryview, gboolean selected_only) |
| 4763 | 4762 |
{
|
| 4764 |
if (prefs_common.manual_junk_fltlist) |
|
| 4763 |
FilterRule *rule; |
|
| 4764 |
GSList junk_fltlist = {NULL, NULL};
|
|
| 4765 |
FolderItem *item = summaryview->folder_item; |
|
| 4766 |
FolderItem *junk = NULL; |
|
| 4767 |
|
|
| 4768 |
if (!item) |
|
| 4769 |
return; |
|
| 4770 |
|
|
| 4771 |
if (item->folder) |
|
| 4772 |
junk = folder_get_junk(item->folder); |
|
| 4773 |
rule = filter_junk_rule_create(NULL, junk, TRUE); |
|
| 4774 |
if (rule) {
|
|
| 4775 |
junk_fltlist.data = rule; |
|
| 4776 |
summaryview->junk_fltlist = &junk_fltlist; |
|
| 4765 | 4777 |
summary_filter_real(summaryview, summary_filter_junk_func, |
| 4766 | 4778 |
selected_only); |
| 4779 |
summaryview->junk_fltlist = NULL; |
|
| 4780 |
filter_rule_free(rule); |
|
| 4781 |
} |
|
| 4767 | 4782 |
} |
| 4768 | 4783 |
|
| 4769 | 4784 |
void summary_filter_open(SummaryView *summaryview, FilterCreateType type) |
| src/summaryview.h (revision 2767) | ||
|---|---|---|
| 159 | 159 |
GSList *pos_list; |
| 160 | 160 |
|
| 161 | 161 |
guint write_lock_count; |
| 162 |
|
|
| 163 |
/* junk filter list */ |
|
| 164 |
GSList *junk_fltlist; |
|
| 162 | 165 |
}; |
| 163 | 166 |
|
| 164 | 167 |
SummaryView *summary_create(void); |
| src/prefs_common_dialog.c (revision 2767) | ||
|---|---|---|
| 4382 | 4382 |
static void prefs_common_apply(void) |
| 4383 | 4383 |
{
|
| 4384 | 4384 |
prefs_set_data_from_dialog(prefs_common_get_params()); |
| 4385 |
prefs_common_junk_filter_list_set(); |
|
| 4386 | 4385 |
gtkut_stock_button_set_set_reverse(!prefs_common.comply_gnome_hig); |
| 4387 | 4386 |
main_window_reflect_prefs_all(); |
| 4388 | 4387 |
compose_reflect_prefs_all(); |
| ChangeLog (revision 2767) | ||
|---|---|---|
| 1 | 1 |
2010-12-22 |
| 2 | 2 |
|
| 3 |
* libsylph/filter.[ch] |
|
| 4 |
libsylph/prefs_common.[ch] |
|
| 5 |
libsylph/mbox.c |
|
| 6 |
src/inc.[ch] |
|
| 7 |
src/main.c |
|
| 8 |
src/summaryview.[ch] |
|
| 9 |
src/prefs_common_dialog.c: refactored junk filter rule management. |
|
| 10 |
Create junk filter rule on demand. |
|
| 11 |
Deprecated prefs_common_junk_filter_list_set(). |
|
| 12 |
Automatically select appropriate Junk folder on filtering. |
|
| 13 |
|
|
| 14 |
2010-12-22 |
|
| 15 |
|
|
| 3 | 16 |
* src/addressbook.c: added menu 'Add to recipient/Cc/Bcc'. |
| 4 | 17 |
|
| 5 | 18 |
2010-12-21 |
Also available in: Unified diff