2 * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2016 Hiroyuki Yamamoto and the Claws Mail team
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 3 of the License, or
8 * (at your option) any later version.
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.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include "claws-features.h"
27 #include <glib/gi18n.h>
30 #include <sys/types.h>
38 #include "alertpanel.h"
48 #include "prefs_gtk.h"
50 #include "filtering.h"
51 #include "procheader.h"
54 #include "folder_item_prefs.h"
55 #include "remotefolder.h"
56 #include "partial_download.h"
57 #include "statusbar.h"
65 /* Dependecies to be removed ?! */
66 #include "prefs_common.h"
67 #include "prefs_account.h"
69 /* Define possible missing constants for Windows. */
81 static GList
*folder_list
= NULL
;
82 static GSList
*class_list
= NULL
;
83 static GSList
*folder_unloaded_list
= NULL
;
85 void folder_init (Folder
*folder
,
88 static gchar
*folder_item_get_cache_file (FolderItem
*item
);
89 static gchar
*folder_item_get_mark_file (FolderItem
*item
);
90 static gchar
*folder_item_get_tags_file (FolderItem
*item
);
91 static GNode
*folder_get_xml_node (Folder
*folder
);
92 static Folder
*folder_get_from_xml (GNode
*node
);
93 static void folder_update_op_count_rec (GNode
*node
);
96 static void folder_get_persist_prefs_recursive
97 (GNode
*node
, GHashTable
*pptable
);
98 static gboolean
persist_prefs_free (gpointer key
, gpointer val
, gpointer data
);
99 static void folder_item_read_cache (FolderItem
*item
);
100 gint
folder_item_scan_full (FolderItem
*item
, gboolean filtering
);
101 static void folder_item_update_with_msg (FolderItem
*item
, FolderItemUpdateFlags update_flags
,
103 static GHashTable
*folder_persist_prefs_new (Folder
*folder
);
104 static void folder_persist_prefs_free (GHashTable
*pptable
);
105 static void folder_item_restore_persist_prefs (FolderItem
*item
, GHashTable
*pptable
);
107 void folder_system_init(void)
109 folder_register_class(mh_get_class());
110 folder_register_class(imap_get_class());
111 folder_register_class(news_get_class());
114 static GSList
*folder_get_class_list(void)
119 void folder_register_class(FolderClass
*klass
)
121 GSList
*xmllist
, *cur
;
123 debug_print("registering folder class %s\n", klass
->idstr
);
125 class_list
= g_slist_append(class_list
, klass
);
127 xmllist
= g_slist_copy(folder_unloaded_list
);
128 for (cur
= xmllist
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
129 GNode
*node
= (GNode
*) cur
->data
;
130 XMLNode
*xmlnode
= (XMLNode
*) node
->data
;
131 GList
*cur
= xmlnode
->tag
->attr
;
133 for (; cur
!= NULL
; cur
= g_list_next(cur
)) {
134 XMLAttr
*attr
= (XMLAttr
*) cur
->data
;
136 if (!attr
|| !attr
->name
|| !attr
->value
) continue;
137 if (!strcmp(attr
->name
, "type") && !strcmp(attr
->value
, klass
->idstr
)) {
140 folder
= folder_get_from_xml(node
);
143 folder_unloaded_list
= g_slist_remove(folder_unloaded_list
, node
);
151 g_slist_free(xmllist
);
154 void folder_unregister_class(FolderClass
*klass
)
156 GList
*folderlist
, *cur
;
158 debug_print("unregistering folder class %s\n", klass
->idstr
);
160 class_list
= g_slist_remove(class_list
, klass
);
162 folderlist
= g_list_copy(folder_get_list());
163 for (cur
= folderlist
; cur
!= NULL
; cur
= g_list_next(cur
)) {
164 Folder
*folder
= (Folder
*) cur
->data
;
166 if (folder
->klass
== klass
) {
167 GNode
*xmlnode
= folder_get_xml_node(folder
);
168 folder_unloaded_list
= g_slist_append(folder_unloaded_list
, xmlnode
);
169 folder_destroy(folder
);
172 g_list_free(folderlist
);
174 if (klass
->prefs_pages
)
175 g_slist_free(klass
->prefs_pages
);
178 Folder
*folder_new(FolderClass
*klass
, const gchar
*name
, const gchar
*path
)
180 Folder
*folder
= NULL
;
183 cm_return_val_if_fail(klass
!= NULL
, NULL
);
185 name
= name
? name
: path
;
186 folder
= klass
->new_folder(name
, path
);
188 /* Create root folder item */
189 item
= folder_item_new(folder
, name
, NULL
);
193 item
->folder
= folder
;
194 folder
->node
= item
->node
;
200 void folder_init(Folder
*folder
, const gchar
*name
)
202 cm_return_if_fail(folder
!= NULL
);
204 folder_set_name(folder
, name
);
206 /* Init folder data */
207 folder
->account
= NULL
;
209 folder
->inbox
= NULL
;
210 folder
->outbox
= NULL
;
211 folder
->draft
= NULL
;
212 folder
->queue
= NULL
;
213 folder
->trash
= NULL
;
216 static void reset_parent_type(FolderItem
*item
, gpointer data
) {
217 item
->parent_stype
= -1;
220 void folder_item_change_type(FolderItem
*item
, SpecialFolderItemType newtype
)
222 Folder
*folder
= NULL
;
223 FolderUpdateData hookdata
;
228 folder
= item
->folder
;
229 /* unset previous root of newtype */
232 folder_item_change_type(folder
->inbox
, F_NORMAL
);
233 folder
->inbox
= item
;
236 folder_item_change_type(folder
->outbox
, F_NORMAL
);
237 folder
->outbox
= item
;
240 folder_item_change_type(folder
->queue
, F_NORMAL
);
241 folder
->queue
= item
;
244 folder_item_change_type(folder
->draft
, F_NORMAL
);
245 folder
->draft
= item
;
248 folder_item_change_type(folder
->trash
, F_NORMAL
);
249 folder
->trash
= item
;
255 /* set new type for current folder and sons */
256 item
->stype
= newtype
;
257 folder_func_to_all_folders(reset_parent_type
, NULL
);
259 hookdata
.folder
= folder
;
260 hookdata
.update_flags
= FOLDER_TREE_CHANGED
;
261 hookdata
.item
= NULL
;
262 hookdata
.item2
= NULL
;
263 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
266 void folder_destroy(Folder
*folder
)
268 cm_return_if_fail(folder
!= NULL
);
269 cm_return_if_fail(folder
->klass
->destroy_folder
!= NULL
);
271 folder_remove(folder
);
273 folder_tree_destroy(folder
);
275 folder
->klass
->destroy_folder(folder
);
277 g_free(folder
->name
);
281 void folder_set_xml(Folder
*folder
, XMLTag
*tag
)
284 FolderItem
*rootitem
= NULL
;
286 if ((folder
->node
!= NULL
) && (folder
->node
->data
!= NULL
))
287 rootitem
= (FolderItem
*) folder
->node
->data
;
289 for (cur
= tag
->attr
; cur
!= NULL
; cur
= g_list_next(cur
)) {
290 XMLAttr
*attr
= (XMLAttr
*) cur
->data
;
292 if (!attr
|| !attr
->name
|| !attr
->value
) continue;
293 if (!strcmp(attr
->name
, "name")) {
294 g_free(folder
->name
);
295 folder
->name
= g_strdup(attr
->value
);
296 if (rootitem
!= NULL
) {
297 g_free(rootitem
->name
);
298 rootitem
->name
= g_strdup(attr
->value
);
300 } else if (!strcmp(attr
->name
, "account_id")) {
301 PrefsAccount
*account
;
303 account
= account_find_from_id(atoi(attr
->value
));
305 g_warning("account_id: %s not found", attr
->value
);
307 folder
->account
= account
;
308 account
->folder
= folder
;
310 } else if (!strcmp(attr
->name
, "collapsed")) {
311 if (rootitem
!= NULL
)
312 rootitem
->collapsed
= *attr
->value
== '1' ? TRUE
: FALSE
;
313 } else if (!strcmp(attr
->name
, "sort")) {
314 folder
->sort
= atoi(attr
->value
);
319 XMLTag
*folder_get_xml(Folder
*folder
)
323 tag
= xml_tag_new("folder");
326 xml_tag_add_attr(tag
, xml_attr_new("name", folder
->name
));
328 xml_tag_add_attr(tag
, xml_attr_new_int("account_id", folder
->account
->account_id
));
329 if (folder
->node
&& folder
->node
->data
) {
330 FolderItem
*rootitem
= (FolderItem
*) folder
->node
->data
;
332 xml_tag_add_attr(tag
, xml_attr_new("collapsed", rootitem
->collapsed
? "1" : "0"));
334 xml_tag_add_attr(tag
, xml_attr_new_int("sort", folder
->sort
));
339 FolderItem
*folder_item_new(Folder
*folder
, const gchar
*name
, const gchar
*path
)
341 FolderItem
*item
= NULL
;
343 cm_return_val_if_fail(folder
!= NULL
, NULL
);
345 if (folder
->klass
->item_new
) {
346 item
= folder
->klass
->item_new(folder
);
348 item
= g_new0(FolderItem
, 1);
351 cm_return_val_if_fail(item
!= NULL
, NULL
);
353 item
->stype
= F_NORMAL
;
355 if(!g_utf8_validate(name
, -1, NULL
)) {
356 item
->name
= g_malloc(strlen(name
)*2+1);
357 conv_localetodisp(item
->name
, strlen(name
)*2+1, name
);
359 item
->name
= g_strdup(name
);
362 item
->path
= g_strdup(path
);
365 item
->unread_msgs
= 0;
366 item
->unreadmarked_msgs
= 0;
367 item
->marked_msgs
= 0;
368 item
->total_msgs
= 0;
369 item
->replied_msgs
= 0;
370 item
->forwarded_msgs
= 0;
371 item
->locked_msgs
= 0;
372 item
->ignored_msgs
= 0;
373 item
->watched_msgs
= 0;
377 item
->no_sub
= FALSE
;
378 item
->no_select
= FALSE
;
379 item
->collapsed
= FALSE
;
380 item
->thread_collapsed
= FALSE
;
381 item
->threaded
= TRUE
;
382 item
->ret_rcpt
= FALSE
;
383 item
->opened
= FALSE
;
384 item
->node
= g_node_new(item
);
386 item
->account
= NULL
;
387 item
->apply_sub
= FALSE
;
388 item
->mark_queue
= NULL
;
390 item
->parent_stype
= -1;
392 item
->sort_key
= prefs_common
.default_sort_key
;
393 item
->sort_type
= prefs_common
.default_sort_type
;
395 item
->prefs
= folder_item_prefs_new();
400 void folder_item_append(FolderItem
*parent
, FolderItem
*item
)
402 cm_return_if_fail(parent
!= NULL
);
403 cm_return_if_fail(parent
->folder
!= NULL
);
404 cm_return_if_fail(parent
->node
!= NULL
);
405 cm_return_if_fail(item
!= NULL
);
407 item
->folder
= parent
->folder
;
408 g_node_append(parent
->node
, item
->node
);
411 void folder_item_remove(FolderItem
*item
)
413 GNode
*node
, *start_node
;
414 FolderUpdateData hookdata
;
415 gchar
*tags_file
= NULL
, *tags_dir
= NULL
;
417 cm_return_if_fail(item
!= NULL
);
418 cm_return_if_fail(item
->folder
!= NULL
);
419 cm_return_if_fail(item
->folder
->node
!= NULL
);
421 start_node
= item
->node
;
423 node
= item
->folder
->node
;
425 node
= g_node_find(node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, item
);
426 node
= node
->children
;
428 /* remove my children */
429 while (node
!= NULL
) {
430 if (node
&& node
->data
) {
431 FolderItem
*sub_item
= (FolderItem
*) node
->data
;
433 folder_item_remove(sub_item
);
438 if (item
->cache
!= NULL
) {
439 msgcache_destroy(item
->cache
);
442 tags_file
= folder_item_get_tags_file(item
);
444 claws_unlink(tags_file
);
445 tags_dir
= g_path_get_dirname(tags_file
);
452 hookdata
.folder
= item
->folder
;
453 hookdata
.update_flags
= FOLDER_TREE_CHANGED
| FOLDER_REMOVE_FOLDERITEM
;
454 hookdata
.item
= item
;
455 hookdata
.item2
= NULL
;
456 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
460 if (item
->folder
->node
== node
)
461 item
->folder
->node
= NULL
;
463 folder_item_destroy(item
);
465 g_node_destroy(node
);
468 void folder_item_remove_children(FolderItem
*item
)
472 cm_return_if_fail(item
!= NULL
);
473 cm_return_if_fail(item
->folder
!= NULL
);
474 cm_return_if_fail(item
->node
!= NULL
);
476 node
= item
->node
->children
;
477 while (node
!= NULL
) {
479 folder_item_remove(FOLDER_ITEM(node
->data
));
484 void folder_item_destroy(FolderItem
*item
)
488 cm_return_if_fail(item
!= NULL
);
490 folder
= item
->folder
;
492 if (folder
->inbox
== item
)
493 folder
->inbox
= NULL
;
494 else if (folder
->outbox
== item
)
495 folder
->outbox
= NULL
;
496 else if (folder
->draft
== item
)
497 folder
->draft
= NULL
;
498 else if (folder
->queue
== item
)
499 folder
->queue
= NULL
;
500 else if (folder
->trash
== item
)
501 folder
->trash
= NULL
;
505 folder_item_free_cache(item
, TRUE
);
507 folder_item_prefs_free(item
->prefs
);
511 if (item
->folder
!= NULL
) {
512 if(item
->folder
->klass
->item_destroy
) {
513 item
->folder
->klass
->item_destroy(item
->folder
, item
);
520 FolderItem
*folder_item_parent(FolderItem
*item
)
522 cm_return_val_if_fail(item
!= NULL
, NULL
);
523 cm_return_val_if_fail(item
->node
!= NULL
, NULL
);
525 if (item
->node
->parent
== NULL
)
527 return (FolderItem
*) item
->node
->parent
->data
;
530 void folder_item_set_xml(Folder
*folder
, FolderItem
*item
, XMLTag
*tag
)
534 for (cur
= tag
->attr
; cur
!= NULL
; cur
= g_list_next(cur
)) {
535 XMLAttr
*attr
= (XMLAttr
*) cur
->data
;
537 if (!attr
|| !attr
->name
|| !attr
->value
) continue;
538 if (!strcmp(attr
->name
, "type")) {
539 if (!g_ascii_strcasecmp(attr
->value
, "normal"))
540 item
->stype
= F_NORMAL
;
541 else if (!g_ascii_strcasecmp(attr
->value
, "inbox"))
542 item
->stype
= F_INBOX
;
543 else if (!g_ascii_strcasecmp(attr
->value
, "outbox"))
544 item
->stype
= F_OUTBOX
;
545 else if (!g_ascii_strcasecmp(attr
->value
, "draft"))
546 item
->stype
= F_DRAFT
;
547 else if (!g_ascii_strcasecmp(attr
->value
, "queue"))
548 item
->stype
= F_QUEUE
;
549 else if (!g_ascii_strcasecmp(attr
->value
, "trash"))
550 item
->stype
= F_TRASH
;
551 } else if (!strcmp(attr
->name
, "name")) {
553 item
->name
= g_strdup(attr
->value
);
554 } else if (!strcmp(attr
->name
, "path")) {
556 item
->path
= g_strdup(attr
->value
);
557 } else if (!strcmp(attr
->name
, "mtime"))
558 item
->mtime
= strtoul(attr
->value
, NULL
, 10);
559 else if (!strcmp(attr
->name
, "new"))
560 item
->new_msgs
= atoi(attr
->value
);
561 else if (!strcmp(attr
->name
, "unread"))
562 item
->unread_msgs
= atoi(attr
->value
);
563 else if (!strcmp(attr
->name
, "unreadmarked"))
564 item
->unreadmarked_msgs
= atoi(attr
->value
);
565 else if (!strcmp(attr
->name
, "marked"))
566 item
->marked_msgs
= atoi(attr
->value
);
567 else if (!strcmp(attr
->name
, "replied"))
568 item
->replied_msgs
= atoi(attr
->value
);
569 else if (!strcmp(attr
->name
, "forwarded"))
570 item
->forwarded_msgs
= atoi(attr
->value
);
571 else if (!strcmp(attr
->name
, "locked"))
572 item
->locked_msgs
= atoi(attr
->value
);
573 else if (!strcmp(attr
->name
, "ignored"))
574 item
->ignored_msgs
= atoi(attr
->value
);
575 else if (!strcmp(attr
->name
, "watched"))
576 item
->watched_msgs
= atoi(attr
->value
);
577 else if (!strcmp(attr
->name
, "order"))
578 item
->order
= atoi(attr
->value
);
579 else if (!strcmp(attr
->name
, "total"))
580 item
->total_msgs
= atoi(attr
->value
);
581 else if (!strcmp(attr
->name
, "no_sub"))
582 item
->no_sub
= *attr
->value
== '1' ? TRUE
: FALSE
;
583 else if (!strcmp(attr
->name
, "no_select"))
584 item
->no_select
= *attr
->value
== '1' ? TRUE
: FALSE
;
585 else if (!strcmp(attr
->name
, "collapsed"))
586 item
->collapsed
= *attr
->value
== '1' ? TRUE
: FALSE
;
587 else if (!strcmp(attr
->name
, "thread_collapsed"))
588 item
->thread_collapsed
= *attr
->value
== '1' ? TRUE
: FALSE
;
589 else if (!strcmp(attr
->name
, "threaded"))
590 item
->threaded
= *attr
->value
== '1' ? TRUE
: FALSE
;
591 else if (!strcmp(attr
->name
, "hidereadmsgs"))
592 item
->hide_read_msgs
= *attr
->value
== '1' ? TRUE
: FALSE
;
593 else if (!strcmp(attr
->name
, "hidedelmsgs"))
594 item
->hide_del_msgs
= *attr
->value
== '1' ? TRUE
: FALSE
;
595 else if (!strcmp(attr
->name
, "hidereadthreads"))
596 item
->hide_read_threads
= *attr
->value
== '1' ? TRUE
: FALSE
;
597 else if (!strcmp(attr
->name
, "reqretrcpt"))
598 item
->ret_rcpt
= *attr
->value
== '1' ? TRUE
: FALSE
;
599 else if (!strcmp(attr
->name
, "sort_key")) {
600 if (!strcmp(attr
->value
, "none"))
601 item
->sort_key
= SORT_BY_NONE
;
602 else if (!strcmp(attr
->value
, "number"))
603 item
->sort_key
= SORT_BY_NUMBER
;
604 else if (!strcmp(attr
->value
, "size"))
605 item
->sort_key
= SORT_BY_SIZE
;
606 else if (!strcmp(attr
->value
, "date"))
607 item
->sort_key
= SORT_BY_DATE
;
608 else if (!strcmp(attr
->value
, "from"))
609 item
->sort_key
= SORT_BY_FROM
;
610 else if (!strcmp(attr
->value
, "subject"))
611 item
->sort_key
= SORT_BY_SUBJECT
;
612 else if (!strcmp(attr
->value
, "score"))
613 item
->sort_key
= SORT_BY_SCORE
;
614 else if (!strcmp(attr
->value
, "label"))
615 item
->sort_key
= SORT_BY_LABEL
;
616 else if (!strcmp(attr
->value
, "mark"))
617 item
->sort_key
= SORT_BY_MARK
;
618 else if (!strcmp(attr
->value
, "unread"))
619 item
->sort_key
= SORT_BY_STATUS
;
620 else if (!strcmp(attr
->value
, "mime"))
621 item
->sort_key
= SORT_BY_MIME
;
622 else if (!strcmp(attr
->value
, "to"))
623 item
->sort_key
= SORT_BY_TO
;
624 else if (!strcmp(attr
->value
, "locked"))
625 item
->sort_key
= SORT_BY_LOCKED
;
626 else if (!strcmp(attr
->value
, "tags"))
627 item
->sort_key
= SORT_BY_TAGS
;
628 else if (!strcmp(attr
->value
, "thread_date"))
629 item
->sort_key
= SORT_BY_THREAD_DATE
;
630 } else if (!strcmp(attr
->name
, "sort_type")) {
631 if (!strcmp(attr
->value
, "ascending"))
632 item
->sort_type
= SORT_ASCENDING
;
634 item
->sort_type
= SORT_DESCENDING
;
635 } else if (!strcmp(attr
->name
, "account_id")) {
636 PrefsAccount
*account
;
638 account
= account_find_from_id(atoi(attr
->value
));
640 g_warning("account_id: %s not found", attr
->value
);
642 item
->account
= account
;
643 } else if (!strcmp(attr
->name
, "apply_sub")) {
644 item
->apply_sub
= *attr
->value
== '1' ? TRUE
: FALSE
;
645 } else if (!strcmp(attr
->name
, "last_seen")) {
646 if (!claws_crashed())
647 item
->last_seen
= atoi(attr
->value
);
652 /* options without meaning in drafts */
653 if (item
->stype
== F_DRAFT
)
654 item
->hide_read_msgs
=
655 item
->hide_del_msgs
=
656 item
->hide_read_threads
= FALSE
;
659 XMLTag
*folder_item_get_xml(Folder
*folder
, FolderItem
*item
)
661 static gchar
*folder_item_stype_str
[] = {"normal", "inbox", "outbox",
662 "draft", "queue", "trash"};
663 static gchar
*sort_key_str
[] = {"none", "number", "size", "date",
664 "from", "subject", "score", "label",
665 "mark", "unread", "mime", "to",
666 "locked", "tags", "thread_date" };
670 tag
= xml_tag_new("folderitem");
672 xml_tag_add_attr(tag
, xml_attr_new("type", folder_item_stype_str
[item
->stype
]));
674 xml_tag_add_attr(tag
, xml_attr_new("name", item
->name
));
676 xml_tag_add_attr(tag
, xml_attr_new("path", item
->path
));
678 xml_tag_add_attr(tag
, xml_attr_new("no_sub", "1"));
680 xml_tag_add_attr(tag
, xml_attr_new("no_select", "1"));
681 xml_tag_add_attr(tag
, xml_attr_new("collapsed", item
->collapsed
&& item
->node
->children
? "1" : "0"));
682 xml_tag_add_attr(tag
, xml_attr_new("thread_collapsed", item
->thread_collapsed
? "1" : "0"));
683 xml_tag_add_attr(tag
, xml_attr_new("threaded", item
->threaded
? "1" : "0"));
684 xml_tag_add_attr(tag
, xml_attr_new("hidereadmsgs", item
->hide_read_msgs
? "1" : "0"));
685 xml_tag_add_attr(tag
, xml_attr_new("hidedelmsgs", item
->hide_del_msgs
? "1" : "0"));
686 xml_tag_add_attr(tag
, xml_attr_new("hidereadthreads", item
->hide_read_threads
? "1" : "0"));
688 xml_tag_add_attr(tag
, xml_attr_new("reqretrcpt", "1"));
690 if (item
->sort_key
!= SORT_BY_NONE
) {
691 xml_tag_add_attr(tag
, xml_attr_new("sort_key", sort_key_str
[item
->sort_key
]));
692 xml_tag_add_attr(tag
, xml_attr_new("sort_type", item
->sort_type
== SORT_ASCENDING
? "ascending" : "descending"));
695 value
= g_strdup_printf("%ld", (unsigned long int) item
->mtime
);
696 xml_tag_add_attr(tag
, xml_attr_new("mtime", value
));
698 xml_tag_add_attr(tag
, xml_attr_new_int("new", item
->new_msgs
));
699 xml_tag_add_attr(tag
, xml_attr_new_int("unread", item
->unread_msgs
));
700 xml_tag_add_attr(tag
, xml_attr_new_int("unreadmarked", item
->unreadmarked_msgs
));
701 xml_tag_add_attr(tag
, xml_attr_new_int("marked", item
->marked_msgs
));
702 xml_tag_add_attr(tag
, xml_attr_new_int("total", item
->total_msgs
));
703 xml_tag_add_attr(tag
, xml_attr_new_int("replied", item
->replied_msgs
));
704 xml_tag_add_attr(tag
, xml_attr_new_int("forwarded", item
->forwarded_msgs
));
705 xml_tag_add_attr(tag
, xml_attr_new_int("locked", item
->locked_msgs
));
706 xml_tag_add_attr(tag
, xml_attr_new_int("ignore", item
->ignored_msgs
));
707 xml_tag_add_attr(tag
, xml_attr_new_int("watched", item
->watched_msgs
));
708 xml_tag_add_attr(tag
, xml_attr_new_int("order", item
->order
));
711 xml_tag_add_attr(tag
, xml_attr_new_int("account_id", item
->account
->account_id
));
713 xml_tag_add_attr(tag
, xml_attr_new("apply_sub", "1"));
715 xml_tag_add_attr(tag
, xml_attr_new_int("last_seen", item
->last_seen
));
720 void folder_set_ui_func(Folder
*folder
, FolderUIFunc func
, gpointer data
)
722 cm_return_if_fail(folder
!= NULL
);
724 folder
->ui_func
= func
;
725 folder
->ui_func_data
= data
;
728 void folder_set_name(Folder
*folder
, const gchar
*name
)
730 cm_return_if_fail(folder
!= NULL
);
732 g_free(folder
->name
);
733 folder
->name
= name
? g_strdup(name
) : NULL
;
734 if (folder
->node
&& folder
->node
->data
) {
735 FolderItem
*item
= (FolderItem
*)folder
->node
->data
;
738 item
->name
= name
? g_strdup(name
) : NULL
;
742 void folder_set_sort(Folder
*folder
, guint sort
)
744 cm_return_if_fail(folder
!= NULL
);
746 if (folder
->sort
!= sort
) {
747 folder_remove(folder
);
753 static gboolean
folder_tree_destroy_func(GNode
*node
, gpointer data
) {
754 FolderItem
*item
= (FolderItem
*) node
->data
;
756 folder_item_destroy(item
);
760 void folder_tree_destroy(Folder
*folder
)
764 cm_return_if_fail(folder
!= NULL
);
768 prefs_filtering_clear_folder(folder
);
771 g_node_traverse(node
, G_POST_ORDER
, G_TRAVERSE_ALL
, -1,
772 folder_tree_destroy_func
, NULL
);
773 g_node_destroy(node
);
778 void folder_add(Folder
*folder
)
783 FolderUpdateData hookdata
;
785 cm_return_if_fail(folder
!= NULL
);
787 if ((FOLDER_TYPE(folder
) == F_IMAP
||
788 FOLDER_TYPE(folder
) == F_NEWS
) &&
789 folder
->account
== NULL
) {
793 for (i
= 0, cur
= folder_list
; cur
!= NULL
; cur
= cur
->next
, i
++) {
794 cur_folder
= FOLDER(cur
->data
);
795 if (cur_folder
->sort
< folder
->sort
)
799 folder_list
= g_list_insert(folder_list
, folder
, i
);
801 hookdata
.folder
= folder
;
802 hookdata
.update_flags
= FOLDER_ADD_FOLDER
;
803 hookdata
.item
= NULL
;
804 hookdata
.item2
= NULL
;
805 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
808 void folder_remove(Folder
*folder
)
810 FolderUpdateData hookdata
;
812 cm_return_if_fail(folder
!= NULL
);
814 folder_list
= g_list_remove(folder_list
, folder
);
816 hookdata
.folder
= folder
;
817 hookdata
.update_flags
= FOLDER_REMOVE_FOLDER
;
818 hookdata
.item
= NULL
;
819 hookdata
.item2
= NULL
;
820 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
823 GList
*folder_get_list(void)
828 gint
folder_read_list(void)
834 path
= folder_get_list_path();
835 if (!is_file_exist(path
)) return -1;
836 node
= xml_parse_file(path
);
837 if (!node
) return -1;
839 xmlnode
= node
->data
;
840 if (strcmp2(xmlnode
->tag
->tag
, "folderlist") != 0) {
841 g_warning("wrong folder list");
846 cur
= node
->children
;
847 while (cur
!= NULL
) {
850 folder
= folder_get_from_xml(cur
);
854 folder_unloaded_list
= g_slist_append(folder_unloaded_list
,
855 (gpointer
) xml_copy_tree(cur
));
860 if (folder_list
|| folder_unloaded_list
)
866 void folder_write_list(void)
877 path
= folder_get_list_path();
878 if ((pfile
= prefs_write_open(path
)) == NULL
) return;
880 if (xml_file_put_xml_decl(pfile
->fp
) < 0) {
881 prefs_file_close_revert(pfile
);
882 g_warning("failed to start write folder list.");
885 tag
= xml_tag_new("folderlist");
887 xmlnode
= xml_node_new(tag
, NULL
);
889 rootnode
= g_node_new(xmlnode
);
891 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
895 node
= folder_get_xml_node(folder
);
897 g_node_append(rootnode
, node
);
900 for (slist
= folder_unloaded_list
; slist
!= NULL
; slist
= g_slist_next(slist
)) {
901 GNode
*node
= (GNode
*) slist
->data
;
903 g_node_append(rootnode
, (gpointer
) xml_copy_tree(node
));
906 if (xml_write_tree(rootnode
, pfile
->fp
) < 0) {
907 prefs_file_close_revert(pfile
);
908 g_warning("failed to write folder list.");
909 } else if (prefs_file_close(pfile
) < 0) {
910 g_warning("failed to write folder list.");
912 xml_free_tree(rootnode
);
915 static gboolean
folder_scan_tree_func(GNode
*node
, gpointer data
)
917 GHashTable
*pptable
= (GHashTable
*)data
;
918 FolderItem
*item
= (FolderItem
*)node
->data
;
920 folder_item_restore_persist_prefs(item
, pptable
);
921 folder_item_scan_full(item
, FALSE
);
926 static gboolean
folder_restore_prefs_func(GNode
*node
, gpointer data
)
928 GHashTable
*pptable
= (GHashTable
*)data
;
929 FolderItem
*item
= (FolderItem
*)node
->data
;
931 folder_item_restore_persist_prefs(item
, pptable
);
936 void folder_scan_tree(Folder
*folder
, gboolean rebuild
)
939 FolderUpdateData hookdata
;
940 Folder
*old_folder
= folder
;
942 if (!folder
->klass
->scan_tree
)
945 pptable
= folder_persist_prefs_new(folder
);
948 folder_remove(folder
);
950 if (folder
->klass
->scan_tree(folder
) < 0) {
952 folder_add(old_folder
);
957 hookdata
.folder
= folder
;
958 hookdata
.update_flags
= FOLDER_TREE_CHANGED
;
959 hookdata
.item
= NULL
;
960 hookdata
.item2
= NULL
;
961 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
964 g_node_traverse(folder
->node
, G_POST_ORDER
, G_TRAVERSE_ALL
, -1, folder_scan_tree_func
, pptable
);
966 g_node_traverse(folder
->node
, G_POST_ORDER
, G_TRAVERSE_ALL
, -1, folder_restore_prefs_func
, pptable
);
968 folder_persist_prefs_free(pptable
);
970 prefs_matcher_read_config();
975 FolderItem
*folder_create_folder(FolderItem
*parent
, const gchar
*name
)
977 FolderItem
*new_item
;
979 cm_return_val_if_fail(parent
!= NULL
, NULL
);
981 new_item
= parent
->folder
->klass
->create_folder(parent
->folder
, parent
, name
);
983 FolderUpdateData hookdata
;
985 new_item
->cache
= msgcache_new();
986 new_item
->cache_dirty
= TRUE
;
987 new_item
->mark_dirty
= TRUE
;
988 new_item
->tags_dirty
= TRUE
;
990 hookdata
.folder
= new_item
->folder
;
991 hookdata
.update_flags
= FOLDER_TREE_CHANGED
| FOLDER_ADD_FOLDERITEM
;
992 hookdata
.item
= new_item
;
993 hookdata
.item2
= NULL
;
994 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
1000 gint
folder_item_rename(FolderItem
*item
, gchar
*newname
)
1004 cm_return_val_if_fail(item
!= NULL
, -1);
1005 cm_return_val_if_fail(newname
!= NULL
, -1);
1007 retval
= item
->folder
->klass
->rename_folder(item
->folder
, item
, newname
);
1010 FolderItemUpdateData hookdata
;
1011 FolderUpdateData hookdata2
;
1013 hookdata
.item
= item
;
1014 hookdata
.update_flags
= F_ITEM_UPDATE_NAME
;
1015 hookdata
.msg
= NULL
;
1016 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST
, &hookdata
);
1018 hookdata2
.folder
= item
->folder
;
1019 hookdata2
.item
= item
;
1020 hookdata2
.item2
= NULL
;
1021 hookdata2
.update_flags
= FOLDER_RENAME_FOLDERITEM
;
1022 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata2
);
1028 struct TotalMsgCount
1032 guint unreadmarked_msgs
;
1036 guint forwarded_msgs
;
1042 struct FuncToAllFoldersData
1044 FolderItemFunc function
;
1048 static gboolean
folder_func_to_all_folders_func(GNode
*node
, gpointer data
)
1051 struct FuncToAllFoldersData
*function_data
= (struct FuncToAllFoldersData
*) data
;
1053 cm_return_val_if_fail(node
->data
!= NULL
, FALSE
);
1055 item
= FOLDER_ITEM(node
->data
);
1056 cm_return_val_if_fail(item
!= NULL
, FALSE
);
1058 function_data
->function(item
, function_data
->data
);
1063 void folder_func_to_all_folders(FolderItemFunc function
, gpointer data
)
1067 struct FuncToAllFoldersData function_data
;
1069 function_data
.function
= function
;
1070 function_data
.data
= data
;
1072 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1073 folder
= FOLDER(list
->data
);
1075 g_node_traverse(folder
->node
, G_PRE_ORDER
,
1077 folder_func_to_all_folders_func
,
1082 static void folder_count_total_msgs_func(FolderItem
*item
, gpointer data
)
1084 struct TotalMsgCount
*count
= (struct TotalMsgCount
*)data
;
1086 count
->new_msgs
+= item
->new_msgs
;
1087 count
->unread_msgs
+= item
->unread_msgs
;
1088 count
->unreadmarked_msgs
+= item
->unreadmarked_msgs
;
1089 count
->marked_msgs
+= item
->marked_msgs
;
1090 count
->total_msgs
+= item
->total_msgs
;
1091 count
->replied_msgs
+= item
->replied_msgs
;
1092 count
->forwarded_msgs
+= item
->forwarded_msgs
;
1093 count
->locked_msgs
+= item
->locked_msgs
;
1094 count
->ignored_msgs
+= item
->ignored_msgs
;
1095 count
->watched_msgs
+= item
->watched_msgs
;
1098 struct TotalMsgStatus
1106 static gboolean
folder_get_status_full_all_func(GNode
*node
, gpointer data
)
1109 struct TotalMsgStatus
*status
= (struct TotalMsgStatus
*)data
;
1112 cm_return_val_if_fail(node
->data
!= NULL
, FALSE
);
1114 item
= FOLDER_ITEM(node
->data
);
1116 if (!item
->path
) return FALSE
;
1118 status
->new += item
->new_msgs
;
1119 status
->unread
+= item
->unread_msgs
;
1120 status
->total
+= item
->total_msgs
;
1123 id
= folder_item_get_identifier(item
);
1124 g_string_append_printf(status
->str
, "%5d %5d %5d %s\n",
1125 item
->new_msgs
, item
->unread_msgs
,
1126 item
->total_msgs
, id
);
1133 static void folder_get_status_full_all(GString
*str
, guint
*new, guint
*unread
,
1138 struct TotalMsgStatus status
;
1140 status
.new = status
.unread
= status
.total
= 0;
1143 debug_print("Counting total number of messages...\n");
1145 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1146 folder
= FOLDER(list
->data
);
1148 g_node_traverse(folder
->node
, G_PRE_ORDER
,
1150 folder_get_status_full_all_func
,
1155 *unread
= status
.unread
;
1156 *total
= status
.total
;
1159 gchar
*folder_get_status(GPtrArray
*folders
, gboolean full
)
1161 guint
new, unread
, total
;
1166 new = unread
= total
= 0;
1168 str
= g_string_new(NULL
);
1171 for (i
= 0; i
< folders
->len
; i
++) {
1174 item
= g_ptr_array_index(folders
, i
);
1175 new += item
->new_msgs
;
1176 unread
+= item
->unread_msgs
;
1177 total
+= item
->total_msgs
;
1182 id
= folder_item_get_identifier(item
);
1183 g_string_append_printf(str
, "%5d %5d %5d %s\n",
1184 item
->new_msgs
, item
->unread_msgs
,
1185 item
->total_msgs
, id
);
1190 folder_get_status_full_all(full
? str
: NULL
,
1191 &new, &unread
, &total
);
1195 g_string_append_printf(str
, "%5d %5d %5d\n", new, unread
, total
);
1197 g_string_append_printf(str
, "%d %d %d\n", new, unread
, total
);
1200 g_string_free(str
, FALSE
);
1205 void folder_count_total_msgs(guint
*new_msgs
, guint
*unread_msgs
,
1206 guint
*unreadmarked_msgs
, guint
*marked_msgs
,
1207 guint
*total_msgs
, guint
*replied_msgs
,
1208 guint
*forwarded_msgs
, guint
*locked_msgs
,
1209 guint
*ignored_msgs
, guint
*watched_msgs
)
1211 struct TotalMsgCount count
;
1213 count
.new_msgs
= count
.unread_msgs
= count
.unreadmarked_msgs
= 0;
1214 count
.total_msgs
= count
.replied_msgs
= count
.forwarded_msgs
= 0;
1215 count
.locked_msgs
= count
.ignored_msgs
= count
.watched_msgs
= 0;
1216 count
.marked_msgs
= 0;
1218 debug_print("Counting total number of messages...\n");
1220 folder_func_to_all_folders(folder_count_total_msgs_func
, &count
);
1222 *new_msgs
= count
.new_msgs
;
1223 *unread_msgs
= count
.unread_msgs
;
1224 *unreadmarked_msgs
= count
.unreadmarked_msgs
;
1225 *marked_msgs
= count
.marked_msgs
;
1226 *total_msgs
= count
.total_msgs
;
1227 *replied_msgs
= count
.replied_msgs
;
1228 *forwarded_msgs
= count
.forwarded_msgs
;
1229 *locked_msgs
= count
.locked_msgs
;
1230 *ignored_msgs
= count
.ignored_msgs
;
1231 *watched_msgs
= count
.watched_msgs
;
1234 Folder
*folder_find_from_path(const gchar
*path
)
1239 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1240 folder
= list
->data
;
1241 if ((FOLDER_TYPE(folder
) == F_MH
||
1242 FOLDER_TYPE(folder
) == F_MBOX
) &&
1243 !path_cmp(LOCAL_FOLDER(folder
)->rootpath
, path
))
1250 Folder
*folder_find_from_name(const gchar
*name
, FolderClass
*klass
)
1255 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1256 folder
= list
->data
;
1257 if (folder
->klass
== klass
&&
1258 strcmp2(name
, folder
->name
) == 0)
1265 static gboolean
folder_item_find_func(GNode
*node
, gpointer data
)
1267 FolderItem
*item
= node
->data
;
1269 const gchar
*path
= d
[0];
1271 if (path_cmp(path
, item
->path
) != 0)
1279 FolderItem
*folder_find_item_from_path(const gchar
*path
)
1283 GList
*list
= folder_get_list();
1285 folder
= list
? list
->data
:NULL
;
1287 cm_return_val_if_fail(folder
!= NULL
, NULL
);
1289 d
[0] = (gpointer
)path
;
1291 while (d
[1] == NULL
&& list
) {
1292 folder
= FOLDER(list
->data
);
1293 g_node_traverse(folder
->node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, -1,
1294 folder_item_find_func
, d
);
1300 static gboolean
folder_item_find_func_real_path(GNode
*node
, gpointer data
)
1302 FolderItem
*item
= node
->data
;
1304 const gchar
*path
= d
[0];
1305 gchar
*tmp
= folder_item_get_path(item
);
1306 if (path_cmp(path
, tmp
) != 0) {
1316 FolderItem
*folder_find_item_from_real_path(const gchar
*path
)
1320 GList
*list
= folder_get_list();
1322 folder
= list
? list
->data
:NULL
;
1324 cm_return_val_if_fail(folder
!= NULL
, NULL
);
1326 d
[0] = (gpointer
)path
;
1328 while (d
[1] == NULL
&& list
) {
1329 folder
= FOLDER(list
->data
);
1330 g_node_traverse(folder
->node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, -1,
1331 folder_item_find_func_real_path
, d
);
1337 FolderItem
*folder_find_child_item_by_name(FolderItem
*item
, const gchar
*name
)
1342 for (node
= item
->node
->children
; node
!= NULL
; node
= node
->next
) {
1343 child
= FOLDER_ITEM(node
->data
);
1344 if (strcmp2(child
->name
, name
) == 0) {
1352 FolderClass
*folder_get_class_from_string(const gchar
*str
)
1356 classlist
= folder_get_class_list();
1357 for (; classlist
!= NULL
; classlist
= g_slist_next(classlist
)) {
1358 FolderClass
*class = (FolderClass
*) classlist
->data
;
1359 if (g_ascii_strcasecmp(class->idstr
, str
) == 0)
1366 gchar
*folder_get_identifier(Folder
*folder
)
1370 cm_return_val_if_fail(folder
!= NULL
, NULL
);
1372 type_str
= folder
->klass
->idstr
;
1373 return g_strconcat("#", type_str
, "/", folder
->name
, NULL
);
1376 gchar
*folder_item_get_identifier(FolderItem
*item
)
1379 gchar
*folder_id
= NULL
;
1381 cm_return_val_if_fail(item
!= NULL
, NULL
);
1383 if (item
->path
== NULL
)
1386 folder_id
= folder_get_identifier(item
->folder
);
1387 id
= g_strconcat(folder_id
, "/", item
->path
, NULL
);
1393 Folder
*folder_find_from_identifier(const gchar
*identifier
)
1400 cm_return_val_if_fail(identifier
!= NULL
, NULL
);
1402 if (*identifier
!= '#')
1405 Xstrdup_a(str
, identifier
, return NULL
);
1407 p
= strchr(str
, '/');
1412 class = folder_get_class_from_string(&str
[1]);
1421 return folder_find_from_name(name
, class);
1424 FolderItem
*folder_find_item_from_identifier(const gchar
*identifier
)
1434 cm_return_val_if_fail(identifier
!= NULL
, NULL
);
1436 if (*identifier
!= '#')
1437 return folder_find_item_from_path(identifier
);
1439 Xstrdup_a(str
, identifier
, return NULL
);
1441 p
= strchr(str
, '/');
1443 return folder_find_item_from_path(identifier
);
1446 class = folder_get_class_from_string(&str
[1]);
1448 return folder_find_item_from_path(identifier
);
1453 return folder_find_item_from_path(identifier
);
1457 folder
= folder_find_from_name(name
, class);
1459 return folder_find_item_from_path(identifier
);
1463 d
[0] = (gpointer
)path
;
1465 g_node_traverse(folder
->node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, -1,
1466 folder_item_find_func
, d
);
1470 /** Returns the FolderItem from a given identifier
1472 * The FolderItem is created if it doesn't already exist.
1473 * If creation failed, the function returns NULL.
1475 * Identifiers are of the form #type/Mailbox/FolderA/FolderB/FolderC
1477 FolderItem
*folder_get_item_from_identifier(const gchar
*identifier
)
1479 FolderItem
*item
, *last_parent
;
1481 gchar
*p1
, *p2
, *str
;
1484 gboolean created_something
= FALSE
;
1486 item
= folder_find_item_from_identifier(identifier
);
1490 /* trivial sanity check: need at least # and two slashes */
1491 len
= strlen(identifier
);
1495 /* make sure identifier ends with a slash */
1496 if(identifier
[len
-1] == G_DIR_SEPARATOR
) {
1497 Xstrdup_a(str
, identifier
, return NULL
);
1500 Xstrndup_a(str
, identifier
, len
+1, return NULL
);
1501 str
[len
] = G_DIR_SEPARATOR
;
1504 /* find folder class */
1505 p1
= strchr(str
, G_DIR_SEPARATOR
);
1509 class = folder_get_class_from_string(&str
[1]);
1512 *p1
= G_DIR_SEPARATOR
;
1515 /* find folder from class and name */
1516 p2
= strchr(p1
, G_DIR_SEPARATOR
);
1520 folder
= folder_find_from_name(p1
, class);
1523 *p2
= G_DIR_SEPARATOR
;
1527 /* Now, move forward and make sure all sections in the path exist */
1528 last_parent
= folder
->node
->data
;
1529 while((p1
= strchr(p1
, G_DIR_SEPARATOR
)) != NULL
) {
1531 item
= folder_find_item_from_identifier(str
);
1533 item
= folder_create_folder(last_parent
, p2
);
1536 debug_print("Created folder '%s'\n", str
);
1537 created_something
= TRUE
;
1538 if(prefs_common
.inherit_folder_props
&& (last_parent
!= item
->folder
->node
->data
)) {
1539 folder_item_prefs_copy_prefs(last_parent
, item
);
1543 *p1
= G_DIR_SEPARATOR
;
1548 if(created_something
)
1549 folder_write_list();
1556 * Get a displayable name for a FolderItem
1558 * \param item FolderItem for that a name should be created
1559 * \return Displayable name for item, returned string has to
1562 gchar
*folder_item_get_name(FolderItem
*item
)
1566 cm_return_val_if_fail(item
!= NULL
, g_strdup(""));
1568 switch (item
->stype
) {
1570 name
= g_strdup(!strcmp2(item
->name
, INBOX_DIR
) ? _("Inbox") :
1574 name
= g_strdup(!strcmp2(item
->name
, OUTBOX_DIR
) ? _("Sent") :
1578 name
= g_strdup(!strcmp2(item
->name
, QUEUE_DIR
) ? _("Queue") :
1582 name
= g_strdup(!strcmp2(item
->name
, TRASH_DIR
) ? _("Trash") :
1586 name
= g_strdup(!strcmp2(item
->name
, DRAFT_DIR
) ? _("Drafts") :
1595 * should probably be done by a virtual function,
1596 * the folder knows the ui string and how to abbrev
1598 if (folder_item_parent(item
) == NULL
) {
1599 name
= g_strconcat(item
->name
, " (", item
->folder
->klass
->uistr
, ")", NULL
);
1601 if (FOLDER_CLASS(item
->folder
) == news_get_class() &&
1602 item
->path
&& !strcmp2(item
->name
, item
->path
))
1603 name
= get_abbrev_newsgroup_name
1605 prefs_common
.ng_abbrev_len
);
1607 name
= g_strdup(item
->name
);
1612 name
= g_strdup("");
1617 gboolean
folder_have_mailbox (void)
1620 for (cur
= folder_list
; cur
!= NULL
; cur
= g_list_next(cur
)) {
1621 Folder
*folder
= FOLDER(cur
->data
);
1622 if (folder
->inbox
&& folder
->outbox
)
1628 FolderItem
*folder_get_default_inbox(void)
1632 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1633 Folder
* folder
= FOLDER(flist
->data
);
1637 if (folder
->inbox
== NULL
)
1639 if (folder
->klass
->type
== F_UNKNOWN
)
1642 return folder
->inbox
;
1648 FolderItem
*folder_get_default_inbox_for_class(FolderType type
)
1652 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1653 Folder
* folder
= FOLDER(flist
->data
);
1657 if (folder
->inbox
== NULL
)
1659 if (folder
->klass
->type
!= type
)
1662 return folder
->inbox
;
1668 FolderItem
*folder_get_default_outbox(void)
1672 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1673 Folder
* folder
= FOLDER(flist
->data
);
1677 if (folder
->outbox
== NULL
)
1679 if (folder
->klass
->type
== F_UNKNOWN
)
1682 return folder
->outbox
;
1688 FolderItem
*folder_get_default_outbox_for_class(FolderType type
)
1692 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1693 Folder
* folder
= FOLDER(flist
->data
);
1697 if (folder
->outbox
== NULL
)
1699 if (folder
->klass
->type
!= type
)
1702 return folder
->outbox
;
1708 FolderItem
*folder_get_default_draft(void)
1712 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1713 Folder
* folder
= FOLDER(flist
->data
);
1717 if (folder
->draft
== NULL
)
1719 if (folder
->klass
->type
== F_UNKNOWN
)
1722 return folder
->draft
;
1728 FolderItem
*folder_get_default_draft_for_class(FolderType type
)
1732 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1733 Folder
* folder
= FOLDER(flist
->data
);
1737 if (folder
->draft
== NULL
)
1739 if (folder
->klass
->type
!= type
)
1742 return folder
->draft
;
1748 FolderItem
*folder_get_default_queue(void)
1752 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1753 Folder
* folder
= FOLDER(flist
->data
);
1757 if (folder
->queue
== NULL
)
1759 if (folder
->klass
->type
== F_UNKNOWN
)
1762 return folder
->queue
;
1768 FolderItem
*folder_get_default_queue_for_class(FolderType type
)
1772 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1773 Folder
* folder
= FOLDER(flist
->data
);
1777 if (folder
->queue
== NULL
)
1779 if (folder
->klass
->type
!= type
)
1782 return folder
->queue
;
1788 FolderItem
*folder_get_default_trash(void)
1792 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1793 Folder
* folder
= FOLDER(flist
->data
);
1797 if (folder
->trash
== NULL
)
1799 if (folder
->klass
->type
== F_UNKNOWN
)
1802 return folder
->trash
;
1808 FolderItem
*folder_get_default_trash_for_class(FolderType type
)
1812 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1813 Folder
* folder
= FOLDER(flist
->data
);
1817 if (folder
->trash
== NULL
)
1819 if (folder
->klass
->type
!= type
)
1822 return folder
->trash
;
1828 #define CREATE_FOLDER_IF_NOT_EXIST(member, dir, type) \
1830 if (!folder->member) { \
1831 item = folder_item_new(folder, dir, dir); \
1832 item->stype = type; \
1833 folder_item_append(rootitem, item); \
1834 folder->member = item; \
1838 void folder_set_missing_folders(void)
1841 FolderItem
*rootitem
;
1845 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1846 folder
= list
->data
;
1847 if (FOLDER_TYPE(folder
) != F_MH
) continue;
1848 rootitem
= FOLDER_ITEM(folder
->node
->data
);
1849 cm_return_if_fail(rootitem
!= NULL
);
1851 if (folder
->inbox
&& folder
->outbox
&& folder
->draft
&&
1852 folder
->queue
&& folder
->trash
)
1855 if (folder
->klass
->create_tree(folder
) < 0) {
1856 g_warning("%s: can't create the folder tree.",
1857 LOCAL_FOLDER(folder
)->rootpath
);
1861 CREATE_FOLDER_IF_NOT_EXIST(inbox
, INBOX_DIR
, F_INBOX
);
1862 CREATE_FOLDER_IF_NOT_EXIST(outbox
, OUTBOX_DIR
, F_OUTBOX
);
1863 CREATE_FOLDER_IF_NOT_EXIST(draft
, DRAFT_DIR
, F_DRAFT
);
1864 CREATE_FOLDER_IF_NOT_EXIST(queue
, QUEUE_DIR
, F_QUEUE
);
1865 CREATE_FOLDER_IF_NOT_EXIST(trash
, TRASH_DIR
, F_TRASH
);
1869 static gboolean
folder_unref_account_func(GNode
*node
, gpointer data
)
1871 FolderItem
*item
= node
->data
;
1872 PrefsAccount
*account
= data
;
1874 if (item
->account
== account
)
1875 item
->account
= NULL
;
1880 void folder_unref_account_all(PrefsAccount
*account
)
1885 if (!account
) return;
1887 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1888 folder
= list
->data
;
1889 if (folder
->account
== account
)
1890 folder
->account
= NULL
;
1891 g_node_traverse(folder
->node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, -1,
1892 folder_unref_account_func
, account
);
1896 #undef CREATE_FOLDER_IF_NOT_EXIST
1898 gchar
*folder_item_get_path(FolderItem
*item
)
1902 cm_return_val_if_fail(item
!= NULL
, NULL
);
1903 folder
= item
->folder
;
1904 cm_return_val_if_fail(folder
!= NULL
, NULL
);
1906 return folder
->klass
->item_get_path(folder
, item
);
1909 static gint
folder_sort_cache_list_by_msgnum(gconstpointer a
, gconstpointer b
)
1911 MsgInfo
*msginfo_a
= (MsgInfo
*) a
;
1912 MsgInfo
*msginfo_b
= (MsgInfo
*) b
;
1914 return (msginfo_a
->msgnum
- msginfo_b
->msgnum
);
1917 static gint
folder_sort_folder_list(gconstpointer a
, gconstpointer b
)
1919 guint gint_a
= GPOINTER_TO_INT(a
);
1920 guint gint_b
= GPOINTER_TO_INT(b
);
1922 return (gint_a
- gint_b
);
1925 static gint
syncronize_flags(FolderItem
*item
, MsgInfoList
*msglist
)
1927 GHashTable
*relation
;
1933 if(item
->folder
->klass
->get_flags
== NULL
)
1935 if (item
->no_select
)
1938 relation
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
1939 if ((ret
= item
->folder
->klass
->get_flags(
1940 item
->folder
, item
, msglist
, relation
)) == 0) {
1941 gpointer data
, old_key
;
1943 MsgPermFlags permflags
= 0;
1945 folder_item_update_freeze();
1946 folder_item_set_batch(item
, TRUE
);
1947 for (cur
= msglist
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
1948 msginfo
= (MsgInfo
*) cur
->data
;
1950 if (g_hash_table_lookup_extended(relation
, msginfo
, &old_key
, &data
)) {
1951 permflags
= GPOINTER_TO_INT(data
);
1953 if (msginfo
->flags
.perm_flags
!= permflags
) {
1954 procmsg_msginfo_change_flags(msginfo
,
1955 permflags
& ~msginfo
->flags
.perm_flags
, 0,
1956 ~permflags
& msginfo
->flags
.perm_flags
, 0);
1960 folder_item_set_batch(item
, FALSE
);
1961 folder_item_update_thaw();
1963 g_hash_table_destroy(relation
);
1968 static gint
folder_item_syncronize_flags(FolderItem
*item
)
1970 MsgInfoList
*msglist
= NULL
;
1974 cm_return_val_if_fail(item
!= NULL
, -1);
1975 cm_return_val_if_fail(item
->folder
!= NULL
, -1);
1976 cm_return_val_if_fail(item
->folder
->klass
!= NULL
, -1);
1977 if (item
->no_select
)
1980 item
->scanning
= ITEM_SCANNING_WITH_FLAGS
;
1982 if (item
->cache
== NULL
)
1983 folder_item_read_cache(item
);
1985 msglist
= msgcache_get_msg_list(item
->cache
);
1987 ret
= syncronize_flags(item
, msglist
);
1989 for (cur
= msglist
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
1990 procmsg_msginfo_free((MsgInfo
**)&(cur
->data
));
1993 g_slist_free(msglist
);
1995 item
->scanning
= ITEM_NOT_SCANNING
;
2000 static void folder_item_process_open (FolderItem
*item
,
2001 void (*before_proc_func
)(gpointer data
),
2002 void (*after_proc_func
)(gpointer data
),
2008 if((item
->folder
->klass
->scan_required
!= NULL
) &&
2009 (item
->folder
->klass
->scan_required(item
->folder
, item
))) {
2010 folder_item_scan_full(item
, TRUE
);
2012 folder_item_syncronize_flags(item
);
2016 if (item
->prefs
->enable_processing_when_opening
) {
2017 buf
= g_strdup_printf(_("Processing (%s)...\n"),
2018 item
->path
? item
->path
: item
->name
);
2021 if (before_proc_func
)
2022 before_proc_func(data
);
2024 folder_item_apply_processing(item
);
2026 if (after_proc_func
)
2027 after_proc_func(data
);
2029 item
->processing_pending
= FALSE
;
2033 gint
folder_item_open(FolderItem
*item
)
2036 if (item
->no_select
)
2039 if (item
->scanning
!= ITEM_NOT_SCANNING
) {
2040 debug_print("%s is scanning... \n", item
->path
? item
->path
: item
->name
);
2044 item
->processing_pending
= TRUE
;
2045 folder_item_process_open (item
, NULL
, NULL
, NULL
);
2047 item
->opened
= TRUE
;
2052 gint
folder_item_close(FolderItem
*item
)
2054 GSList
*mlist
, *cur
;
2057 cm_return_val_if_fail(item
!= NULL
, -1);
2059 if (item
->no_select
)
2062 if (item
->new_msgs
) {
2063 folder_item_update_freeze();
2064 mlist
= folder_item_get_msg_list(item
);
2065 for (cur
= mlist
; cur
!= NULL
; cur
= cur
->next
) {
2068 msginfo
= (MsgInfo
*) cur
->data
;
2069 if (MSG_IS_NEW(msginfo
->flags
))
2070 procmsg_msginfo_unset_flags(msginfo
, MSG_NEW
, 0);
2071 procmsg_msginfo_free(&msginfo
);
2073 g_slist_free(mlist
);
2074 folder_item_update_thaw();
2077 folder_item_write_cache(item
);
2079 folder_item_update(item
, F_ITEM_UPDATE_MSGCNT
);
2081 item
->opened
= FALSE
;
2082 folder
= item
->folder
;
2084 if (folder
->klass
->close
== NULL
)
2087 return folder
->klass
->close(folder
, item
);
2090 static MsgInfoList
*get_msginfos(FolderItem
*item
, MsgNumberList
*numlist
)
2092 MsgInfoList
*msglist
= NULL
;
2093 Folder
*folder
= item
->folder
;
2094 if (item
->no_select
)
2097 if (folder
->klass
->get_msginfos
!= NULL
)
2098 msglist
= folder
->klass
->get_msginfos(folder
, item
, numlist
);
2100 MsgNumberList
*elem
;
2102 for (elem
= numlist
; elem
!= NULL
; elem
= g_slist_next(elem
)) {
2106 num
= GPOINTER_TO_INT(elem
->data
);
2107 msginfo
= folder
->klass
->get_msginfo(folder
, item
, num
);
2108 if (msginfo
!= NULL
)
2109 msglist
= g_slist_prepend(msglist
, msginfo
);
2116 static MsgInfo
*get_msginfo(FolderItem
*item
, guint num
)
2118 MsgNumberList numlist
;
2119 MsgInfoList
*msglist
;
2120 MsgInfo
*msginfo
= NULL
;
2122 numlist
.data
= GINT_TO_POINTER(num
);
2123 numlist
.next
= NULL
;
2124 msglist
= get_msginfos(item
, &numlist
);
2125 if (msglist
!= NULL
)
2126 msginfo
= procmsg_msginfo_new_ref(msglist
->data
);
2127 procmsg_msg_list_free(msglist
);
2132 gint
folder_item_scan_full(FolderItem
*item
, gboolean filtering
)
2135 GSList
*folder_list
= NULL
, *cache_list
= NULL
;
2136 GSList
*folder_list_cur
, *cache_list_cur
, *new_list
= NULL
;
2137 GSList
*exists_list
= NULL
, *elem
;
2138 GSList
*newmsg_list
= NULL
;
2139 guint newcnt
= 0, unreadcnt
= 0, totalcnt
= 0;
2140 guint markedcnt
= 0, unreadmarkedcnt
= 0;
2141 guint repliedcnt
= 0, forwardedcnt
= 0;
2142 guint lockedcnt
= 0, ignoredcnt
= 0, watchedcnt
= 0;
2144 guint cache_max_num
, folder_max_num
, cache_cur_num
, folder_cur_num
;
2145 gboolean update_flags
= 0, old_uids_valid
= FALSE
;
2146 GHashTable
*subject_table
= NULL
;
2148 cm_return_val_if_fail(item
!= NULL
, -1);
2149 if (item
->path
== NULL
) return -1;
2151 folder
= item
->folder
;
2153 cm_return_val_if_fail(folder
!= NULL
, -1);
2154 cm_return_val_if_fail(folder
->klass
->get_num_list
!= NULL
, -1);
2156 item
->scanning
= ITEM_SCANNING_WITH_FLAGS
;
2158 debug_print("Scanning folder %s for cache changes.\n", item
->path
? item
->path
: "(null)");
2160 /* Get list of messages for folder and cache */
2161 if (folder
->klass
->get_num_list(item
->folder
, item
, &folder_list
, &old_uids_valid
) < 0) {
2162 debug_print("Error fetching list of message numbers\n");
2163 item
->scanning
= ITEM_NOT_SCANNING
;
2167 if(prefs_common
.thread_by_subject
) {
2168 subject_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
2171 if (old_uids_valid
) {
2173 folder_item_read_cache(item
);
2174 cache_list
= msgcache_get_msg_list(item
->cache
);
2177 msgcache_destroy(item
->cache
);
2178 item
->cache
= msgcache_new();
2179 item
->cache_dirty
= TRUE
;
2180 item
->mark_dirty
= TRUE
;
2181 item
->tags_dirty
= TRUE
;
2185 /* Sort both lists */
2186 cache_list
= g_slist_sort(cache_list
, folder_sort_cache_list_by_msgnum
);
2187 folder_list
= g_slist_sort(folder_list
, folder_sort_folder_list
);
2189 cache_list_cur
= cache_list
;
2190 folder_list_cur
= folder_list
;
2192 if (cache_list_cur
!= NULL
) {
2193 GSList
*cache_list_last
;
2195 cache_cur_num
= ((MsgInfo
*)cache_list_cur
->data
)->msgnum
;
2196 cache_list_last
= g_slist_last(cache_list
);
2197 cache_max_num
= ((MsgInfo
*)cache_list_last
->data
)->msgnum
;
2199 cache_cur_num
= G_MAXUINT
;
2203 if (folder_list_cur
!= NULL
) {
2204 GSList
*folder_list_last
;
2206 folder_cur_num
= GPOINTER_TO_UINT(folder_list_cur
->data
);
2207 folder_list_last
= g_slist_last(folder_list
);
2208 folder_max_num
= GPOINTER_TO_UINT(folder_list_last
->data
);
2210 folder_cur_num
= G_MAXUINT
;
2214 while ((cache_cur_num
!= G_MAXUINT
) || (folder_cur_num
!= G_MAXUINT
)) {
2216 * Message only exists in the folder
2217 * Remember message for fetching
2219 if (folder_cur_num
< cache_cur_num
) {
2220 gboolean add
= FALSE
;
2222 switch(FOLDER_TYPE(folder
)) {
2224 if (folder_cur_num
< cache_max_num
)
2227 if (folder
->account
->max_articles
== 0) {
2231 if (folder_max_num
<= folder
->account
->max_articles
) {
2233 } else if (folder_cur_num
> (folder_max_num
- folder
->account
->max_articles
)) {
2243 new_list
= g_slist_prepend(new_list
, GUINT_TO_POINTER(folder_cur_num
));
2244 debug_print("Remembered message %u for fetching\n", folder_cur_num
);
2247 /* Move to next folder number */
2248 if (folder_list_cur
)
2249 folder_list_cur
= folder_list_cur
->next
;
2251 if (folder_list_cur
!= NULL
)
2252 folder_cur_num
= GPOINTER_TO_UINT(folder_list_cur
->data
);
2254 folder_cur_num
= G_MAXUINT
;
2260 * Message only exists in the cache
2261 * Remove the message from the cache
2263 if (cache_cur_num
< folder_cur_num
) {
2264 msgcache_remove_msg(item
->cache
, cache_cur_num
);
2265 debug_print("Removed message %u from cache.\n", cache_cur_num
);
2267 /* Move to next cache number */
2269 cache_list_cur
= cache_list_cur
->next
;
2271 if (cache_list_cur
!= NULL
)
2272 cache_cur_num
= ((MsgInfo
*)cache_list_cur
->data
)->msgnum
;
2274 cache_cur_num
= G_MAXUINT
;
2276 update_flags
|= F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
;
2282 * Message number exists in folder and cache!
2283 * Check if the message has been modified
2285 if (cache_cur_num
== folder_cur_num
) {
2288 msginfo
= msgcache_get_msg(item
->cache
, folder_cur_num
);
2289 if (msginfo
&& folder
->klass
->is_msg_changed
&& folder
->klass
->is_msg_changed(folder
, item
, msginfo
)) {
2290 msgcache_remove_msg(item
->cache
, msginfo
->msgnum
);
2291 new_list
= g_slist_prepend(new_list
, GINT_TO_POINTER(msginfo
->msgnum
));
2292 procmsg_msginfo_free(&msginfo
);
2294 debug_print("Remembering message %u to update...\n", folder_cur_num
);
2295 } else if (msginfo
) {
2296 exists_list
= g_slist_prepend(exists_list
, msginfo
);
2298 if(prefs_common
.thread_by_subject
&&
2299 MSG_IS_IGNORE_THREAD(msginfo
->flags
) &&
2300 !subject_table_lookup(subject_table
, msginfo
->subject
)) {
2301 subject_table_insert(subject_table
, msginfo
->subject
, msginfo
);
2305 /* Move to next folder and cache number */
2307 cache_list_cur
= cache_list_cur
->next
;
2309 if (folder_list_cur
)
2310 folder_list_cur
= folder_list_cur
->next
;
2312 if (cache_list_cur
!= NULL
)
2313 cache_cur_num
= ((MsgInfo
*)cache_list_cur
->data
)->msgnum
;
2315 cache_cur_num
= G_MAXUINT
;
2317 if (folder_list_cur
!= NULL
)
2318 folder_cur_num
= GPOINTER_TO_UINT(folder_list_cur
->data
);
2320 folder_cur_num
= G_MAXUINT
;
2326 for(cache_list_cur
= cache_list
; cache_list_cur
!= NULL
; cache_list_cur
= g_slist_next(cache_list_cur
))
2327 procmsg_msginfo_free((MsgInfo
**)&(cache_list_cur
->data
));
2329 g_slist_free(cache_list
);
2330 g_slist_free(folder_list
);
2332 if (new_list
!= NULL
) {
2333 GSList
*tmp_list
= NULL
;
2334 newmsg_list
= get_msginfos(item
, new_list
);
2335 g_slist_free(new_list
);
2336 tmp_list
= g_slist_concat(g_slist_copy(exists_list
), g_slist_copy(newmsg_list
));
2337 syncronize_flags(item
, tmp_list
);
2338 g_slist_free(tmp_list
);
2340 syncronize_flags(item
, exists_list
);
2343 folder_item_update_freeze();
2345 item
->scanning
= ITEM_SCANNING
;
2347 if (newmsg_list
!= NULL
) {
2348 GSList
*elem
, *to_filter
= NULL
;
2349 gboolean do_filter
= (filtering
== TRUE
) &&
2350 (item
->stype
== F_INBOX
) &&
2351 (item
->folder
->account
!= NULL
) &&
2352 (item
->folder
->account
->filter_on_recv
);
2354 for (elem
= newmsg_list
; elem
!= NULL
; elem
= g_slist_next(elem
)) {
2355 MsgInfo
*msginfo
= (MsgInfo
*) elem
->data
;
2357 msgcache_add_msg(item
->cache
, msginfo
);
2359 exists_list
= g_slist_prepend(exists_list
, msginfo
);
2361 if(prefs_common
.thread_by_subject
&&
2362 MSG_IS_IGNORE_THREAD(msginfo
->flags
) &&
2363 !subject_table_lookup(subject_table
, msginfo
->subject
)) {
2364 subject_table_insert(subject_table
, msginfo
->subject
, msginfo
);
2372 folder_item_set_batch(item
, TRUE
);
2373 procmsg_msglist_filter(newmsg_list
, item
->folder
->account
,
2374 &to_filter
, &unfiltered
,
2376 folder_item_set_batch(item
, FALSE
);
2378 filtering_move_and_copy_msgs(newmsg_list
);
2379 if (to_filter
!= NULL
) {
2380 for (elem
= to_filter
; elem
; elem
= g_slist_next(elem
)) {
2381 MsgInfo
*msginfo
= (MsgInfo
*)elem
->data
;
2382 procmsg_msginfo_free(&msginfo
);
2384 g_slist_free(to_filter
);
2386 if (unfiltered
!= NULL
) {
2387 for (elem
= unfiltered
; elem
; elem
= g_slist_next(elem
)) {
2388 MsgInfo
*msginfo
= (MsgInfo
*)elem
->data
;
2389 exists_list
= g_slist_prepend(exists_list
, msginfo
);
2391 if(prefs_common
.thread_by_subject
&&
2392 MSG_IS_IGNORE_THREAD(msginfo
->flags
) &&
2393 !subject_table_lookup(subject_table
, msginfo
->subject
)) {
2394 subject_table_insert(subject_table
, msginfo
->subject
, msginfo
);
2397 g_slist_free(unfiltered
);
2399 if (prefs_common
.real_time_sync
)
2400 folder_item_synchronise(item
);
2402 if (prefs_common
.real_time_sync
)
2403 folder_item_synchronise(item
);
2406 g_slist_free(newmsg_list
);
2408 update_flags
|= F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
;
2411 folder_item_set_batch(item
, TRUE
);
2412 for (elem
= exists_list
; elem
!= NULL
; elem
= g_slist_next(elem
)) {
2413 MsgInfo
*msginfo
, *parent_msginfo
;
2415 msginfo
= elem
->data
;
2416 if (MSG_IS_IGNORE_THREAD(msginfo
->flags
) && (MSG_IS_NEW(msginfo
->flags
) || MSG_IS_UNREAD(msginfo
->flags
)))
2417 procmsg_msginfo_unset_flags(msginfo
, MSG_NEW
| MSG_UNREAD
, 0);
2418 if (!MSG_IS_IGNORE_THREAD(msginfo
->flags
) && procmsg_msg_has_flagged_parent(msginfo
, MSG_IGNORE_THREAD
)) {
2419 procmsg_msginfo_change_flags(msginfo
, MSG_IGNORE_THREAD
, 0, MSG_NEW
| MSG_UNREAD
, 0);
2421 if (!MSG_IS_WATCH_THREAD(msginfo
->flags
) && procmsg_msg_has_flagged_parent(msginfo
, MSG_WATCH_THREAD
)) {
2422 procmsg_msginfo_set_flags(msginfo
, MSG_WATCH_THREAD
, 0);
2424 if(prefs_common
.thread_by_subject
&& !msginfo
->inreplyto
&&
2425 !msginfo
->references
&& !MSG_IS_IGNORE_THREAD(msginfo
->flags
) &&
2426 (parent_msginfo
= subject_table_lookup(subject_table
, msginfo
->subject
)))
2428 if(MSG_IS_IGNORE_THREAD(parent_msginfo
->flags
)) {
2429 procmsg_msginfo_change_flags(msginfo
, MSG_IGNORE_THREAD
, 0,
2430 MSG_NEW
| MSG_UNREAD
, 0);
2433 if ((folder_has_parent_of_type(item
, F_OUTBOX
) ||
2434 folder_has_parent_of_type(item
, F_QUEUE
) ||
2435 folder_has_parent_of_type(item
, F_TRASH
)) &&
2436 (MSG_IS_NEW(msginfo
->flags
) || MSG_IS_UNREAD(msginfo
->flags
)))
2437 procmsg_msginfo_unset_flags(msginfo
, MSG_NEW
| MSG_UNREAD
, 0);
2438 if (MSG_IS_NEW(msginfo
->flags
))
2440 if (MSG_IS_UNREAD(msginfo
->flags
))
2442 if (MSG_IS_UNREAD(msginfo
->flags
) && procmsg_msg_has_marked_parent(msginfo
))
2444 if (MSG_IS_MARKED(msginfo
->flags
))
2446 if (MSG_IS_REPLIED(msginfo
->flags
))
2448 if (MSG_IS_FORWARDED(msginfo
->flags
))
2450 if (MSG_IS_LOCKED(msginfo
->flags
))
2452 if (MSG_IS_IGNORE_THREAD(msginfo
->flags
))
2454 if (MSG_IS_WATCH_THREAD(msginfo
->flags
))
2459 procmsg_msginfo_free(&msginfo
);
2461 folder_item_set_batch(item
, FALSE
);
2462 g_slist_free(exists_list
);
2464 if(prefs_common
.thread_by_subject
) {
2465 g_hash_table_destroy(subject_table
);
2468 if (item
->new_msgs
!= newcnt
|| item
->unread_msgs
!= unreadcnt
2469 || item
->total_msgs
!= totalcnt
|| item
->marked_msgs
!= markedcnt
2470 || item
->unreadmarked_msgs
!= unreadmarkedcnt
2471 || item
->replied_msgs
!= repliedcnt
|| item
->forwarded_msgs
!= forwardedcnt
2472 || item
->locked_msgs
!= lockedcnt
|| item
->ignored_msgs
!= ignoredcnt
2473 || item
->watched_msgs
!= watchedcnt
) {
2474 update_flags
|= F_ITEM_UPDATE_CONTENT
;
2477 item
->new_msgs
= newcnt
;
2478 item
->unread_msgs
= unreadcnt
;
2479 item
->total_msgs
= totalcnt
;
2480 item
->unreadmarked_msgs
= unreadmarkedcnt
;
2481 item
->marked_msgs
= markedcnt
;
2482 item
->replied_msgs
= repliedcnt
;
2483 item
->forwarded_msgs
= forwardedcnt
;
2484 item
->locked_msgs
= lockedcnt
;
2485 item
->ignored_msgs
= ignoredcnt
;
2486 item
->watched_msgs
= watchedcnt
;
2488 update_flags
|= F_ITEM_UPDATE_MSGCNT
;
2490 folder_item_update(item
, update_flags
);
2491 folder_item_update_thaw();
2493 item
->scanning
= ITEM_NOT_SCANNING
;
2498 gint
folder_item_scan(FolderItem
*item
)
2500 return folder_item_scan_full(item
, TRUE
);
2503 static void folder_count_total_cache_memusage(FolderItem
*item
, gpointer data
)
2505 gint
*memusage
= (gint
*)data
;
2507 if (item
->cache
== NULL
)
2510 *memusage
+= msgcache_get_memory_usage(item
->cache
);
2513 static gint
folder_cache_time_compare_func(gconstpointer a
, gconstpointer b
)
2515 FolderItem
*fa
= (FolderItem
*)a
;
2516 FolderItem
*fb
= (FolderItem
*)b
;
2518 return (gint
) (msgcache_get_last_access_time(fa
->cache
) - msgcache_get_last_access_time(fb
->cache
));
2521 static void folder_find_expired_caches(FolderItem
*item
, gpointer data
)
2523 GSList
**folder_item_list
= (GSList
**)data
;
2524 gint difftime
, expiretime
;
2526 if (item
->cache
== NULL
)
2529 if (item
->opened
> 0)
2532 difftime
= (gint
) (time(NULL
) - msgcache_get_last_access_time(item
->cache
));
2533 expiretime
= prefs_common
.cache_min_keep_time
* 60;
2534 debug_print("Cache unused time: %d (Expire time: %d)\n", difftime
, expiretime
);
2536 if (difftime
> expiretime
&& !item
->opened
&& !item
->processing_pending
) {
2537 *folder_item_list
= g_slist_insert_sorted(*folder_item_list
, item
, folder_cache_time_compare_func
);
2541 gboolean
folder_item_free_cache(FolderItem
*item
, gboolean force
)
2543 cm_return_val_if_fail(item
!= NULL
, TRUE
);
2545 if (item
->cache
== NULL
)
2548 if (item
->opened
> 0 && !force
)
2551 folder_item_write_cache(item
);
2552 msgcache_destroy(item
->cache
);
2557 void folder_clean_cache_memory_force(void)
2559 int old_cache_max_mem_usage
= prefs_common
.cache_max_mem_usage
;
2560 int old_cache_min_keep_time
= prefs_common
.cache_min_keep_time
;
2562 prefs_common
.cache_max_mem_usage
= 0;
2563 prefs_common
.cache_min_keep_time
= 0;
2565 folder_clean_cache_memory(NULL
);
2567 prefs_common
.cache_max_mem_usage
= old_cache_max_mem_usage
;
2568 prefs_common
.cache_min_keep_time
= old_cache_min_keep_time
;
2571 void folder_clean_cache_memory(FolderItem
*protected_item
)
2575 folder_func_to_all_folders(folder_count_total_cache_memusage
, &memusage
);
2576 debug_print("Total cache memory usage: %d\n", memusage
);
2578 if (memusage
> (prefs_common
.cache_max_mem_usage
* 1024)) {
2579 GSList
*folder_item_list
= NULL
, *listitem
;
2581 debug_print("Trying to free cache memory\n");
2583 folder_func_to_all_folders(folder_find_expired_caches
, &folder_item_list
);
2584 listitem
= folder_item_list
;
2585 while((listitem
!= NULL
) && (memusage
> (prefs_common
.cache_max_mem_usage
* 1024))) {
2586 FolderItem
*item
= (FolderItem
*)(listitem
->data
);
2587 gint cache_size
= 0;
2588 if (item
== protected_item
) {
2589 listitem
= listitem
->next
;
2592 debug_print("Freeing cache memory for %s\n", item
->path
? item
->path
: item
->name
);
2593 cache_size
= msgcache_get_memory_usage(item
->cache
);
2594 if (folder_item_free_cache(item
, FALSE
))
2595 memusage
-= cache_size
;
2597 listitem
= listitem
->next
;
2599 g_slist_free(folder_item_list
);
2603 static void folder_item_remove_cached_msg(FolderItem
*item
, MsgInfo
*msginfo
)
2605 Folder
*folder
= item
->folder
;
2607 cm_return_if_fail(folder
!= NULL
);
2609 if (folder
->klass
->remove_cached_msg
== NULL
)
2612 folder
->klass
->remove_cached_msg(folder
, item
, msginfo
);
2615 static void folder_item_clean_local_files(FolderItem
*item
, gint days
)
2617 cm_return_if_fail(item
!= NULL
);
2618 cm_return_if_fail(item
->folder
!= NULL
);
2620 if (FOLDER_TYPE(item
->folder
) == F_IMAP
||
2621 FOLDER_TYPE(item
->folder
) == F_NEWS
) {
2622 GSList
*msglist
= folder_item_get_msg_list(item
);
2624 time_t t
= time(NULL
);
2625 for (cur
= msglist
; cur
; cur
= cur
->next
) {
2626 MsgInfo
*msginfo
= (MsgInfo
*)cur
->data
;
2627 gint age
= (t
- msginfo
->date_t
) / (60*60*24);
2629 folder_item_remove_cached_msg(item
, msginfo
);
2631 procmsg_msg_list_free(msglist
);
2635 static void folder_item_read_cache(FolderItem
*item
)
2637 gchar
*cache_file
, *mark_file
, *tags_file
;
2639 cm_return_if_fail(item
!= NULL
);
2641 if (item
->path
!= NULL
) {
2642 cache_file
= folder_item_get_cache_file(item
);
2643 mark_file
= folder_item_get_mark_file(item
);
2644 tags_file
= folder_item_get_tags_file(item
);
2645 item
->cache
= msgcache_read_cache(item
, cache_file
);
2646 item
->cache_dirty
= FALSE
;
2647 item
->mark_dirty
= FALSE
;
2648 item
->tags_dirty
= FALSE
;
2650 MsgInfoList
*list
, *cur
;
2651 guint newcnt
= 0, unreadcnt
= 0;
2652 guint markedcnt
= 0, unreadmarkedcnt
= 0;
2653 guint repliedcnt
= 0, forwardedcnt
= 0;
2654 guint lockedcnt
= 0, ignoredcnt
= 0;
2655 guint watchedcnt
= 0;
2658 item
->cache
= msgcache_new();
2659 item
->cache_dirty
= TRUE
;
2660 item
->mark_dirty
= TRUE
;
2661 item
->tags_dirty
= TRUE
;
2662 folder_item_scan_full(item
, TRUE
);
2664 msgcache_read_mark(item
->cache
, mark_file
);
2666 list
= msgcache_get_msg_list(item
->cache
);
2667 for (cur
= list
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
2668 msginfo
= cur
->data
;
2670 if (MSG_IS_NEW(msginfo
->flags
))
2672 if (MSG_IS_UNREAD(msginfo
->flags
))
2674 if (MSG_IS_UNREAD(msginfo
->flags
) && procmsg_msg_has_marked_parent(msginfo
))
2676 if (MSG_IS_MARKED(msginfo
->flags
))
2678 if (MSG_IS_REPLIED(msginfo
->flags
))
2680 if (MSG_IS_FORWARDED(msginfo
->flags
))
2682 if (MSG_IS_LOCKED(msginfo
->flags
))
2684 if (MSG_IS_IGNORE_THREAD(msginfo
->flags
))
2686 if (MSG_IS_WATCH_THREAD(msginfo
->flags
))
2688 procmsg_msginfo_unset_flags(msginfo
, MSG_FULLY_CACHED
, 0);
2690 item
->new_msgs
= newcnt
;
2691 item
->unread_msgs
= unreadcnt
;
2692 item
->unreadmarked_msgs
= unreadmarkedcnt
;
2693 item
->marked_msgs
= markedcnt
;
2694 item
->replied_msgs
= repliedcnt
;
2695 item
->forwarded_msgs
= forwardedcnt
;
2696 item
->locked_msgs
= lockedcnt
;
2697 item
->ignored_msgs
= ignoredcnt
;
2698 item
->watched_msgs
= watchedcnt
;
2699 procmsg_msg_list_free(list
);
2701 msgcache_read_mark(item
->cache
, mark_file
);
2703 msgcache_read_tags(item
->cache
, tags_file
);
2709 item
->cache
= msgcache_new();
2710 item
->cache_dirty
= TRUE
;
2711 item
->mark_dirty
= TRUE
;
2712 item
->tags_dirty
= TRUE
;
2716 folder_clean_cache_memory(item
);
2719 void folder_item_write_cache(FolderItem
*item
)
2721 gchar
*cache_file
= NULL
, *mark_file
= NULL
, *tags_file
= NULL
;
2722 FolderItemPrefs
*prefs
;
2725 time_t last_mtime
= (time_t)0;
2726 gboolean need_scan
= FALSE
;
2728 if (!item
|| !item
->path
|| !item
->cache
)
2731 last_mtime
= item
->mtime
;
2732 if (item
->folder
->klass
->set_mtime
) {
2733 if (item
->folder
->klass
->scan_required
)
2734 need_scan
= item
->folder
->klass
->scan_required(item
->folder
, item
);
2739 id
= folder_item_get_identifier(item
);
2740 debug_print("Save cache for folder %s\n", id
);
2743 if (item
->cache_dirty
)
2744 cache_file
= folder_item_get_cache_file(item
);
2745 if (item
->cache_dirty
|| item
->mark_dirty
)
2746 mark_file
= folder_item_get_mark_file(item
);
2747 if (item
->cache_dirty
|| item
->tags_dirty
)
2748 tags_file
= folder_item_get_tags_file(item
);
2749 if (msgcache_write(cache_file
, mark_file
, tags_file
, item
->cache
) < 0) {
2750 prefs
= item
->prefs
;
2751 if (prefs
&& prefs
->enable_folder_chmod
&& prefs
->folder_chmod
) {
2752 /* for cache file */
2753 filemode
= prefs
->folder_chmod
;
2754 if (filemode
& S_IRGRP
) filemode
|= S_IWGRP
;
2755 if (filemode
& S_IROTH
) filemode
|= S_IWOTH
;
2756 if (cache_file
!= NULL
)
2757 chmod(cache_file
, filemode
);
2760 item
->cache_dirty
= FALSE
;
2761 item
->mark_dirty
= FALSE
;
2762 item
->tags_dirty
= FALSE
;
2765 if (!need_scan
&& item
->folder
->klass
->set_mtime
) {
2766 if (item
->mtime
== last_mtime
) {
2767 item
->folder
->klass
->set_mtime(item
->folder
, item
);
2776 MsgInfo
*folder_item_get_msginfo(FolderItem
*item
, gint num
)
2778 MsgInfo
*msginfo
= NULL
;
2780 cm_return_val_if_fail(item
!= NULL
, NULL
);
2781 if (item
->no_select
)
2784 folder_item_read_cache(item
);
2786 if ((msginfo
= msgcache_get_msg(item
->cache
, num
)) != NULL
)
2789 msginfo
= get_msginfo(item
, num
);
2790 if (msginfo
!= NULL
) {
2791 msgcache_add_msg(item
->cache
, msginfo
);
2798 MsgInfo
*folder_item_get_msginfo_by_msgid(FolderItem
*item
, const gchar
*msgid
)
2802 cm_return_val_if_fail(item
!= NULL
, NULL
);
2803 cm_return_val_if_fail(msgid
!= NULL
, NULL
);
2804 if (item
->no_select
)
2808 folder_item_read_cache(item
);
2810 if ((msginfo
= msgcache_get_msg_by_id(item
->cache
, msgid
)) != NULL
)
2816 GSList
*folder_item_get_msg_list(FolderItem
*item
)
2818 cm_return_val_if_fail(item
!= NULL
, NULL
);
2819 if (item
->no_select
)
2822 if (item
->cache
== 0)
2823 folder_item_read_cache(item
);
2825 cm_return_val_if_fail(item
->cache
!= NULL
, NULL
);
2827 return msgcache_get_msg_list(item
->cache
);
2830 static void msginfo_set_mime_flags(GNode
*node
, gpointer data
)
2832 MsgInfo
*msginfo
= data
;
2833 MimeInfo
*mimeinfo
= node
->data
;
2835 if (mimeinfo
->disposition
== DISPOSITIONTYPE_ATTACHMENT
2836 && (!mimeinfo
->subtype
|| (strcmp(mimeinfo
->subtype
, "pgp-signature") &&
2837 strcmp(mimeinfo
->subtype
, "x-pkcs7-signature") &&
2838 strcmp(mimeinfo
->subtype
, "pkcs7-signature")))) {
2839 procmsg_msginfo_set_flags(msginfo
, 0, MSG_HAS_ATTACHMENT
);
2840 } else if (mimeinfo
->disposition
== DISPOSITIONTYPE_UNKNOWN
&&
2841 mimeinfo
->id
== NULL
&&
2842 mimeinfo
->type
!= MIMETYPE_TEXT
&&
2843 mimeinfo
->type
!= MIMETYPE_MULTIPART
) {
2844 if (!mimeinfo
->subtype
2845 || (strcmp(mimeinfo
->subtype
, "pgp-signature") &&
2846 strcmp(mimeinfo
->subtype
, "x-pkcs7-signature") &&
2847 strcmp(mimeinfo
->subtype
, "pkcs7-signature")))
2848 procmsg_msginfo_set_flags(msginfo
, 0, MSG_HAS_ATTACHMENT
);
2849 } else if (mimeinfo
->disposition
== DISPOSITIONTYPE_INLINE
&&
2850 mimeinfo
->id
== NULL
&&
2851 (strcmp(mimeinfo
->subtype
, "pgp-signature") &&
2852 strcmp(mimeinfo
->subtype
, "x-pkcs7-signature") &&
2853 strcmp(mimeinfo
->subtype
, "pkcs7-signature")) &&
2854 (procmime_mimeinfo_get_parameter(mimeinfo
, "name") != NULL
||
2855 procmime_mimeinfo_get_parameter(mimeinfo
, "filename") != NULL
)) {
2856 procmsg_msginfo_set_flags(msginfo
, 0, MSG_HAS_ATTACHMENT
);
2859 /* don't descend below top level message for signed and encrypted info */
2860 if (mimeinfo
->type
== MIMETYPE_MESSAGE
)
2863 if (privacy_mimeinfo_is_signed(mimeinfo
)) {
2864 procmsg_msginfo_set_flags(msginfo
, 0, MSG_SIGNED
);
2867 if (privacy_mimeinfo_is_encrypted(mimeinfo
)) {
2868 procmsg_msginfo_set_flags(msginfo
, 0, MSG_ENCRYPTED
);
2870 /* searching inside encrypted parts doesn't really make sense */
2871 g_node_children_foreach(mimeinfo
->node
, G_TRAVERSE_ALL
, msginfo_set_mime_flags
, msginfo
);
2875 gchar
*folder_item_fetch_msg(FolderItem
*item
, gint num
)
2881 cm_return_val_if_fail(item
!= NULL
, NULL
);
2883 folder
= item
->folder
;
2885 cm_return_val_if_fail(folder
->klass
->fetch_msg
!= NULL
, NULL
);
2886 if (item
->no_select
)
2889 msgfile
= folder
->klass
->fetch_msg(folder
, item
, num
);
2891 if (msgfile
!= NULL
) {
2892 msginfo
= folder_item_get_msginfo(item
, num
);
2893 if ((msginfo
!= NULL
) && !MSG_IS_SCANNED(msginfo
->flags
)) {
2896 if (!folder_has_parent_of_type(msginfo
->folder
, F_QUEUE
) &&
2897 !folder_has_parent_of_type(msginfo
->folder
, F_DRAFT
))
2898 mimeinfo
= procmime_scan_file(msgfile
);
2900 mimeinfo
= procmime_scan_queue_file(msgfile
);
2901 /* check for attachments */
2902 if (mimeinfo
!= NULL
) {
2903 g_node_children_foreach(mimeinfo
->node
, G_TRAVERSE_ALL
, msginfo_set_mime_flags
, msginfo
);
2904 procmime_mimeinfo_free_all(&mimeinfo
);
2906 procmsg_msginfo_set_flags(msginfo
, 0, MSG_SCANNED
);
2909 procmsg_msginfo_free(&msginfo
);
2915 gchar
*folder_item_fetch_msg_full(FolderItem
*item
, gint num
, gboolean headers
,
2922 cm_return_val_if_fail(item
!= NULL
, NULL
);
2923 if (item
->no_select
)
2926 folder
= item
->folder
;
2928 if (folder
->klass
->fetch_msg_full
== NULL
)
2929 return folder_item_fetch_msg(item
, num
);
2931 if (item
->prefs
->offlinesync
&& prefs_common
.real_time_sync
)
2932 msgfile
= folder
->klass
->fetch_msg_full(folder
, item
, num
,
2935 msgfile
= folder
->klass
->fetch_msg_full(folder
, item
, num
,
2938 if (msgfile
!= NULL
) {
2939 msginfo
= folder_item_get_msginfo(item
, num
);
2940 if ((msginfo
!= NULL
) && !MSG_IS_SCANNED(msginfo
->flags
)) {
2943 if (!folder_has_parent_of_type(msginfo
->folder
, F_QUEUE
) &&
2944 !folder_has_parent_of_type(msginfo
->folder
, F_DRAFT
))
2945 mimeinfo
= procmime_scan_file(msgfile
);
2947 mimeinfo
= procmime_scan_queue_file(msgfile
);
2948 /* check for attachments */
2949 if (mimeinfo
!= NULL
) {
2950 g_node_children_foreach(mimeinfo
->node
, G_TRAVERSE_ALL
, msginfo_set_mime_flags
, msginfo
);
2951 procmime_mimeinfo_free_all(&mimeinfo
);
2953 procmsg_msginfo_set_flags(msginfo
, 0, MSG_SCANNED
);
2956 procmsg_msginfo_free(&msginfo
);
2963 static gint
folder_item_get_msg_num_by_file(FolderItem
*dest
, const gchar
*file
)
2965 static HeaderEntry hentry
[] = {{"Message-ID:", NULL
, TRUE
},
2966 {NULL
, NULL
, FALSE
}};
2970 gchar buf
[BUFFSIZE
];
2972 if ((fp
= g_fopen(file
, "rb")) == NULL
)
2975 if ((folder_has_parent_of_type(dest
, F_QUEUE
)) ||
2976 (folder_has_parent_of_type(dest
, F_DRAFT
)))
2977 while (fgets(buf
, sizeof(buf
), fp
) != NULL
) {
2979 if ((!strncmp(buf
, "X-Claws-End-Special-Headers: 1",
2980 strlen("X-Claws-End-Special-Headers:"))) ||
2981 (!strncmp(buf
, "X-Sylpheed-End-Special-Headers: 1",
2982 strlen("X-Sylpheed-End-Special-Headers:"))))
2985 if (buf
[0] == '\r' || buf
[0] == '\n') break;
2986 /* from other mailers */
2987 if (!strncmp(buf
, "Date: ", 6)
2988 || !strncmp(buf
, "To: ", 4)
2989 || !strncmp(buf
, "From: ", 6)
2990 || !strncmp(buf
, "Subject: ", 9)) {
2996 procheader_get_header_fields(fp
, hentry
);
2997 debug_print("looking for %s\n", hentry
[0].body
);
2998 if (hentry
[0].body
) {
2999 extract_parenthesis(hentry
[0].body
, '<', '>');
3000 remove_space(hentry
[0].body
);
3001 if ((msginfo
= msgcache_get_msg_by_id(dest
->cache
, hentry
[0].body
)) != NULL
) {
3002 msgnum
= msginfo
->msgnum
;
3003 procmsg_msginfo_free(&msginfo
);
3005 debug_print("found message as uid %d\n", msgnum
);
3009 g_free(hentry
[0].body
);
3010 hentry
[0].body
= NULL
;
3016 static void copy_msginfo_flags(MsgInfo
*source
, MsgInfo
*dest
)
3018 MsgPermFlags perm_flags
= 0;
3019 MsgTmpFlags tmp_flags
= 0;
3021 /* create new flags */
3022 if (source
!= NULL
) {
3023 /* copy original flags */
3024 perm_flags
= source
->flags
.perm_flags
;
3025 tmp_flags
= source
->flags
.tmp_flags
;
3027 perm_flags
= dest
->flags
.perm_flags
;
3028 tmp_flags
= dest
->flags
.tmp_flags
;
3031 /* remove new, unread and deleted in special folders */
3032 if (folder_has_parent_of_type(dest
->folder
, F_OUTBOX
) ||
3033 folder_has_parent_of_type(dest
->folder
, F_QUEUE
) ||
3034 folder_has_parent_of_type(dest
->folder
, F_DRAFT
) ||
3035 folder_has_parent_of_type(dest
->folder
, F_TRASH
))
3036 perm_flags
&= ~(MSG_NEW
| MSG_UNREAD
| MSG_DELETED
);
3038 /* set ignore flag of ignored parent exists */
3039 if (procmsg_msg_has_flagged_parent(dest
, MSG_IGNORE_THREAD
))
3040 perm_flags
|= MSG_IGNORE_THREAD
;
3042 /* unset FULLY_CACHED flags */
3043 perm_flags
&= ~MSG_FULLY_CACHED
;
3045 if (procmsg_msg_has_flagged_parent(dest
, MSG_WATCH_THREAD
))
3046 perm_flags
|= MSG_WATCH_THREAD
;
3048 /* Unset tmp flags that should not be copied */
3049 tmp_flags
&= ~(MSG_MOVE
| MSG_COPY
| MSG_MOVE_DONE
);
3051 /* unset flags that are set but should not */
3052 /* and set new flags */
3053 procmsg_msginfo_change_flags(dest
,
3054 ~dest
->flags
.perm_flags
& perm_flags
,
3055 ~dest
->flags
.tmp_flags
& tmp_flags
,
3056 dest
->flags
.perm_flags
& ~perm_flags
,
3057 dest
->flags
.tmp_flags
& ~tmp_flags
);
3059 if (source
&& source
->tags
) {
3060 g_slist_free(dest
->tags
);
3061 dest
->tags
= g_slist_copy(source
->tags
);
3062 folder_item_commit_tags(dest
->folder
, dest
, dest
->tags
, NULL
);
3066 static void add_msginfo_to_cache(FolderItem
*item
, MsgInfo
*newmsginfo
, MsgInfo
*flagsource
)
3068 /* update folder stats */
3069 if (MSG_IS_NEW(newmsginfo
->flags
))
3071 if (MSG_IS_UNREAD(newmsginfo
->flags
))
3072 item
->unread_msgs
++;
3073 if (MSG_IS_UNREAD(newmsginfo
->flags
) && procmsg_msg_has_marked_parent(newmsginfo
))
3074 item
->unreadmarked_msgs
++;
3075 if (MSG_IS_MARKED(newmsginfo
->flags
))
3076 item
->marked_msgs
++;
3077 if (MSG_IS_REPLIED(newmsginfo
->flags
))
3078 item
->replied_msgs
++;
3079 if (MSG_IS_FORWARDED(newmsginfo
->flags
))
3080 item
->forwarded_msgs
++;
3081 if (MSG_IS_LOCKED(newmsginfo
->flags
))
3082 item
->locked_msgs
++;
3083 if (MSG_IS_IGNORE_THREAD(newmsginfo
->flags
))
3084 item
->ignored_msgs
++;
3085 if (MSG_IS_WATCH_THREAD(newmsginfo
->flags
))
3086 item
->watched_msgs
++;
3089 folder_item_update_freeze();
3092 folder_item_read_cache(item
);
3094 msgcache_add_msg(item
->cache
, newmsginfo
);
3095 copy_msginfo_flags(flagsource
, newmsginfo
);
3096 folder_item_update_with_msg(item
, F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
| F_ITEM_UPDATE_ADDMSG
, newmsginfo
);
3097 folder_item_update_thaw();
3100 static void remove_msginfo_from_cache(FolderItem
*item
, MsgInfo
*msginfo
)
3102 MsgInfoUpdate msginfo_update
;
3105 folder_item_read_cache(item
);
3107 if (MSG_IS_NEW(msginfo
->flags
) && !MSG_IS_IGNORE_THREAD(msginfo
->flags
))
3108 msginfo
->folder
->new_msgs
--;
3109 if (MSG_IS_UNREAD(msginfo
->flags
) && !MSG_IS_IGNORE_THREAD(msginfo
->flags
))
3110 msginfo
->folder
->unread_msgs
--;
3111 if (MSG_IS_UNREAD(msginfo
->flags
) && procmsg_msg_has_marked_parent(msginfo
))
3112 msginfo
->folder
->unreadmarked_msgs
--;
3113 if (MSG_IS_MARKED(msginfo
->flags
))
3114 item
->marked_msgs
--;
3115 if (MSG_IS_REPLIED(msginfo
->flags
))
3116 item
->replied_msgs
--;
3117 if (MSG_IS_FORWARDED(msginfo
->flags
))
3118 item
->forwarded_msgs
--;
3119 if (MSG_IS_LOCKED(msginfo
->flags
))
3120 item
->locked_msgs
--;
3121 if (MSG_IS_IGNORE_THREAD(msginfo
->flags
))
3122 item
->ignored_msgs
--;
3123 if (MSG_IS_WATCH_THREAD(msginfo
->flags
))
3124 item
->watched_msgs
--;
3126 msginfo
->folder
->total_msgs
--;
3128 msginfo_update
.msginfo
= msginfo
;
3129 msginfo_update
.flags
= MSGINFO_UPDATE_DELETED
;
3130 hooks_invoke(MSGINFO_UPDATE_HOOKLIST
, &msginfo_update
);
3132 msgcache_remove_msg(item
->cache
, msginfo
->msgnum
);
3133 folder_item_update_with_msg(msginfo
->folder
, F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
| F_ITEM_UPDATE_REMOVEMSG
, msginfo
);
3136 gint
folder_item_add_msg(FolderItem
*dest
, const gchar
*file
,
3137 MsgFlags
*flags
, gboolean remove_source
)
3140 MsgFileInfo fileinfo
;
3142 cm_return_val_if_fail(dest
!= NULL
, -1);
3143 cm_return_val_if_fail(file
!= NULL
, -1);
3145 fileinfo
.msginfo
= NULL
;
3146 fileinfo
.file
= (gchar
*)file
;
3147 fileinfo
.flags
= flags
;
3148 file_list
.data
= &fileinfo
;
3149 file_list
.next
= NULL
;
3151 return folder_item_add_msgs(dest
, &file_list
, remove_source
);
3154 gint
folder_item_add_msgs(FolderItem
*dest
, GSList
*file_list
,
3155 gboolean remove_source
)
3158 gint ret
, num
, lastnum
= -1;
3160 GHashTable
*relation
;
3161 MsgFileInfo
*fileinfo
= NULL
;
3162 gboolean folderscan
= FALSE
;
3164 cm_return_val_if_fail(dest
!= NULL
, -1);
3165 cm_return_val_if_fail(file_list
!= NULL
, -1);
3166 cm_return_val_if_fail(dest
->folder
!= NULL
, -1);
3167 if (dest
->no_select
)
3170 folder
= dest
->folder
;
3172 relation
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
3174 if (folder
->klass
->add_msgs
!= NULL
) {
3175 ret
= folder
->klass
->add_msgs(folder
, dest
, file_list
, relation
);
3177 g_hash_table_destroy(relation
);
3181 for (file_cur
= file_list
; file_cur
!= NULL
; file_cur
= g_slist_next(file_cur
)) {
3182 fileinfo
= (MsgFileInfo
*) file_cur
->data
;
3184 ret
= folder
->klass
->add_msg(folder
, dest
, fileinfo
->file
, fileinfo
->flags
);
3186 g_hash_table_destroy(relation
);
3189 g_hash_table_insert(relation
, fileinfo
, GINT_TO_POINTER(ret
));
3193 for (file_cur
= file_list
; file_cur
!= NULL
; file_cur
= g_slist_next(file_cur
)) {
3194 gpointer data
, old_key
;
3196 fileinfo
= (MsgFileInfo
*) file_cur
->data
;
3197 if (g_hash_table_lookup_extended(relation
, fileinfo
, &old_key
, &data
))
3198 num
= GPOINTER_TO_INT(data
);
3203 MsgInfo
*newmsginfo
;
3207 folder_item_scan_full(dest
, FALSE
);
3210 num
= folder_item_get_msg_num_by_file(dest
, fileinfo
->file
);
3211 debug_print("got num %d\n", num
);
3217 if (num
>= 0 && remove_source
) {
3218 if (claws_unlink(fileinfo
->file
) < 0)
3219 FILE_OP_ERROR(fileinfo
->file
, "unlink");
3226 ((newmsginfo
= get_msginfo(dest
, num
)) != NULL
)) {
3227 add_msginfo_to_cache(dest
, newmsginfo
, NULL
);
3228 procmsg_msginfo_free(&newmsginfo
);
3229 } else if ((newmsginfo
= msgcache_get_msg(dest
->cache
, num
)) != NULL
) {
3230 /* TODO: set default flags */
3231 procmsg_msginfo_free(&newmsginfo
);
3236 g_hash_table_destroy(relation
);
3241 static FolderItem
*folder_item_move_recursive(FolderItem
*src
, FolderItem
*dest
, gboolean copy
)
3244 FolderItem
*new_item
;
3245 FolderItem
*next_item
;
3247 gchar
*old_id
, *new_id
;
3248 FolderUpdateData hookdata
;
3251 debug_print("%s %s to %s\n", copy
?"Copying":"Moving", src
->path
, dest
->path
);
3252 new_item
= folder_create_folder(dest
, src
->name
);
3253 if (new_item
== NULL
) {
3254 g_print("Can't create folder\n");
3258 if (new_item
->folder
== NULL
)
3259 new_item
->folder
= dest
->folder
;
3262 log_message(LOG_PROTOCOL
, copy
?_("Copying %s to %s...\n"):_("Moving %s to %s...\n"),
3263 src
->name
, new_item
->path
);
3266 folder_item_prefs_copy_prefs(src
, new_item
);
3268 /* copy internal data */
3269 if (src
->folder
->klass
== new_item
->folder
->klass
&&
3270 src
->folder
->klass
->copy_private_data
!= NULL
)
3271 src
->folder
->klass
->copy_private_data(src
->folder
,
3273 new_item
->collapsed
= src
->collapsed
;
3274 new_item
->thread_collapsed
= src
->thread_collapsed
;
3275 new_item
->threaded
= src
->threaded
;
3276 new_item
->ret_rcpt
= src
->ret_rcpt
;
3277 new_item
->hide_read_msgs
= src
->hide_read_msgs
;
3278 new_item
->hide_del_msgs
= src
->hide_del_msgs
;
3279 new_item
->hide_read_threads
= src
->hide_read_threads
;
3280 new_item
->sort_key
= src
->sort_key
;
3281 new_item
->sort_type
= src
->sort_type
;
3283 mlist
= folder_item_get_msg_list(src
);
3285 if (mlist
!= NULL
) {
3287 folder_item_copy_msgs(new_item
, mlist
);
3289 folder_item_move_msgs(new_item
, mlist
);
3290 procmsg_msg_list_free(mlist
);
3293 prefs_matcher_write_config();
3296 srcnode
= src
->folder
->node
;
3297 srcnode
= g_node_find(srcnode
, G_PRE_ORDER
, G_TRAVERSE_ALL
, src
);
3298 srcnode
= srcnode
->children
;
3299 while (srcnode
!= NULL
) {
3300 if (srcnode
&& srcnode
->data
) {
3301 next_item
= (FolderItem
*) srcnode
->data
;
3302 srcnode
= srcnode
->next
;
3303 if (folder_item_move_recursive(next_item
, new_item
, copy
) == NULL
) {
3308 old_id
= folder_item_get_identifier(src
);
3309 new_id
= folder_item_get_identifier(new_item
);
3311 hookdata
.folder
= src
->folder
;
3312 hookdata
.update_flags
= FOLDER_TREE_CHANGED
| FOLDER_MOVE_FOLDERITEM
;
3313 hookdata
.item
= src
;
3314 hookdata
.item2
= new_item
;
3315 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
3317 /* if src supports removing, otherwise only copy folder */
3318 if (src
->folder
->klass
->remove_folder
!= NULL
&& !copy
)
3319 src
->folder
->klass
->remove_folder(src
->folder
, src
);
3320 folder_write_list();
3323 debug_print("updating rules : %s => %s\n", old_id
, new_id
);
3324 if (old_id
!= NULL
&& new_id
!= NULL
) {
3325 prefs_filtering_rename_path(old_id
, new_id
);
3326 account_rename_path(old_id
, new_id
);
3335 gint
folder_item_move_to(FolderItem
*src
, FolderItem
*dest
, FolderItem
**new_item
, gboolean copy
)
3337 FolderItem
*tmp
= folder_item_parent(dest
);
3338 gchar
* src_identifier
, * dst_identifier
;
3339 gchar
* phys_srcpath
, * phys_dstpath
, *tmppath
;
3343 return F_MOVE_FAILED_DEST_IS_CHILD
;
3345 tmp
= folder_item_parent(tmp
);
3348 /* both dst and src can be root folders */
3349 src_identifier
= folder_item_get_identifier(src
);
3350 if (src_identifier
== NULL
&& src
->folder
&& folder_item_parent(src
) == NULL
) {
3351 src_identifier
= folder_get_identifier(src
->folder
);
3354 dst_identifier
= folder_item_get_identifier(dest
);
3355 if(dst_identifier
== NULL
&& dest
->folder
&& folder_item_parent(dest
) == NULL
) {
3356 dst_identifier
= folder_get_identifier(dest
->folder
);
3359 if (src_identifier
== NULL
|| dst_identifier
== NULL
) {
3360 debug_print("Can't get identifiers\n");
3361 return F_MOVE_FAILED
;
3364 if (src
->folder
!= dest
->folder
&& !copy
) {
3365 return F_MOVE_FAILED_DEST_OUTSIDE_MAILBOX
;
3368 phys_srcpath
= folder_item_get_path(src
);
3369 tmppath
= folder_item_get_path(dest
);
3370 phys_dstpath
= g_strconcat(tmppath
,
3372 g_path_get_basename(phys_srcpath
),
3376 if (folder_item_parent(src
) == dest
|| src
== dest
) {
3377 g_free(src_identifier
);
3378 g_free(dst_identifier
);
3379 g_free(phys_srcpath
);
3380 g_free(phys_dstpath
);
3381 return F_MOVE_FAILED_DEST_IS_PARENT
;
3383 debug_print("moving \"%s\" to \"%s\"\n", phys_srcpath
, phys_dstpath
);
3384 if ((tmp
= folder_item_move_recursive(src
, dest
, copy
)) == NULL
) {
3385 return F_MOVE_FAILED
;
3388 g_free(src_identifier
);
3389 g_free(dst_identifier
);
3390 g_free(phys_srcpath
);
3391 g_free(phys_dstpath
);
3402 static void find_num(gpointer key
, gpointer value
, gpointer data
)
3404 struct find_data
*fdata
= (struct find_data
*)data
;
3405 if (GPOINTER_TO_INT(value
) == 0)
3406 fdata
->found
= TRUE
;
3409 static gboolean
some_msgs_have_zero_num(GHashTable
*hashtable
)
3411 struct find_data fdata
;
3413 fdata
.found
= FALSE
;
3414 g_hash_table_foreach(hashtable
, find_num
, &fdata
);
3420 * Copy a list of message to a new folder and remove
3421 * source messages if wanted
3423 static gint
do_copy_msgs(FolderItem
*dest
, GSList
*msglist
, gboolean remove_source
)
3427 gint num
, lastnum
= -1;
3428 gboolean folderscan
= FALSE
;
3429 GHashTable
*relation
;
3430 GSList
*not_moved
= NULL
;
3431 gint total
= 0, curmsg
= 0;
3432 MsgInfo
*msginfo
= NULL
;
3434 cm_return_val_if_fail(dest
!= NULL
, -1);
3435 cm_return_val_if_fail(msglist
!= NULL
, -1);
3437 folder
= dest
->folder
;
3439 cm_return_val_if_fail(folder
->klass
->copy_msg
!= NULL
, -1);
3440 if (dest
->no_select
)
3443 msginfo
= (MsgInfo
*)msglist
->data
;
3448 if (!MSG_IS_QUEUED(msginfo
->flags
) &&
3449 MSG_IS_DRAFT(msginfo
->flags
) &&
3450 folder_has_parent_of_type(dest
, F_QUEUE
)) {
3451 GSList
*cur
= msglist
;
3452 gboolean queue_err
= FALSE
;
3453 for (; cur
; cur
= cur
->next
) {
3454 Compose
*compose
= NULL
;
3455 FolderItem
*queue
= dest
;
3458 msginfo
= (MsgInfo
*)cur
->data
;
3459 compose
= compose_reedit(msginfo
, TRUE
);
3460 if (compose
== NULL
) {
3464 val
= compose_queue(compose
, NULL
, &queue
, NULL
,
3468 } else if (remove_source
) {
3469 folder_item_remove_msg(msginfo
->folder
, msginfo
->msgnum
);
3472 compose_close(compose
);
3474 return queue_err
? -1:0;
3477 relation
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
3479 for (l
= msglist
; l
!= NULL
; l
= g_slist_next(l
)) {
3480 MsgInfo
* msginfo
= (MsgInfo
*) l
->data
;
3482 if (msginfo
->planned_download
!= 0) {
3483 int old_planned
= msginfo
->planned_download
;
3484 partial_unmark(msginfo
);
3485 /* little hack to reenable after */
3486 msginfo
->planned_download
= old_planned
;
3491 * Copy messages to destination folder and
3492 * store new message numbers in newmsgnums
3494 if (folder
->klass
->copy_msgs
!= NULL
) {
3495 if (folder
->klass
->copy_msgs(folder
, dest
, msglist
, relation
) < 0) {
3496 g_hash_table_destroy(relation
);
3503 /* immediately stop if src and dest folders are identical */
3505 msginfo
= (MsgInfo
*) l
->data
;
3506 if (msginfo
!= NULL
&& msginfo
->folder
== dest
) {
3507 g_hash_table_destroy(relation
);
3512 for (; l
!= NULL
; l
= g_slist_next(l
)) {
3513 msginfo
= (MsgInfo
*) l
->data
;
3515 num
= folder
->klass
->copy_msg(folder
, dest
, msginfo
);
3517 g_hash_table_insert(relation
, msginfo
, GINT_TO_POINTER(num
));
3519 not_moved
= g_slist_prepend(not_moved
, msginfo
);
3523 if (remove_source
) {
3524 MsgInfo
*msginfo
= (MsgInfo
*) msglist
->data
;
3525 FolderItem
*item
= msginfo
->folder
;
3527 * Remove source messages from their folders if
3528 * copying was successfull and update folder
3531 if (not_moved
== NULL
&& item
->folder
->klass
->remove_msgs
) {
3532 item
->folder
->klass
->remove_msgs(item
->folder
,
3537 for (l
= msglist
; l
!= NULL
; l
= g_slist_next(l
)) {
3538 gpointer old_key
, data
;
3539 msginfo
= (MsgInfo
*) l
->data
;
3540 item
= msginfo
->folder
;
3542 if (g_hash_table_lookup_extended(relation
, msginfo
, &old_key
, &data
))
3543 num
= GPOINTER_TO_INT(data
);
3547 if (g_slist_find(not_moved
, msginfo
))
3550 if ((num
>= 0) && (item
->folder
->klass
->remove_msg
!= NULL
)) {
3551 if (!item
->folder
->klass
->remove_msgs
)
3552 item
->folder
->klass
->remove_msg(item
->folder
,
3555 remove_msginfo_from_cache(item
, msginfo
);
3560 /* Read cache for dest folder */
3561 if (!dest
->cache
) folder_item_read_cache(dest
);
3564 * Fetch new MsgInfos for new messages in dest folder,
3565 * add them to the msgcache and update folder message counts
3567 if (some_msgs_have_zero_num(relation
)) {
3568 folder_item_scan_full(dest
, FALSE
);
3572 statusbar_print_all(_("Updating cache for %s..."), dest
->path
? dest
->path
: "(null)");
3573 total
= g_slist_length(msglist
);
3575 if (FOLDER_TYPE(dest
->folder
) == F_IMAP
&& total
> 1) {
3576 folder_item_scan_full(dest
, FALSE
);
3579 folder_item_set_batch(dest
, TRUE
);
3580 for (l
= msglist
; l
!= NULL
; l
= g_slist_next(l
)) {
3581 MsgInfo
*msginfo
= (MsgInfo
*) l
->data
;
3582 gpointer data
, old_key
;
3587 if (g_hash_table_lookup_extended(relation
, msginfo
, &old_key
, &data
))
3588 num
= GPOINTER_TO_INT(data
);
3592 statusbar_progress_all(curmsg
++,total
, 100);
3593 if (curmsg
% 100 == 0)
3597 MsgInfo
*newmsginfo
= NULL
;
3599 if (!folderscan
&& num
> 0) {
3600 newmsginfo
= get_msginfo(dest
, num
);
3601 if (newmsginfo
!= NULL
) {
3602 add_msginfo_to_cache(dest
, newmsginfo
, msginfo
);
3605 if (newmsginfo
== NULL
) {
3607 folder_item_scan_full(dest
, FALSE
);
3610 if (msginfo
->msgid
!= NULL
) {
3611 newmsginfo
= folder_item_get_msginfo_by_msgid(dest
, msginfo
->msgid
);
3612 if (newmsginfo
!= NULL
) {
3613 copy_msginfo_flags(msginfo
, newmsginfo
);
3614 num
= newmsginfo
->msgnum
;
3618 if (newmsginfo
!= NULL
3619 && msginfo
->planned_download
== POP3_PARTIAL_DLOAD_DELE
) {
3620 partial_mark_for_delete(newmsginfo
);
3622 if (newmsginfo
!= NULL
3623 && msginfo
->planned_download
== POP3_PARTIAL_DLOAD_DLOAD
) {
3624 partial_mark_for_download(newmsginfo
);
3626 if (!MSG_IS_POSTFILTERED (msginfo
->flags
)) {
3627 procmsg_msginfo_set_flags ( msginfo
, MSG_POSTFILTERED
, 0);
3629 procmsg_msginfo_set_flags (newmsginfo
, MSG_POSTFILTERED
, 0);
3630 hooks_invoke (MAIL_POSTFILTERING_HOOKLIST
, newmsginfo
);
3633 procmsg_msginfo_free(&newmsginfo
);
3640 folder_item_set_batch(dest
, FALSE
);
3641 statusbar_progress_all(0,0,0);
3642 statusbar_pop_all();
3644 g_hash_table_destroy(relation
);
3645 if (not_moved
!= NULL
) {
3646 g_slist_free(not_moved
);
3653 * Move a message to a new folder.
3655 * \param dest Destination folder
3656 * \param msginfo The message
3658 gint
folder_item_move_msg(FolderItem
*dest
, MsgInfo
*msginfo
)
3662 cm_return_val_if_fail(dest
!= NULL
, -1);
3663 cm_return_val_if_fail(msginfo
!= NULL
, -1);
3665 list
.data
= msginfo
;
3668 return do_copy_msgs(dest
, &list
, TRUE
);
3672 * Move a list of messages to a new folder.
3674 * \param dest Destination folder
3675 * \param msglist List of messages
3677 gint
folder_item_move_msgs(FolderItem
*dest
, GSList
*msglist
)
3680 cm_return_val_if_fail(dest
!= NULL
, -1);
3681 cm_return_val_if_fail(msglist
!= NULL
, -1);
3683 result
= do_copy_msgs(dest
, msglist
, TRUE
);
3689 * Copy a message to a new folder.
3691 * \param dest Destination folder
3692 * \param msginfo The message
3694 gint
folder_item_copy_msg(FolderItem
*dest
, MsgInfo
*msginfo
)
3698 cm_return_val_if_fail(dest
!= NULL
, -1);
3699 cm_return_val_if_fail(msginfo
!= NULL
, -1);
3701 list
.data
= msginfo
;
3704 return do_copy_msgs(dest
, &list
, FALSE
);
3708 * Copy a list of messages to a new folder.
3710 * \param dest Destination folder
3711 * \param msglist List of messages
3713 gint
folder_item_copy_msgs(FolderItem
*dest
, GSList
*msglist
)
3716 cm_return_val_if_fail(dest
!= NULL
, -1);
3717 cm_return_val_if_fail(msglist
!= NULL
, -1);
3720 result
= do_copy_msgs(dest
, msglist
, FALSE
);
3726 gint
folder_item_remove_msg(FolderItem
*item
, gint num
)
3732 cm_return_val_if_fail(item
!= NULL
, -1);
3733 folder
= item
->folder
;
3734 cm_return_val_if_fail(folder
->klass
->remove_msg
!= NULL
, -1);
3735 if (item
->no_select
)
3738 if (!item
->cache
) folder_item_read_cache(item
);
3740 msginfo
= msgcache_get_msg(item
->cache
, num
);
3741 if (msginfo
&& MSG_IS_LOCKED(msginfo
->flags
)) {
3742 procmsg_msginfo_free(&msginfo
);
3745 ret
= folder
->klass
->remove_msg(folder
, item
, num
);
3747 if (msginfo
!= NULL
) {
3749 remove_msginfo_from_cache(item
, msginfo
);
3750 procmsg_msginfo_free(&msginfo
);
3756 gint
folder_item_remove_msgs(FolderItem
*item
, GSList
*msglist
)
3760 GSList
*real_list
= NULL
, *cur
= NULL
;
3762 cm_return_val_if_fail(item
!= NULL
, -1);
3763 folder
= item
->folder
;
3764 cm_return_val_if_fail(folder
!= NULL
, -1);
3765 if (item
->no_select
)
3768 if (!item
->cache
) folder_item_read_cache(item
);
3770 folder_item_update_freeze();
3772 /* filter out locked mails */
3773 for (cur
= msglist
; cur
; cur
= cur
->next
) {
3774 MsgInfo
*info
= (MsgInfo
*)cur
->data
;
3775 if (!MSG_IS_LOCKED(info
->flags
))
3776 real_list
= g_slist_prepend(real_list
, info
);
3779 real_list
= g_slist_reverse(real_list
);
3781 if (item
->folder
->klass
->remove_msgs
) {
3782 ret
= item
->folder
->klass
->remove_msgs(item
->folder
,
3788 while (ret
== 0 && cur
!= NULL
) {
3789 MsgInfo
*msginfo
= (MsgInfo
*)cur
->data
;
3790 if (msginfo
&& MSG_IS_LOCKED(msginfo
->flags
)) {
3794 if (!item
->folder
->klass
->remove_msgs
)
3795 ret
= folder_item_remove_msg(item
, msginfo
->msgnum
);
3796 if (ret
!= 0) break;
3797 msgcache_remove_msg(item
->cache
, msginfo
->msgnum
);
3800 g_slist_free(real_list
);
3801 folder_item_scan_full(item
, FALSE
);
3802 folder_item_update_thaw();
3807 gint
folder_item_expunge(FolderItem
*item
)
3809 Folder
*folder
= item
->folder
;
3813 if (folder
->klass
->expunge
) {
3814 GSList
*msglist
= folder_item_get_msg_list(item
);
3816 result
= folder
->klass
->expunge(folder
, item
);
3818 for (cur
= msglist
; cur
; cur
= cur
->next
) {
3819 MsgInfo
*msginfo
= (MsgInfo
*)cur
->data
;
3820 if (MSG_IS_DELETED(msginfo
->flags
)) {
3821 remove_msginfo_from_cache(item
, msginfo
);
3825 procmsg_msg_list_free(msglist
);
3830 gint
folder_item_remove_all_msg(FolderItem
*item
)
3835 cm_return_val_if_fail(item
!= NULL
, -1);
3836 if (item
->no_select
)
3839 folder
= item
->folder
;
3842 if (folder
->klass
->remove_all_msg
!= NULL
) {
3843 result
= folder
->klass
->remove_all_msg(folder
, item
);
3846 folder_item_free_cache(item
, TRUE
);
3847 item
->cache
= msgcache_new();
3848 item
->cache_dirty
= TRUE
;
3849 item
->mark_dirty
= TRUE
;
3850 item
->tags_dirty
= TRUE
;
3853 MsgInfoList
*msglist
;
3855 msglist
= folder_item_get_msg_list(item
);
3856 result
= folder_item_remove_msgs(item
, msglist
);
3857 procmsg_msg_list_free(msglist
);
3862 item
->unread_msgs
= 0;
3863 item
->unreadmarked_msgs
= 0;
3864 item
->marked_msgs
= 0;
3865 item
->total_msgs
= 0;
3866 item
->replied_msgs
= 0;
3867 item
->forwarded_msgs
= 0;
3868 item
->locked_msgs
= 0;
3869 item
->ignored_msgs
= 0;
3870 item
->watched_msgs
= 0;
3871 folder_item_update(item
, F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
);
3878 void folder_item_change_msg_flags(FolderItem
*item
, MsgInfo
*msginfo
, MsgPermFlags newflags
)
3880 cm_return_if_fail(item
!= NULL
);
3881 cm_return_if_fail(msginfo
!= NULL
);
3883 item
->mark_dirty
= TRUE
;
3885 if (item
->no_select
)
3888 if (item
->folder
->klass
->change_flags
!= NULL
&& item
->scanning
!= ITEM_SCANNING_WITH_FLAGS
) {
3889 item
->folder
->klass
->change_flags(item
->folder
, item
, msginfo
, newflags
);
3891 msginfo
->flags
.perm_flags
= newflags
;
3895 void folder_item_commit_tags(FolderItem
*item
, MsgInfo
*msginfo
, GSList
*tags_set
, GSList
*tags_unset
)
3897 Folder
*folder
= NULL
;
3903 if (!tags_set
&& !tags_unset
)
3906 folder
= item
->folder
;
3910 item
->tags_dirty
= TRUE
;
3912 if (folder
->klass
->commit_tags
== NULL
)
3915 folder
->klass
->commit_tags(item
, msginfo
, tags_set
, tags_unset
);
3918 gboolean
folder_item_is_msg_changed(FolderItem
*item
, MsgInfo
*msginfo
)
3922 cm_return_val_if_fail(item
!= NULL
, FALSE
);
3923 if (item
->no_select
)
3926 folder
= item
->folder
;
3928 cm_return_val_if_fail(folder
->klass
->is_msg_changed
!= NULL
, -1);
3930 return folder
->klass
->is_msg_changed(folder
, item
, msginfo
);
3933 void folder_item_discard_cache(FolderItem
*item
)
3942 msgcache_destroy(item
->cache
);
3945 dir
= folder_item_get_path(item
);
3946 if (is_dir_exist(dir
))
3947 remove_all_numbered_files(dir
);
3950 cache
= folder_item_get_cache_file(item
);
3951 if (is_file_exist(cache
))
3952 claws_unlink(cache
);
3957 static gchar
*folder_item_get_cache_file(FolderItem
*item
)
3963 cm_return_val_if_fail(item
!= NULL
, NULL
);
3964 cm_return_val_if_fail(item
->path
!= NULL
, NULL
);
3966 path
= folder_item_get_path(item
);
3967 cm_return_val_if_fail(path
!= NULL
, NULL
);
3968 if (!is_dir_exist(path
))
3969 make_dir_hier(path
);
3970 file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, CACHE_FILE
, NULL
);
3971 old_file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, OLD_CACHE_FILE
, NULL
);
3973 if (!is_file_exist(file
) && is_file_exist(old_file
))
3974 move_file(old_file
, file
, FALSE
);
3981 static gchar
*folder_item_get_mark_file(FolderItem
*item
)
3987 cm_return_val_if_fail(item
!= NULL
, NULL
);
3988 cm_return_val_if_fail(item
->path
!= NULL
, NULL
);
3990 path
= folder_item_get_path(item
);
3991 cm_return_val_if_fail(path
!= NULL
, NULL
);
3992 if (!is_dir_exist(path
))
3993 make_dir_hier(path
);
3994 file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, MARK_FILE
, NULL
);
3995 old_file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, OLD_MARK_FILE
, NULL
);
3997 if (!is_file_exist(file
) && is_file_exist(old_file
))
3998 move_file(old_file
, file
, FALSE
);
4005 static gchar
*folder_item_get_tags_file(FolderItem
*item
)
4011 /* we save tags files in rc_dir, because tagsrc is there too,
4012 * and storing tags directly in the mailboxes would give strange
4013 * result when using another Claws mailbox from another install
4014 * with different tags. */
4016 cm_return_val_if_fail(item
!= NULL
, NULL
);
4018 identifier
= folder_item_get_identifier(item
);
4019 cm_return_val_if_fail(identifier
!= NULL
, NULL
);
4022 while (strchr(identifier
, '/'))
4023 *strchr(identifier
, '/') = '\\';
4026 path
= g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S
,
4027 TAGS_DIR
, G_DIR_SEPARATOR_S
,
4032 if (!is_dir_exist(path
))
4033 make_dir_hier(path
);
4035 file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, TAGS_FILE
, NULL
);
4042 static gpointer
xml_to_folder_item(gpointer nodedata
, gpointer data
)
4044 XMLNode
*xmlnode
= (XMLNode
*) nodedata
;
4045 Folder
*folder
= (Folder
*) data
;
4048 cm_return_val_if_fail(xmlnode
!= NULL
, NULL
);
4049 cm_return_val_if_fail(folder
!= NULL
, NULL
);
4051 if (strcmp2(xmlnode
->tag
->tag
, "folderitem") != 0) {
4052 g_warning("tag name != \"folderitem\"");
4056 item
= folder_item_new(folder
, "", "");
4057 g_node_destroy(item
->node
);
4058 if (folder
->klass
->item_set_xml
!= NULL
)
4059 folder
->klass
->item_set_xml(folder
, item
, xmlnode
->tag
);
4061 folder_item_set_xml(folder
, item
, xmlnode
->tag
);
4063 item
->folder
= folder
;
4065 switch (item
->stype
) {
4066 case F_INBOX
: folder
->inbox
= item
; break;
4067 case F_OUTBOX
: folder
->outbox
= item
; break;
4068 case F_DRAFT
: folder
->draft
= item
; break;
4069 case F_QUEUE
: folder
->queue
= item
; break;
4070 case F_TRASH
: folder
->trash
= item
; break;
4073 folder_item_prefs_read_config(item
);
4078 static gboolean
folder_item_set_node(GNode
*node
, gpointer data
)
4080 cm_return_val_if_fail(node
->data
!= NULL
, -1);
4082 FolderItem
*item
= (FolderItem
*) node
->data
;
4088 static Folder
*folder_get_from_xml(GNode
*node
)
4093 FolderClass
*klass
= NULL
;
4096 cm_return_val_if_fail(node
->data
!= NULL
, NULL
);
4098 xmlnode
= node
->data
;
4099 if (strcmp2(xmlnode
->tag
->tag
, "folder") != 0) {
4100 g_warning("tag name != \"folder\"");
4103 list
= xmlnode
->tag
->attr
;
4104 for (; list
!= NULL
; list
= list
->next
) {
4105 XMLAttr
*attr
= list
->data
;
4107 if (!attr
|| !attr
->name
|| !attr
->value
) continue;
4108 if (!strcmp(attr
->name
, "type"))
4109 klass
= folder_get_class_from_string(attr
->value
);
4114 folder
= folder_new(klass
, "", "");
4115 cm_return_val_if_fail(folder
!= NULL
, NULL
);
4118 klass
->set_xml(folder
, xmlnode
->tag
);
4120 folder_set_xml(folder
, xmlnode
->tag
);
4122 cur
= node
->children
;
4123 while (cur
!= NULL
) {
4126 itemnode
= g_node_map(cur
, xml_to_folder_item
, (gpointer
) folder
);
4127 g_node_append(folder
->node
, itemnode
);
4130 g_node_traverse(folder
->node
, G_IN_ORDER
, G_TRAVERSE_ALL
, -1, folder_item_set_node
, NULL
);
4135 gchar
*folder_get_list_path(void)
4137 static gchar
*filename
= NULL
;
4140 filename
= g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S
,
4146 static gpointer
folder_item_to_xml(gpointer nodedata
, gpointer data
)
4148 FolderItem
*item
= (FolderItem
*) nodedata
;
4151 cm_return_val_if_fail(item
!= NULL
, NULL
);
4153 if (item
->folder
->klass
->item_get_xml
!= NULL
)
4154 tag
= item
->folder
->klass
->item_get_xml(item
->folder
, item
);
4156 tag
= folder_item_get_xml(item
->folder
, item
);
4158 return xml_node_new(tag
, NULL
);
4161 static GNode
*folder_get_xml_node(Folder
*folder
)
4167 cm_return_val_if_fail(folder
!= NULL
, NULL
);
4169 if (folder
->klass
->get_xml
!= NULL
)
4170 tag
= folder
->klass
->get_xml(folder
);
4172 tag
= folder_get_xml(folder
);
4174 xml_tag_add_attr(tag
, xml_attr_new("type", folder
->klass
->idstr
));
4176 xmlnode
= xml_node_new(tag
, NULL
);
4178 node
= g_node_new(xmlnode
);
4180 cm_return_val_if_fail (folder
->node
!= NULL
, NULL
);
4182 if (folder
->node
->children
) {
4185 cur
= folder
->node
->children
;
4189 xmlnode
= g_node_map(cur
, folder_item_to_xml
, (gpointer
) folder
);
4190 g_node_append(node
, xmlnode
);
4198 static void folder_update_op_count_rec(GNode
*node
)
4200 FolderItem
*fitem
= FOLDER_ITEM(node
->data
);
4202 if (g_node_depth(node
) > 0) {
4203 if (fitem
->op_count
> 0) {
4204 fitem
->op_count
= 0;
4205 folder_item_update(fitem
, F_ITEM_UPDATE_MSGCNT
);
4207 if (node
->children
) {
4210 child
= node
->children
;
4216 folder_update_op_count_rec(cur
);
4222 void folder_update_op_count(void)
4227 for (cur
= folder_list
; cur
!= NULL
; cur
= cur
->next
) {
4229 folder_update_op_count_rec(folder
->node
);
4233 typedef struct _type_str
{
4240 static gchar * folder_item_get_tree_identifier(FolderItem * item)
4242 if (item->parent != NULL) {
4246 path = folder_item_get_tree_identifier(item->parent);
4250 id = g_strconcat(path, "/", item->name, NULL);
4256 return g_strconcat("/", item->name, NULL);
4261 /* CLAWS: temporary local folder for filtering */
4262 #define TEMP_FOLDER "TEMP_FOLDER"
4263 #define PROCESSING_FOLDER_ITEM "processing"
4265 static FolderItem
*folder_create_processing_folder(int account_id
)
4267 static Folder
*processing_folder
= NULL
;
4268 FolderItem
*processing_folder_item
;
4270 gchar
*processing_folder_item_name
= NULL
;
4272 processing_folder_item_name
= g_strdup_printf("%s-%d", PROCESSING_FOLDER_ITEM
, account_id
);
4274 if (processing_folder
== NULL
) {
4276 g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S
,
4277 "tempfolder", NULL
);
4279 folder_new(mh_get_class(), TEMP_FOLDER
, tmppath
);
4283 g_assert(processing_folder
!= NULL
);
4284 processing_folder
->klass
->scan_tree(processing_folder
);
4286 g_assert(processing_folder
!= NULL
);
4288 processing_folder_item
= folder_find_child_item_by_name(FOLDER_ITEM(processing_folder
->node
->data
),
4289 processing_folder_item_name
);
4290 if (processing_folder_item
) {
4291 debug_print("*TMP* already created %s\n", folder_item_get_path(processing_folder_item
));
4293 processing_folder_item
= processing_folder
->klass
->create_folder(processing_folder
,
4294 processing_folder
->node
->data
,
4295 processing_folder_item_name
);
4296 folder_item_append(FOLDER_ITEM(processing_folder
->node
->data
), processing_folder_item
);
4297 debug_print("*TMP* creating %s\n", folder_item_get_path(processing_folder_item
));
4299 g_free(processing_folder_item_name
);
4300 g_assert(processing_folder_item
!= NULL
);
4302 return(processing_folder_item
);
4305 FolderItem
*folder_get_default_processing(int account_id
)
4307 return folder_create_processing_folder(account_id
);
4310 /* folder_persist_prefs_new() - return hash table with persistent
4311 * settings (and folder name as key).
4312 * (note that in claws other options are in the folder_item_prefs_RC
4313 * file, so those don't need to be included in PersistPref yet)
4315 static GHashTable
*folder_persist_prefs_new(Folder
*folder
)
4317 GHashTable
*pptable
;
4319 cm_return_val_if_fail(folder
, NULL
);
4320 pptable
= g_hash_table_new(g_str_hash
, g_str_equal
);
4321 folder_get_persist_prefs_recursive(folder
->node
, pptable
);
4325 static void folder_persist_prefs_free(GHashTable
*pptable
)
4327 cm_return_if_fail(pptable
);
4328 g_hash_table_foreach_remove(pptable
, persist_prefs_free
, NULL
);
4329 g_hash_table_destroy(pptable
);
4332 static const PersistPrefs
*folder_get_persist_prefs(GHashTable
*pptable
, const char *name
)
4334 if (pptable
== NULL
|| name
== NULL
) return NULL
;
4335 return g_hash_table_lookup(pptable
, name
);
4338 static void folder_item_restore_persist_prefs(FolderItem
*item
, GHashTable
*pptable
)
4340 const PersistPrefs
*pp
;
4341 gchar
*id
= folder_item_get_identifier(item
);
4343 pp
= folder_get_persist_prefs(pptable
, id
);
4348 /* CLAWS: since not all folder properties have been migrated to
4349 * folderlist.xml, we need to call the old stuff first before
4350 * setting things that apply both to Main and Claws. */
4351 folder_item_prefs_read_config(item
);
4353 item
->collapsed
= pp
->collapsed
;
4354 item
->thread_collapsed
= pp
->thread_collapsed
;
4355 item
->threaded
= pp
->threaded
;
4356 item
->ret_rcpt
= pp
->ret_rcpt
;
4357 item
->hide_read_msgs
= pp
->hide_read_msgs
;
4358 item
->hide_del_msgs
= pp
->hide_del_msgs
;
4359 item
->hide_read_threads
= pp
->hide_read_threads
;
4360 item
->sort_key
= pp
->sort_key
;
4361 item
->sort_type
= pp
->sort_type
;
4364 static void folder_get_persist_prefs_recursive(GNode
*node
, GHashTable
*pptable
)
4366 FolderItem
*item
= FOLDER_ITEM(node
->data
);
4371 cm_return_if_fail(node
!= NULL
);
4372 cm_return_if_fail(item
!= NULL
);
4374 /* NOTE: item->path == NULL means top level folder; not interesting
4375 * to store preferences of that one. */
4377 id
= folder_item_get_identifier(item
);
4378 pp
= g_new0(PersistPrefs
, 1);
4379 cm_return_if_fail(pp
!= NULL
);
4380 pp
->collapsed
= item
->collapsed
;
4381 pp
->thread_collapsed
= item
->thread_collapsed
;
4382 pp
->threaded
= item
->threaded
;
4383 pp
->ret_rcpt
= item
->ret_rcpt
;
4384 pp
->hide_read_msgs
= item
->hide_read_msgs
;
4385 pp
->hide_del_msgs
= item
->hide_del_msgs
;
4386 pp
->hide_read_threads
= item
->hide_read_threads
;
4387 pp
->sort_key
= item
->sort_key
;
4388 pp
->sort_type
= item
->sort_type
;
4389 g_hash_table_insert(pptable
, id
, pp
);
4392 if (node
->children
) {
4393 child
= node
->children
;
4397 folder_get_persist_prefs_recursive(cur
, pptable
);
4402 static gboolean
persist_prefs_free(gpointer key
, gpointer val
, gpointer data
)
4409 void folder_item_apply_processing(FolderItem
*item
)
4411 GSList
*processing_list
;
4412 GSList
*mlist
, *cur
;
4413 guint total
= 0, curmsg
= 0;
4414 gint last_apply_per_account
;
4416 cm_return_if_fail(item
!= NULL
);
4418 if (item
->no_select
)
4421 processing_list
= item
->prefs
->processing
;
4423 if (!pre_global_processing
&& !processing_list
4424 && !post_global_processing
)
4427 debug_print("processing %s\n", item
->name
);
4428 folder_item_update_freeze();
4432 mlist
= folder_item_get_msg_list(item
);
4433 total
= g_slist_length(mlist
);
4434 statusbar_print_all(_("Processing messages..."));
4436 last_apply_per_account
= prefs_common
.apply_per_account_filtering_rules
;
4437 prefs_common
.apply_per_account_filtering_rules
= FILTERING_ACCOUNT_RULES_SKIP
;
4439 folder_item_set_batch(item
, TRUE
);
4440 for (cur
= mlist
; cur
!= NULL
; cur
= cur
->next
) {
4443 msginfo
= (MsgInfo
*) cur
->data
;
4445 /* reset parameters that can be modified by processing */
4446 msginfo
->hidden
= 0;
4449 statusbar_progress_all(curmsg
++,total
, 10);
4451 /* apply pre global rules */
4452 filter_message_by_msginfo(pre_global_processing
, msginfo
, NULL
,
4453 FILTERING_PRE_PROCESSING
, NULL
);
4455 /* apply rules of the folder */
4456 filter_message_by_msginfo(processing_list
, msginfo
, NULL
,
4457 FILTERING_FOLDER_PROCESSING
, item
->name
);
4459 /* apply post global rules */
4460 filter_message_by_msginfo(post_global_processing
, msginfo
, NULL
,
4461 FILTERING_POST_PROCESSING
, NULL
);
4462 if (curmsg
% 1000 == 0)
4465 folder_item_set_batch(item
, FALSE
);
4467 prefs_common
.apply_per_account_filtering_rules
= last_apply_per_account
;
4469 if (pre_global_processing
|| processing_list
4470 || post_global_processing
)
4471 filtering_move_and_copy_msgs(mlist
);
4472 for (cur
= mlist
; cur
!= NULL
; cur
= cur
->next
) {
4473 procmsg_msginfo_free((MsgInfo
**)&(cur
->data
));
4475 g_slist_free(mlist
);
4477 statusbar_progress_all(0,0,0);
4478 statusbar_pop_all();
4482 folder_item_update_thaw();
4486 * functions for handling FolderItem content changes
4488 static gint folder_item_update_freeze_cnt
= 0;
4490 static void folder_item_update_with_msg(FolderItem
*item
, FolderItemUpdateFlags update_flags
, MsgInfo
*msg
)
4492 if (folder_item_update_freeze_cnt
== 0 /* || (msg != NULL && item->opened) */) {
4493 FolderItemUpdateData source
;
4496 source
.update_flags
= update_flags
;
4498 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST
, &source
);
4500 item
->update_flags
|= update_flags
& ~(F_ITEM_UPDATE_ADDMSG
| F_ITEM_UPDATE_REMOVEMSG
);
4505 * Notify the folder system about changes to a folder. If the
4506 * update system is not frozen the FOLDER_ITEM_UPDATE_HOOKLIST will
4507 * be invoked, otherwise the changes will be remebered until
4508 * the folder system is thawed.
4510 * \param item The FolderItem that was changed
4511 * \param update_flags Type of changed that was made
4513 void folder_item_update(FolderItem
*item
, FolderItemUpdateFlags update_flags
)
4515 folder_item_update_with_msg(item
, update_flags
, NULL
);
4518 void folder_item_update_recursive(FolderItem
*item
, FolderItemUpdateFlags update_flags
)
4520 GNode
*node
= item
->folder
->node
;
4522 node
= g_node_find(node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, item
);
4523 node
= node
->children
;
4525 folder_item_update(item
, update_flags
);
4526 while (node
!= NULL
) {
4527 if (node
&& node
->data
) {
4528 FolderItem
*next_item
= (FolderItem
*) node
->data
;
4530 folder_item_update(next_item
, update_flags
);
4536 void folder_item_update_freeze(void)
4538 folder_item_update_freeze_cnt
++;
4541 static void folder_item_update_func(FolderItem
*item
, gpointer data
)
4543 FolderItemUpdateData source
;
4545 if (item
->update_flags
) {
4547 source
.update_flags
= item
->update_flags
;
4549 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST
, &source
);
4550 item
->update_flags
= 0;
4554 void folder_item_update_thaw(void)
4556 if (folder_item_update_freeze_cnt
> 0)
4557 folder_item_update_freeze_cnt
--;
4558 if (folder_item_update_freeze_cnt
== 0) {
4559 /* Update all folders */
4560 folder_func_to_all_folders(folder_item_update_func
, NULL
);
4564 void folder_item_synchronise(FolderItem
*item
)
4568 if (item
->prefs
->offlinesync
&& item
->folder
->klass
->synchronise
) {
4569 statuswindow_print_all(_("Synchronising %s for offline use...\n"), item
->path
? item
->path
: "(null)");
4570 item
->folder
->klass
->synchronise(item
,
4571 item
->prefs
->offlinesync_days
);
4572 if (item
->prefs
->offlinesync_days
> 0 &&
4573 item
->prefs
->remove_old_bodies
)
4574 folder_item_clean_local_files(item
, item
->prefs
->offlinesync_days
);
4575 statuswindow_pop_all();
4579 static void folder_item_synchronise_func(FolderItem
*item
, gpointer data
)
4581 Folder
*folder
= (Folder
*)data
;
4582 if (folder
== NULL
|| item
->folder
== folder
) {
4583 folder_item_synchronise(item
);
4587 void folder_synchronise(Folder
*folder
)
4589 folder_func_to_all_folders(folder_item_synchronise_func
, folder
);
4592 typedef struct _WantSyncData
{
4597 static void folder_item_want_synchronise_func(FolderItem
*item
, gpointer data
)
4599 WantSyncData
*want_sync_data
= (WantSyncData
*)data
;
4601 if (want_sync_data
->folder
== NULL
|| item
->folder
== want_sync_data
->folder
) {
4602 if (item
->prefs
->offlinesync
&& item
->folder
->klass
->synchronise
)
4603 want_sync_data
->want_sync
|= TRUE
;
4607 gboolean
folder_want_synchronise(Folder
*folder
)
4609 WantSyncData
*want_sync_data
= g_new0(WantSyncData
, 1);
4611 want_sync_data
->folder
= folder
;
4612 want_sync_data
->want_sync
= FALSE
;
4614 folder_func_to_all_folders(folder_item_want_synchronise_func
, want_sync_data
);
4615 result
= want_sync_data
->want_sync
;
4616 g_free(want_sync_data
);
4618 debug_print("Folder %s wants sync\n", folder
->name
);
4622 void folder_item_set_batch (FolderItem
*item
, gboolean batch
)
4624 if (!item
|| !item
->folder
)
4626 if (item
->folder
->klass
->set_batch
) {
4627 item
->folder
->klass
->set_batch(item
->folder
, item
, batch
);
4631 gboolean
folder_has_parent_of_type(FolderItem
*item
,
4632 SpecialFolderItemType type
)
4634 FolderItem
*cur
= item
;
4638 /* if we already know it, make it short */
4639 if (item
->parent_stype
!= -1) {
4640 return (item
->parent_stype
== type
);
4643 /* if we don't, find the type from the first possible parent,
4644 * and set our parent type to be faster next time */
4646 if (cur
->stype
== type
|| cur
->parent_stype
== type
) {
4647 item
->parent_stype
= type
;
4650 cur
= folder_item_parent(cur
);
4653 /* if we didn't match what was asked, we didn't return. If our
4654 * parent type is unknown, we may as well find it now to be faster
4656 if (item
->parent_stype
== -1) {
4659 /* here's an exception: Inbox subfolders are normal. */
4660 if (item
->parent_stype
== -1 && cur
->stype
== F_INBOX
4662 item
->parent_stype
= F_NORMAL
;
4665 /* ah, we know this parent's parent's type, we may as
4666 * well copy it instead of going up the full way */
4667 if (cur
->parent_stype
!= -1) {
4668 item
->parent_stype
= cur
->parent_stype
;
4671 /* we found a parent that has a special type. That's
4672 * our parent type. */
4673 if (cur
->stype
!= F_NORMAL
) {
4674 cur
->parent_stype
= cur
->stype
;
4675 item
->parent_stype
= cur
->stype
;
4678 /* if we didn't find anything, go up once more */
4679 cur
= folder_item_parent(cur
);
4681 /* as we still didn't find anything, our parents must all be
4683 if (item
->parent_stype
== -1) {
4684 item
->parent_stype
= F_NORMAL
;
4690 gboolean
folder_is_child_of(FolderItem
*item
, FolderItem
*parent
)
4692 if (item
== NULL
|| parent
== NULL
)
4695 while (item
!= NULL
) {
4699 item
= folder_item_parent(item
);
4706 gboolean
folder_subscribe (const gchar
*uri
)
4709 for (cur
= folder_get_list(); cur
!= NULL
; cur
= g_list_next(cur
)) {
4710 Folder
*folder
= (Folder
*) cur
->data
;
4712 if (folder
->klass
->subscribe
4713 && folder
->klass
->subscribe(folder
, uri
)) {
4721 gboolean
folder_get_sort_type (Folder
*folder
,
4722 FolderSortKey
*sort_key
,
4723 FolderSortType
*sort_type
)
4725 if (!folder
|| !sort_key
|| !sort_type
)
4727 if (folder
->klass
->get_sort_type
== NULL
)
4729 folder
->klass
->get_sort_type(folder
, sort_key
, sort_type
);
4733 gint
folder_item_search_msgs (Folder
*folder
,
4734 FolderItem
*container
,
4735 MsgNumberList
**msgs
,
4736 gboolean
*on_server
,
4737 MatcherList
*predicate
,
4738 SearchProgressNotify progress_cb
,
4739 gpointer progress_data
)
4743 folder_item_update_freeze();
4745 if (folder
->klass
->search_msgs
)
4746 result
= folder
->klass
->search_msgs(folder
, container
,
4747 msgs
, on_server
, predicate
, progress_cb
, progress_data
);
4749 result
= folder_item_search_msgs_local(folder
, container
,
4750 msgs
, on_server
, predicate
, progress_cb
, progress_data
);
4752 folder_item_update_thaw();
4757 MsgNumberList
*folder_item_get_number_list(FolderItem
*item
)
4759 GSList
*nums
= NULL
;
4760 GSList
*msglist
= folder_item_get_msg_list(item
);
4762 nums
= procmsg_get_number_list_for_msgs(msglist
);
4763 procmsg_msg_list_free(msglist
);
4768 gint
folder_item_search_msgs_local (Folder
*folder
,
4769 FolderItem
*container
,
4770 MsgNumberList
**msgs
,
4771 gboolean
*on_server
,
4772 MatcherList
*predicate
,
4773 SearchProgressNotify progress_cb
,
4774 gpointer progress_data
)
4776 GSList
*result
= NULL
;
4778 gint matched_count
= 0;
4779 guint processed_count
= 0;
4781 GSList
*nums
= NULL
;
4783 if (*msgs
== NULL
) {
4784 nums
= folder_item_get_number_list(container
);
4789 msgcount
= g_slist_length(nums
);
4794 for (cur
= nums
; cur
!= NULL
; cur
= cur
->next
) {
4795 guint msgnum
= GPOINTER_TO_UINT(cur
->data
);
4796 MsgInfo
*msg
= folder_item_get_msginfo(container
, msgnum
);
4799 g_slist_free(result
);
4803 if (matcherlist_match(predicate
, msg
)) {
4804 result
= g_slist_prepend(result
, GUINT_TO_POINTER(msg
->msgnum
));
4809 procmsg_msginfo_free(&msg
);
4811 if (progress_cb
!= NULL
4812 && !progress_cb(progress_data
, FALSE
, processed_count
,
4813 matched_count
, msgcount
))
4818 *msgs
= g_slist_reverse(result
);
4820 return matched_count
;
4823 /* Tests if a local (on disk) folder name is acceptable. */
4824 gboolean
folder_local_name_ok(const gchar
*name
)
4827 if (name
[0] == '.' || name
[strlen(name
) - 1] == '.') {
4828 alertpanel_error(_("A folder name cannot begin or end with a dot."));
4831 if (name
[strlen(name
) - 1] == ' ') {
4832 alertpanel_error(_("A folder name can not end with a space."));