2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2012 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/>.
22 #include "claws-features.h"
28 #include <glib/gi18n.h>
31 #include <sys/types.h>
39 #include "alertpanel.h"
49 #include "prefs_gtk.h"
51 #include "filtering.h"
52 #include "procheader.h"
55 #include "folder_item_prefs.h"
56 #include "remotefolder.h"
57 #include "partial_download.h"
58 #include "statusbar.h"
66 /* Dependecies to be removed ?! */
67 #include "prefs_common.h"
68 #include "prefs_account.h"
70 /* Define possible missing constants for Windows. */
82 static GList
*folder_list
= NULL
;
83 static GSList
*class_list
= NULL
;
84 static GSList
*folder_unloaded_list
= NULL
;
86 void folder_init (Folder
*folder
,
89 static gchar
*folder_item_get_cache_file (FolderItem
*item
);
90 static gchar
*folder_item_get_mark_file (FolderItem
*item
);
91 static gchar
*folder_item_get_tags_file (FolderItem
*item
);
92 static GNode
*folder_get_xml_node (Folder
*folder
);
93 static Folder
*folder_get_from_xml (GNode
*node
);
94 static void folder_update_op_count_rec (GNode
*node
);
97 static void folder_get_persist_prefs_recursive
98 (GNode
*node
, GHashTable
*pptable
);
99 static gboolean
persist_prefs_free (gpointer key
, gpointer val
, gpointer data
);
100 static void folder_item_read_cache (FolderItem
*item
);
101 gint
folder_item_scan_full (FolderItem
*item
, gboolean filtering
);
102 static void folder_item_update_with_msg (FolderItem
*item
, FolderItemUpdateFlags update_flags
,
104 static GHashTable
*folder_persist_prefs_new (Folder
*folder
);
105 static void folder_persist_prefs_free (GHashTable
*pptable
);
106 static void folder_item_restore_persist_prefs (FolderItem
*item
, GHashTable
*pptable
);
108 void folder_system_init(void)
110 folder_register_class(mh_get_class());
111 folder_register_class(imap_get_class());
112 folder_register_class(news_get_class());
115 static GSList
*folder_get_class_list(void)
120 void folder_register_class(FolderClass
*klass
)
122 GSList
*xmllist
, *cur
;
124 debug_print("registering folder class %s\n", klass
->idstr
);
126 class_list
= g_slist_append(class_list
, klass
);
128 xmllist
= g_slist_copy(folder_unloaded_list
);
129 for (cur
= xmllist
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
130 GNode
*node
= (GNode
*) cur
->data
;
131 XMLNode
*xmlnode
= (XMLNode
*) node
->data
;
132 GList
*cur
= xmlnode
->tag
->attr
;
134 for (; cur
!= NULL
; cur
= g_list_next(cur
)) {
135 XMLAttr
*attr
= (XMLAttr
*) cur
->data
;
137 if (!attr
|| !attr
->name
|| !attr
->value
) continue;
138 if (!strcmp(attr
->name
, "type") && !strcmp(attr
->value
, klass
->idstr
)) {
141 folder
= folder_get_from_xml(node
);
144 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
= g_node_new(item
);
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
);
654 XMLTag
*folder_item_get_xml(Folder
*folder
, FolderItem
*item
)
656 static gchar
*folder_item_stype_str
[] = {"normal", "inbox", "outbox",
657 "draft", "queue", "trash"};
658 static gchar
*sort_key_str
[] = {"none", "number", "size", "date",
659 "from", "subject", "score", "label",
660 "mark", "unread", "mime", "to",
661 "locked", "tags", "thread_date" };
665 tag
= xml_tag_new("folderitem");
667 xml_tag_add_attr(tag
, xml_attr_new("type", folder_item_stype_str
[item
->stype
]));
669 xml_tag_add_attr(tag
, xml_attr_new("name", item
->name
));
671 xml_tag_add_attr(tag
, xml_attr_new("path", item
->path
));
673 xml_tag_add_attr(tag
, xml_attr_new("no_sub", "1"));
675 xml_tag_add_attr(tag
, xml_attr_new("no_select", "1"));
676 xml_tag_add_attr(tag
, xml_attr_new("collapsed", item
->collapsed
&& item
->node
->children
? "1" : "0"));
677 xml_tag_add_attr(tag
, xml_attr_new("thread_collapsed", item
->thread_collapsed
? "1" : "0"));
678 xml_tag_add_attr(tag
, xml_attr_new("threaded", item
->threaded
? "1" : "0"));
679 xml_tag_add_attr(tag
, xml_attr_new("hidereadmsgs", item
->hide_read_msgs
? "1" : "0"));
680 xml_tag_add_attr(tag
, xml_attr_new("hidedelmsgs", item
->hide_del_msgs
? "1" : "0"));
681 xml_tag_add_attr(tag
, xml_attr_new("hidereadthreads", item
->hide_read_threads
? "1" : "0"));
683 xml_tag_add_attr(tag
, xml_attr_new("reqretrcpt", "1"));
685 if (item
->sort_key
!= SORT_BY_NONE
) {
686 xml_tag_add_attr(tag
, xml_attr_new("sort_key", sort_key_str
[item
->sort_key
]));
687 xml_tag_add_attr(tag
, xml_attr_new("sort_type", item
->sort_type
== SORT_ASCENDING
? "ascending" : "descending"));
690 value
= g_strdup_printf("%ld", (unsigned long int) item
->mtime
);
691 xml_tag_add_attr(tag
, xml_attr_new("mtime", value
));
693 xml_tag_add_attr(tag
, xml_attr_new_int("new", item
->new_msgs
));
694 xml_tag_add_attr(tag
, xml_attr_new_int("unread", item
->unread_msgs
));
695 xml_tag_add_attr(tag
, xml_attr_new_int("unreadmarked", item
->unreadmarked_msgs
));
696 xml_tag_add_attr(tag
, xml_attr_new_int("marked", item
->marked_msgs
));
697 xml_tag_add_attr(tag
, xml_attr_new_int("total", item
->total_msgs
));
698 xml_tag_add_attr(tag
, xml_attr_new_int("replied", item
->replied_msgs
));
699 xml_tag_add_attr(tag
, xml_attr_new_int("forwarded", item
->forwarded_msgs
));
700 xml_tag_add_attr(tag
, xml_attr_new_int("locked", item
->locked_msgs
));
701 xml_tag_add_attr(tag
, xml_attr_new_int("ignore", item
->ignored_msgs
));
702 xml_tag_add_attr(tag
, xml_attr_new_int("watched", item
->watched_msgs
));
703 xml_tag_add_attr(tag
, xml_attr_new_int("order", item
->order
));
706 xml_tag_add_attr(tag
, xml_attr_new_int("account_id", item
->account
->account_id
));
708 xml_tag_add_attr(tag
, xml_attr_new("apply_sub", "1"));
710 xml_tag_add_attr(tag
, xml_attr_new_int("last_seen", item
->last_seen
));
715 void folder_set_ui_func(Folder
*folder
, FolderUIFunc func
, gpointer data
)
717 cm_return_if_fail(folder
!= NULL
);
719 folder
->ui_func
= func
;
720 folder
->ui_func_data
= data
;
723 void folder_set_name(Folder
*folder
, const gchar
*name
)
725 cm_return_if_fail(folder
!= NULL
);
727 g_free(folder
->name
);
728 folder
->name
= name
? g_strdup(name
) : NULL
;
729 if (folder
->node
&& folder
->node
->data
) {
730 FolderItem
*item
= (FolderItem
*)folder
->node
->data
;
733 item
->name
= name
? g_strdup(name
) : NULL
;
737 void folder_set_sort(Folder
*folder
, guint sort
)
739 cm_return_if_fail(folder
!= NULL
);
741 if (folder
->sort
!= sort
) {
742 folder_remove(folder
);
748 static gboolean
folder_tree_destroy_func(GNode
*node
, gpointer data
) {
749 FolderItem
*item
= (FolderItem
*) node
->data
;
751 folder_item_destroy(item
);
755 void folder_tree_destroy(Folder
*folder
)
759 cm_return_if_fail(folder
!= NULL
);
763 prefs_filtering_clear_folder(folder
);
766 g_node_traverse(node
, G_POST_ORDER
, G_TRAVERSE_ALL
, -1,
767 folder_tree_destroy_func
, NULL
);
768 g_node_destroy(node
);
773 void folder_add(Folder
*folder
)
778 FolderUpdateData hookdata
;
780 cm_return_if_fail(folder
!= NULL
);
782 if ((FOLDER_TYPE(folder
) == F_IMAP
||
783 FOLDER_TYPE(folder
) == F_NEWS
) &&
784 folder
->account
== NULL
) {
788 for (i
= 0, cur
= folder_list
; cur
!= NULL
; cur
= cur
->next
, i
++) {
789 cur_folder
= FOLDER(cur
->data
);
790 if (cur_folder
->sort
< folder
->sort
)
794 folder_list
= g_list_insert(folder_list
, folder
, i
);
796 hookdata
.folder
= folder
;
797 hookdata
.update_flags
= FOLDER_ADD_FOLDER
;
798 hookdata
.item
= NULL
;
799 hookdata
.item2
= NULL
;
800 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
803 void folder_remove(Folder
*folder
)
805 FolderUpdateData hookdata
;
807 cm_return_if_fail(folder
!= NULL
);
809 folder_list
= g_list_remove(folder_list
, folder
);
811 hookdata
.folder
= folder
;
812 hookdata
.update_flags
= FOLDER_REMOVE_FOLDER
;
813 hookdata
.item
= NULL
;
814 hookdata
.item2
= NULL
;
815 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
818 GList
*folder_get_list(void)
823 gint
folder_read_list(void)
829 path
= folder_get_list_path();
830 if (!is_file_exist(path
)) return -1;
831 node
= xml_parse_file(path
);
832 if (!node
) return -1;
834 xmlnode
= node
->data
;
835 if (strcmp2(xmlnode
->tag
->tag
, "folderlist") != 0) {
836 g_warning("wrong folder list");
841 cur
= node
->children
;
842 while (cur
!= NULL
) {
845 folder
= folder_get_from_xml(cur
);
849 folder_unloaded_list
= g_slist_append(folder_unloaded_list
,
850 (gpointer
) xml_copy_tree(cur
));
855 if (folder_list
|| folder_unloaded_list
)
861 void folder_write_list(void)
872 path
= folder_get_list_path();
873 if ((pfile
= prefs_write_open(path
)) == NULL
) return;
875 if (xml_file_put_xml_decl(pfile
->fp
) < 0) {
876 prefs_file_close_revert(pfile
);
877 g_warning("failed to start write folder list.");
880 tag
= xml_tag_new("folderlist");
882 xmlnode
= xml_node_new(tag
, NULL
);
884 rootnode
= g_node_new(xmlnode
);
886 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
890 node
= folder_get_xml_node(folder
);
892 g_node_append(rootnode
, node
);
895 for (slist
= folder_unloaded_list
; slist
!= NULL
; slist
= g_slist_next(slist
)) {
896 GNode
*node
= (GNode
*) slist
->data
;
898 g_node_append(rootnode
, (gpointer
) xml_copy_tree(node
));
901 if (xml_write_tree(rootnode
, pfile
->fp
) < 0) {
902 prefs_file_close_revert(pfile
);
903 g_warning("failed to write folder list.");
904 } else if (prefs_file_close(pfile
) < 0) {
905 g_warning("failed to write folder list.");
907 xml_free_tree(rootnode
);
910 static gboolean
folder_scan_tree_func(GNode
*node
, gpointer data
)
912 GHashTable
*pptable
= (GHashTable
*)data
;
913 FolderItem
*item
= (FolderItem
*)node
->data
;
915 folder_item_restore_persist_prefs(item
, pptable
);
916 folder_item_scan_full(item
, FALSE
);
921 static gboolean
folder_restore_prefs_func(GNode
*node
, gpointer data
)
923 GHashTable
*pptable
= (GHashTable
*)data
;
924 FolderItem
*item
= (FolderItem
*)node
->data
;
926 folder_item_restore_persist_prefs(item
, pptable
);
931 void folder_scan_tree(Folder
*folder
, gboolean rebuild
)
934 FolderUpdateData hookdata
;
935 Folder
*old_folder
= folder
;
937 if (!folder
->klass
->scan_tree
)
940 pptable
= folder_persist_prefs_new(folder
);
943 folder_remove(folder
);
945 if (folder
->klass
->scan_tree(folder
) < 0) {
947 folder_add(old_folder
);
952 hookdata
.folder
= folder
;
953 hookdata
.update_flags
= FOLDER_TREE_CHANGED
;
954 hookdata
.item
= NULL
;
955 hookdata
.item2
= NULL
;
956 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
959 g_node_traverse(folder
->node
, G_POST_ORDER
, G_TRAVERSE_ALL
, -1, folder_scan_tree_func
, pptable
);
961 g_node_traverse(folder
->node
, G_POST_ORDER
, G_TRAVERSE_ALL
, -1, folder_restore_prefs_func
, pptable
);
963 folder_persist_prefs_free(pptable
);
965 prefs_matcher_read_config();
970 FolderItem
*folder_create_folder(FolderItem
*parent
, const gchar
*name
)
972 FolderItem
*new_item
;
974 cm_return_val_if_fail(parent
!= NULL
, NULL
);
976 new_item
= parent
->folder
->klass
->create_folder(parent
->folder
, parent
, name
);
978 FolderUpdateData hookdata
;
980 new_item
->cache
= msgcache_new();
981 new_item
->cache_dirty
= TRUE
;
982 new_item
->mark_dirty
= TRUE
;
983 new_item
->tags_dirty
= TRUE
;
985 hookdata
.folder
= new_item
->folder
;
986 hookdata
.update_flags
= FOLDER_TREE_CHANGED
| FOLDER_ADD_FOLDERITEM
;
987 hookdata
.item
= new_item
;
988 hookdata
.item2
= NULL
;
989 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
995 gint
folder_item_rename(FolderItem
*item
, gchar
*newname
)
999 cm_return_val_if_fail(item
!= NULL
, -1);
1000 cm_return_val_if_fail(newname
!= NULL
, -1);
1002 retval
= item
->folder
->klass
->rename_folder(item
->folder
, item
, newname
);
1005 FolderItemUpdateData hookdata
;
1006 FolderUpdateData hookdata2
;
1008 hookdata
.item
= item
;
1009 hookdata
.update_flags
= F_ITEM_UPDATE_NAME
;
1010 hookdata
.msg
= NULL
;
1011 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST
, &hookdata
);
1013 hookdata2
.folder
= item
->folder
;
1014 hookdata2
.item
= item
;
1015 hookdata2
.item2
= NULL
;
1016 hookdata2
.update_flags
= FOLDER_RENAME_FOLDERITEM
;
1017 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata2
);
1023 struct TotalMsgCount
1027 guint unreadmarked_msgs
;
1031 guint forwarded_msgs
;
1037 struct FuncToAllFoldersData
1039 FolderItemFunc function
;
1043 static gboolean
folder_func_to_all_folders_func(GNode
*node
, gpointer data
)
1046 struct FuncToAllFoldersData
*function_data
= (struct FuncToAllFoldersData
*) data
;
1048 cm_return_val_if_fail(node
->data
!= NULL
, FALSE
);
1050 item
= FOLDER_ITEM(node
->data
);
1051 cm_return_val_if_fail(item
!= NULL
, FALSE
);
1053 function_data
->function(item
, function_data
->data
);
1058 void folder_func_to_all_folders(FolderItemFunc function
, gpointer data
)
1062 struct FuncToAllFoldersData function_data
;
1064 function_data
.function
= function
;
1065 function_data
.data
= data
;
1067 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1068 folder
= FOLDER(list
->data
);
1070 g_node_traverse(folder
->node
, G_PRE_ORDER
,
1072 folder_func_to_all_folders_func
,
1077 static void folder_count_total_msgs_func(FolderItem
*item
, gpointer data
)
1079 struct TotalMsgCount
*count
= (struct TotalMsgCount
*)data
;
1081 count
->new_msgs
+= item
->new_msgs
;
1082 count
->unread_msgs
+= item
->unread_msgs
;
1083 count
->unreadmarked_msgs
+= item
->unreadmarked_msgs
;
1084 count
->marked_msgs
+= item
->marked_msgs
;
1085 count
->total_msgs
+= item
->total_msgs
;
1086 count
->replied_msgs
+= item
->replied_msgs
;
1087 count
->forwarded_msgs
+= item
->forwarded_msgs
;
1088 count
->locked_msgs
+= item
->locked_msgs
;
1089 count
->ignored_msgs
+= item
->ignored_msgs
;
1090 count
->watched_msgs
+= item
->watched_msgs
;
1093 struct TotalMsgStatus
1101 static gboolean
folder_get_status_full_all_func(GNode
*node
, gpointer data
)
1104 struct TotalMsgStatus
*status
= (struct TotalMsgStatus
*)data
;
1107 cm_return_val_if_fail(node
->data
!= NULL
, FALSE
);
1109 item
= FOLDER_ITEM(node
->data
);
1111 if (!item
->path
) return FALSE
;
1113 status
->new += item
->new_msgs
;
1114 status
->unread
+= item
->unread_msgs
;
1115 status
->total
+= item
->total_msgs
;
1118 id
= folder_item_get_identifier(item
);
1119 g_string_append_printf(status
->str
, "%5d %5d %5d %s\n",
1120 item
->new_msgs
, item
->unread_msgs
,
1121 item
->total_msgs
, id
);
1128 static void folder_get_status_full_all(GString
*str
, guint
*new, guint
*unread
,
1133 struct TotalMsgStatus status
;
1135 status
.new = status
.unread
= status
.total
= 0;
1138 debug_print("Counting total number of messages...\n");
1140 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1141 folder
= FOLDER(list
->data
);
1143 g_node_traverse(folder
->node
, G_PRE_ORDER
,
1145 folder_get_status_full_all_func
,
1150 *unread
= status
.unread
;
1151 *total
= status
.total
;
1154 gchar
*folder_get_status(GPtrArray
*folders
, gboolean full
)
1156 guint
new, unread
, total
;
1161 new = unread
= total
= 0;
1163 str
= g_string_new(NULL
);
1166 for (i
= 0; i
< folders
->len
; i
++) {
1169 item
= g_ptr_array_index(folders
, i
);
1170 new += item
->new_msgs
;
1171 unread
+= item
->unread_msgs
;
1172 total
+= item
->total_msgs
;
1177 id
= folder_item_get_identifier(item
);
1178 g_string_append_printf(str
, "%5d %5d %5d %s\n",
1179 item
->new_msgs
, item
->unread_msgs
,
1180 item
->total_msgs
, id
);
1185 folder_get_status_full_all(full
? str
: NULL
,
1186 &new, &unread
, &total
);
1190 g_string_append_printf(str
, "%5d %5d %5d\n", new, unread
, total
);
1192 g_string_append_printf(str
, "%d %d %d\n", new, unread
, total
);
1195 g_string_free(str
, FALSE
);
1200 void folder_count_total_msgs(guint
*new_msgs
, guint
*unread_msgs
,
1201 guint
*unreadmarked_msgs
, guint
*marked_msgs
,
1202 guint
*total_msgs
, guint
*replied_msgs
,
1203 guint
*forwarded_msgs
, guint
*locked_msgs
,
1204 guint
*ignored_msgs
, guint
*watched_msgs
)
1206 struct TotalMsgCount count
;
1208 count
.new_msgs
= count
.unread_msgs
= count
.unreadmarked_msgs
= 0;
1209 count
.total_msgs
= count
.replied_msgs
= count
.forwarded_msgs
= 0;
1210 count
.locked_msgs
= count
.ignored_msgs
= count
.watched_msgs
= 0;
1211 count
.marked_msgs
= 0;
1213 debug_print("Counting total number of messages...\n");
1215 folder_func_to_all_folders(folder_count_total_msgs_func
, &count
);
1217 *new_msgs
= count
.new_msgs
;
1218 *unread_msgs
= count
.unread_msgs
;
1219 *unreadmarked_msgs
= count
.unreadmarked_msgs
;
1220 *marked_msgs
= count
.marked_msgs
;
1221 *total_msgs
= count
.total_msgs
;
1222 *replied_msgs
= count
.replied_msgs
;
1223 *forwarded_msgs
= count
.forwarded_msgs
;
1224 *locked_msgs
= count
.locked_msgs
;
1225 *ignored_msgs
= count
.ignored_msgs
;
1226 *watched_msgs
= count
.watched_msgs
;
1229 Folder
*folder_find_from_path(const gchar
*path
)
1234 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1235 folder
= list
->data
;
1236 if ((FOLDER_TYPE(folder
) == F_MH
||
1237 FOLDER_TYPE(folder
) == F_MBOX
) &&
1238 !path_cmp(LOCAL_FOLDER(folder
)->rootpath
, path
))
1245 Folder
*folder_find_from_name(const gchar
*name
, FolderClass
*klass
)
1250 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1251 folder
= list
->data
;
1252 if (folder
->klass
== klass
&&
1253 strcmp2(name
, folder
->name
) == 0)
1260 static gboolean
folder_item_find_func(GNode
*node
, gpointer data
)
1262 FolderItem
*item
= node
->data
;
1264 const gchar
*path
= d
[0];
1266 if (path_cmp(path
, item
->path
) != 0)
1274 FolderItem
*folder_find_item_from_path(const gchar
*path
)
1278 GList
*list
= folder_get_list();
1280 folder
= list
? list
->data
:NULL
;
1282 cm_return_val_if_fail(folder
!= NULL
, NULL
);
1284 d
[0] = (gpointer
)path
;
1286 while (d
[1] == NULL
&& list
) {
1287 folder
= FOLDER(list
->data
);
1288 g_node_traverse(folder
->node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, -1,
1289 folder_item_find_func
, d
);
1295 static gboolean
folder_item_find_func_real_path(GNode
*node
, gpointer data
)
1297 FolderItem
*item
= node
->data
;
1299 const gchar
*path
= d
[0];
1300 gchar
*tmp
= folder_item_get_path(item
);
1301 if (path_cmp(path
, tmp
) != 0) {
1311 FolderItem
*folder_find_item_from_real_path(const gchar
*path
)
1315 GList
*list
= folder_get_list();
1317 folder
= list
? list
->data
:NULL
;
1319 cm_return_val_if_fail(folder
!= NULL
, NULL
);
1321 d
[0] = (gpointer
)path
;
1323 while (d
[1] == NULL
&& list
) {
1324 folder
= FOLDER(list
->data
);
1325 g_node_traverse(folder
->node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, -1,
1326 folder_item_find_func_real_path
, d
);
1332 FolderItem
*folder_find_child_item_by_name(FolderItem
*item
, const gchar
*name
)
1337 for (node
= item
->node
->children
; node
!= NULL
; node
= node
->next
) {
1338 child
= FOLDER_ITEM(node
->data
);
1339 if (strcmp2(child
->name
, name
) == 0) {
1347 FolderClass
*folder_get_class_from_string(const gchar
*str
)
1351 classlist
= folder_get_class_list();
1352 for (; classlist
!= NULL
; classlist
= g_slist_next(classlist
)) {
1353 FolderClass
*class = (FolderClass
*) classlist
->data
;
1354 if (g_ascii_strcasecmp(class->idstr
, str
) == 0)
1361 gchar
*folder_get_identifier(Folder
*folder
)
1365 cm_return_val_if_fail(folder
!= NULL
, NULL
);
1367 type_str
= folder
->klass
->idstr
;
1368 return g_strconcat("#", type_str
, "/", folder
->name
, NULL
);
1371 gchar
*folder_item_get_identifier(FolderItem
*item
)
1374 gchar
*folder_id
= NULL
;
1376 cm_return_val_if_fail(item
!= NULL
, NULL
);
1378 if (item
->path
== NULL
)
1381 folder_id
= folder_get_identifier(item
->folder
);
1382 id
= g_strconcat(folder_id
, "/", item
->path
, NULL
);
1388 Folder
*folder_find_from_identifier(const gchar
*identifier
)
1395 cm_return_val_if_fail(identifier
!= NULL
, NULL
);
1397 if (*identifier
!= '#')
1400 Xstrdup_a(str
, identifier
, return NULL
);
1402 p
= strchr(str
, '/');
1407 class = folder_get_class_from_string(&str
[1]);
1416 return folder_find_from_name(name
, class);
1419 FolderItem
*folder_find_item_from_identifier(const gchar
*identifier
)
1429 cm_return_val_if_fail(identifier
!= NULL
, NULL
);
1431 if (*identifier
!= '#')
1432 return folder_find_item_from_path(identifier
);
1434 Xstrdup_a(str
, identifier
, return NULL
);
1436 p
= strchr(str
, '/');
1438 return folder_find_item_from_path(identifier
);
1441 class = folder_get_class_from_string(&str
[1]);
1443 return folder_find_item_from_path(identifier
);
1448 return folder_find_item_from_path(identifier
);
1452 folder
= folder_find_from_name(name
, class);
1454 return folder_find_item_from_path(identifier
);
1458 d
[0] = (gpointer
)path
;
1460 g_node_traverse(folder
->node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, -1,
1461 folder_item_find_func
, d
);
1465 /** Returns the FolderItem from a given identifier
1467 * The FolderItem is created if it doesn't already exist.
1468 * If creation failed, the function returns NULL.
1470 * Identifiers are of the form #type/Mailbox/FolderA/FolderB/FolderC
1472 FolderItem
*folder_get_item_from_identifier(const gchar
*identifier
)
1474 FolderItem
*item
, *last_parent
;
1476 gchar
*p1
, *p2
, *str
;
1479 gboolean created_something
= FALSE
;
1481 item
= folder_find_item_from_identifier(identifier
);
1485 /* trivial sanity check: need at least # and two slashes */
1486 len
= strlen(identifier
);
1490 /* make sure identifier ends with a slash */
1491 if(identifier
[len
-1] == G_DIR_SEPARATOR
) {
1492 Xstrdup_a(str
, identifier
, return NULL
);
1495 Xstrndup_a(str
, identifier
, len
+1, return NULL
);
1496 str
[len
] = G_DIR_SEPARATOR
;
1499 /* find folder class */
1500 p1
= strchr(str
, G_DIR_SEPARATOR
);
1504 class = folder_get_class_from_string(&str
[1]);
1507 *p1
= G_DIR_SEPARATOR
;
1510 /* find folder from class and name */
1511 p2
= strchr(p1
, G_DIR_SEPARATOR
);
1515 folder
= folder_find_from_name(p1
, class);
1518 *p2
= G_DIR_SEPARATOR
;
1522 /* Now, move forward and make sure all sections in the path exist */
1523 last_parent
= folder
->node
->data
;
1524 while((p1
= strchr(p1
, G_DIR_SEPARATOR
)) != NULL
) {
1526 item
= folder_find_item_from_identifier(str
);
1528 item
= folder_create_folder(last_parent
, p2
);
1531 debug_print("Created folder '%s'\n", str
);
1532 created_something
= TRUE
;
1533 if(prefs_common
.inherit_folder_props
&& (last_parent
!= item
->folder
->node
->data
)) {
1534 folder_item_prefs_copy_prefs(last_parent
, item
);
1538 *p1
= G_DIR_SEPARATOR
;
1543 if(created_something
)
1544 folder_write_list();
1551 * Get a displayable name for a FolderItem
1553 * \param item FolderItem for that a name should be created
1554 * \return Displayable name for item, returned string has to
1557 gchar
*folder_item_get_name(FolderItem
*item
)
1561 cm_return_val_if_fail(item
!= NULL
, g_strdup(""));
1563 switch (item
->stype
) {
1565 name
= g_strdup(!strcmp2(item
->name
, INBOX_DIR
) ? _("Inbox") :
1569 name
= g_strdup(!strcmp2(item
->name
, OUTBOX_DIR
) ? _("Sent") :
1573 name
= g_strdup(!strcmp2(item
->name
, QUEUE_DIR
) ? _("Queue") :
1577 name
= g_strdup(!strcmp2(item
->name
, TRASH_DIR
) ? _("Trash") :
1581 name
= g_strdup(!strcmp2(item
->name
, DRAFT_DIR
) ? _("Drafts") :
1590 * should probably be done by a virtual function,
1591 * the folder knows the ui string and how to abbrev
1593 if (folder_item_parent(item
) == NULL
) {
1594 name
= g_strconcat(item
->name
, " (", item
->folder
->klass
->uistr
, ")", NULL
);
1596 if (FOLDER_CLASS(item
->folder
) == news_get_class() &&
1597 item
->path
&& !strcmp2(item
->name
, item
->path
))
1598 name
= get_abbrev_newsgroup_name
1600 prefs_common
.ng_abbrev_len
);
1602 name
= g_strdup(item
->name
);
1607 name
= g_strdup("");
1612 gboolean
folder_have_mailbox (void)
1615 for (cur
= folder_list
; cur
!= NULL
; cur
= g_list_next(cur
)) {
1616 Folder
*folder
= FOLDER(cur
->data
);
1617 if (folder
->inbox
&& folder
->outbox
)
1623 FolderItem
*folder_get_default_inbox(void)
1627 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1628 Folder
* folder
= FOLDER(flist
->data
);
1632 if (folder
->inbox
== NULL
)
1634 if (folder
->klass
->type
== F_UNKNOWN
)
1637 return folder
->inbox
;
1643 FolderItem
*folder_get_default_inbox_for_class(FolderType type
)
1647 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1648 Folder
* folder
= FOLDER(flist
->data
);
1652 if (folder
->inbox
== NULL
)
1654 if (folder
->klass
->type
!= type
)
1657 return folder
->inbox
;
1663 FolderItem
*folder_get_default_outbox(void)
1667 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1668 Folder
* folder
= FOLDER(flist
->data
);
1672 if (folder
->outbox
== NULL
)
1674 if (folder
->klass
->type
== F_UNKNOWN
)
1677 return folder
->outbox
;
1683 FolderItem
*folder_get_default_outbox_for_class(FolderType type
)
1687 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1688 Folder
* folder
= FOLDER(flist
->data
);
1692 if (folder
->outbox
== NULL
)
1694 if (folder
->klass
->type
!= type
)
1697 return folder
->outbox
;
1703 FolderItem
*folder_get_default_draft(void)
1707 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1708 Folder
* folder
= FOLDER(flist
->data
);
1712 if (folder
->draft
== NULL
)
1714 if (folder
->klass
->type
== F_UNKNOWN
)
1717 return folder
->draft
;
1723 FolderItem
*folder_get_default_draft_for_class(FolderType type
)
1727 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1728 Folder
* folder
= FOLDER(flist
->data
);
1732 if (folder
->draft
== NULL
)
1734 if (folder
->klass
->type
!= type
)
1737 return folder
->draft
;
1743 FolderItem
*folder_get_default_queue(void)
1747 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1748 Folder
* folder
= FOLDER(flist
->data
);
1752 if (folder
->queue
== NULL
)
1754 if (folder
->klass
->type
== F_UNKNOWN
)
1757 return folder
->queue
;
1763 FolderItem
*folder_get_default_queue_for_class(FolderType type
)
1767 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1768 Folder
* folder
= FOLDER(flist
->data
);
1772 if (folder
->queue
== NULL
)
1774 if (folder
->klass
->type
!= type
)
1777 return folder
->queue
;
1783 FolderItem
*folder_get_default_trash(void)
1787 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1788 Folder
* folder
= FOLDER(flist
->data
);
1792 if (folder
->trash
== NULL
)
1794 if (folder
->klass
->type
== F_UNKNOWN
)
1797 return folder
->trash
;
1803 FolderItem
*folder_get_default_trash_for_class(FolderType type
)
1807 for (flist
= folder_list
; flist
!= NULL
; flist
= g_list_next(flist
)) {
1808 Folder
* folder
= FOLDER(flist
->data
);
1812 if (folder
->trash
== NULL
)
1814 if (folder
->klass
->type
!= type
)
1817 return folder
->trash
;
1823 #define CREATE_FOLDER_IF_NOT_EXIST(member, dir, type) \
1825 if (!folder->member) { \
1826 item = folder_item_new(folder, dir, dir); \
1827 item->stype = type; \
1828 folder_item_append(rootitem, item); \
1829 folder->member = item; \
1833 void folder_set_missing_folders(void)
1836 FolderItem
*rootitem
;
1840 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1841 folder
= list
->data
;
1842 if (FOLDER_TYPE(folder
) != F_MH
) continue;
1843 rootitem
= FOLDER_ITEM(folder
->node
->data
);
1844 cm_return_if_fail(rootitem
!= NULL
);
1846 if (folder
->inbox
&& folder
->outbox
&& folder
->draft
&&
1847 folder
->queue
&& folder
->trash
)
1850 if (folder
->klass
->create_tree(folder
) < 0) {
1851 g_warning("%s: can't create the folder tree.",
1852 LOCAL_FOLDER(folder
)->rootpath
);
1856 CREATE_FOLDER_IF_NOT_EXIST(inbox
, INBOX_DIR
, F_INBOX
);
1857 CREATE_FOLDER_IF_NOT_EXIST(outbox
, OUTBOX_DIR
, F_OUTBOX
);
1858 CREATE_FOLDER_IF_NOT_EXIST(draft
, DRAFT_DIR
, F_DRAFT
);
1859 CREATE_FOLDER_IF_NOT_EXIST(queue
, QUEUE_DIR
, F_QUEUE
);
1860 CREATE_FOLDER_IF_NOT_EXIST(trash
, TRASH_DIR
, F_TRASH
);
1864 static gboolean
folder_unref_account_func(GNode
*node
, gpointer data
)
1866 FolderItem
*item
= node
->data
;
1867 PrefsAccount
*account
= data
;
1869 if (item
->account
== account
)
1870 item
->account
= NULL
;
1875 void folder_unref_account_all(PrefsAccount
*account
)
1880 if (!account
) return;
1882 for (list
= folder_list
; list
!= NULL
; list
= list
->next
) {
1883 folder
= list
->data
;
1884 if (folder
->account
== account
)
1885 folder
->account
= NULL
;
1886 g_node_traverse(folder
->node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, -1,
1887 folder_unref_account_func
, account
);
1891 #undef CREATE_FOLDER_IF_NOT_EXIST
1893 gchar
*folder_item_get_path(FolderItem
*item
)
1897 cm_return_val_if_fail(item
!= NULL
, NULL
);
1898 folder
= item
->folder
;
1899 cm_return_val_if_fail(folder
!= NULL
, NULL
);
1901 return folder
->klass
->item_get_path(folder
, item
);
1904 static gint
folder_sort_cache_list_by_msgnum(gconstpointer a
, gconstpointer b
)
1906 MsgInfo
*msginfo_a
= (MsgInfo
*) a
;
1907 MsgInfo
*msginfo_b
= (MsgInfo
*) b
;
1909 return (msginfo_a
->msgnum
- msginfo_b
->msgnum
);
1912 static gint
folder_sort_folder_list(gconstpointer a
, gconstpointer b
)
1914 guint gint_a
= GPOINTER_TO_INT(a
);
1915 guint gint_b
= GPOINTER_TO_INT(b
);
1917 return (gint_a
- gint_b
);
1920 static gint
syncronize_flags(FolderItem
*item
, MsgInfoList
*msglist
)
1922 GHashTable
*relation
;
1928 if(item
->folder
->klass
->get_flags
== NULL
)
1930 if (item
->no_select
)
1933 relation
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
1934 if ((ret
= item
->folder
->klass
->get_flags(
1935 item
->folder
, item
, msglist
, relation
)) == 0) {
1936 gpointer data
, old_key
;
1938 MsgPermFlags permflags
= 0;
1940 folder_item_update_freeze();
1941 folder_item_set_batch(item
, TRUE
);
1942 for (cur
= msglist
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
1943 msginfo
= (MsgInfo
*) cur
->data
;
1945 if (g_hash_table_lookup_extended(relation
, msginfo
, &old_key
, &data
)) {
1946 permflags
= GPOINTER_TO_INT(data
);
1948 if (msginfo
->flags
.perm_flags
!= permflags
) {
1949 procmsg_msginfo_change_flags(msginfo
,
1950 permflags
& ~msginfo
->flags
.perm_flags
, 0,
1951 ~permflags
& msginfo
->flags
.perm_flags
, 0);
1955 folder_item_set_batch(item
, FALSE
);
1956 folder_item_update_thaw();
1958 g_hash_table_destroy(relation
);
1963 static gint
folder_item_syncronize_flags(FolderItem
*item
)
1965 MsgInfoList
*msglist
= NULL
;
1969 cm_return_val_if_fail(item
!= NULL
, -1);
1970 cm_return_val_if_fail(item
->folder
!= NULL
, -1);
1971 cm_return_val_if_fail(item
->folder
->klass
!= NULL
, -1);
1972 if (item
->no_select
)
1975 item
->scanning
= ITEM_SCANNING_WITH_FLAGS
;
1977 if (item
->cache
== NULL
)
1978 folder_item_read_cache(item
);
1980 msglist
= msgcache_get_msg_list(item
->cache
);
1982 ret
= syncronize_flags(item
, msglist
);
1984 for (cur
= msglist
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
1985 procmsg_msginfo_free((MsgInfo
**)&(cur
->data
));
1988 g_slist_free(msglist
);
1990 item
->scanning
= ITEM_NOT_SCANNING
;
1995 static void folder_item_process_open (FolderItem
*item
,
1996 void (*before_proc_func
)(gpointer data
),
1997 void (*after_proc_func
)(gpointer data
),
2003 if((item
->folder
->klass
->scan_required
!= NULL
) &&
2004 (item
->folder
->klass
->scan_required(item
->folder
, item
))) {
2005 folder_item_scan_full(item
, TRUE
);
2007 folder_item_syncronize_flags(item
);
2011 if (item
->prefs
->enable_processing_when_opening
) {
2012 buf
= g_strdup_printf(_("Processing (%s)...\n"),
2013 item
->path
? item
->path
: item
->name
);
2016 if (before_proc_func
)
2017 before_proc_func(data
);
2019 folder_item_apply_processing(item
);
2021 if (after_proc_func
)
2022 after_proc_func(data
);
2024 item
->processing_pending
= FALSE
;
2028 gint
folder_item_open(FolderItem
*item
)
2031 if (item
->no_select
)
2034 if (item
->scanning
!= ITEM_NOT_SCANNING
) {
2035 debug_print("%s is scanning... \n", item
->path
? item
->path
: item
->name
);
2039 item
->processing_pending
= TRUE
;
2040 folder_item_process_open (item
, NULL
, NULL
, NULL
);
2042 item
->opened
= TRUE
;
2047 gint
folder_item_close(FolderItem
*item
)
2049 GSList
*mlist
, *cur
;
2052 cm_return_val_if_fail(item
!= NULL
, -1);
2054 if (item
->no_select
)
2057 if (item
->new_msgs
) {
2058 folder_item_update_freeze();
2059 mlist
= folder_item_get_msg_list(item
);
2060 for (cur
= mlist
; cur
!= NULL
; cur
= cur
->next
) {
2063 msginfo
= (MsgInfo
*) cur
->data
;
2064 if (MSG_IS_NEW(msginfo
->flags
))
2065 procmsg_msginfo_unset_flags(msginfo
, MSG_NEW
, 0);
2066 procmsg_msginfo_free(&msginfo
);
2068 g_slist_free(mlist
);
2069 folder_item_update_thaw();
2072 folder_item_write_cache(item
);
2074 folder_item_update(item
, F_ITEM_UPDATE_MSGCNT
);
2076 item
->opened
= FALSE
;
2077 folder
= item
->folder
;
2079 if (folder
->klass
->close
== NULL
)
2082 return folder
->klass
->close(folder
, item
);
2085 static MsgInfoList
*get_msginfos(FolderItem
*item
, MsgNumberList
*numlist
)
2087 MsgInfoList
*msglist
= NULL
;
2088 Folder
*folder
= item
->folder
;
2089 if (item
->no_select
)
2092 if (folder
->klass
->get_msginfos
!= NULL
)
2093 msglist
= folder
->klass
->get_msginfos(folder
, item
, numlist
);
2095 MsgNumberList
*elem
;
2097 for (elem
= numlist
; elem
!= NULL
; elem
= g_slist_next(elem
)) {
2101 num
= GPOINTER_TO_INT(elem
->data
);
2102 msginfo
= folder
->klass
->get_msginfo(folder
, item
, num
);
2103 if (msginfo
!= NULL
)
2104 msglist
= g_slist_prepend(msglist
, msginfo
);
2111 static MsgInfo
*get_msginfo(FolderItem
*item
, guint num
)
2113 MsgNumberList numlist
;
2114 MsgInfoList
*msglist
;
2115 MsgInfo
*msginfo
= NULL
;
2117 numlist
.data
= GINT_TO_POINTER(num
);
2118 numlist
.next
= NULL
;
2119 msglist
= get_msginfos(item
, &numlist
);
2120 if (msglist
!= NULL
)
2121 msginfo
= procmsg_msginfo_new_ref(msglist
->data
);
2122 procmsg_msg_list_free(msglist
);
2127 gint
folder_item_scan_full(FolderItem
*item
, gboolean filtering
)
2130 GSList
*folder_list
= NULL
, *cache_list
= NULL
;
2131 GSList
*folder_list_cur
, *cache_list_cur
, *new_list
= NULL
;
2132 GSList
*exists_list
= NULL
, *elem
;
2133 GSList
*newmsg_list
= NULL
;
2134 guint newcnt
= 0, unreadcnt
= 0, totalcnt
= 0;
2135 guint markedcnt
= 0, unreadmarkedcnt
= 0;
2136 guint repliedcnt
= 0, forwardedcnt
= 0;
2137 guint lockedcnt
= 0, ignoredcnt
= 0, watchedcnt
= 0;
2139 guint cache_max_num
, folder_max_num
, cache_cur_num
, folder_cur_num
;
2140 gboolean update_flags
= 0, old_uids_valid
= FALSE
;
2141 GHashTable
*subject_table
= NULL
;
2143 cm_return_val_if_fail(item
!= NULL
, -1);
2144 if (item
->path
== NULL
) return -1;
2146 folder
= item
->folder
;
2148 cm_return_val_if_fail(folder
!= NULL
, -1);
2149 cm_return_val_if_fail(folder
->klass
->get_num_list
!= NULL
, -1);
2151 item
->scanning
= ITEM_SCANNING_WITH_FLAGS
;
2153 debug_print("Scanning folder %s for cache changes.\n", item
->path
? item
->path
: "(null)");
2155 /* Get list of messages for folder and cache */
2156 if (folder
->klass
->get_num_list(item
->folder
, item
, &folder_list
, &old_uids_valid
) < 0) {
2157 debug_print("Error fetching list of message numbers\n");
2158 item
->scanning
= ITEM_NOT_SCANNING
;
2162 if(prefs_common
.thread_by_subject
) {
2163 subject_table
= g_hash_table_new(g_str_hash
, g_str_equal
);
2166 if (old_uids_valid
) {
2168 folder_item_read_cache(item
);
2169 cache_list
= msgcache_get_msg_list(item
->cache
);
2172 msgcache_destroy(item
->cache
);
2173 item
->cache
= msgcache_new();
2174 item
->cache_dirty
= TRUE
;
2175 item
->mark_dirty
= TRUE
;
2176 item
->tags_dirty
= TRUE
;
2180 /* Sort both lists */
2181 cache_list
= g_slist_sort(cache_list
, folder_sort_cache_list_by_msgnum
);
2182 folder_list
= g_slist_sort(folder_list
, folder_sort_folder_list
);
2184 cache_list_cur
= cache_list
;
2185 folder_list_cur
= folder_list
;
2187 if (cache_list_cur
!= NULL
) {
2188 GSList
*cache_list_last
;
2190 cache_cur_num
= ((MsgInfo
*)cache_list_cur
->data
)->msgnum
;
2191 cache_list_last
= g_slist_last(cache_list
);
2192 cache_max_num
= ((MsgInfo
*)cache_list_last
->data
)->msgnum
;
2194 cache_cur_num
= G_MAXINT
;
2198 if (folder_list_cur
!= NULL
) {
2199 GSList
*folder_list_last
;
2201 folder_cur_num
= GPOINTER_TO_INT(folder_list_cur
->data
);
2202 folder_list_last
= g_slist_last(folder_list
);
2203 folder_max_num
= GPOINTER_TO_INT(folder_list_last
->data
);
2205 folder_cur_num
= G_MAXINT
;
2209 while ((cache_cur_num
!= G_MAXINT
) || (folder_cur_num
!= G_MAXINT
)) {
2211 * Message only exists in the folder
2212 * Remember message for fetching
2214 if (folder_cur_num
< cache_cur_num
) {
2215 gboolean add
= FALSE
;
2217 switch(FOLDER_TYPE(folder
)) {
2219 if (folder_cur_num
< cache_max_num
)
2222 if (folder
->account
->max_articles
== 0) {
2226 if (folder_max_num
<= folder
->account
->max_articles
) {
2228 } else if (folder_cur_num
> (folder_max_num
- folder
->account
->max_articles
)) {
2238 new_list
= g_slist_prepend(new_list
, GINT_TO_POINTER(folder_cur_num
));
2239 debug_print("Remembered message %d for fetching\n", folder_cur_num
);
2242 /* Move to next folder number */
2243 if (folder_list_cur
)
2244 folder_list_cur
= folder_list_cur
->next
;
2246 if (folder_list_cur
!= NULL
)
2247 folder_cur_num
= GPOINTER_TO_INT(folder_list_cur
->data
);
2249 folder_cur_num
= G_MAXINT
;
2255 * Message only exists in the cache
2256 * Remove the message from the cache
2258 if (cache_cur_num
< folder_cur_num
) {
2259 msgcache_remove_msg(item
->cache
, cache_cur_num
);
2260 debug_print("Removed message %d from cache.\n", cache_cur_num
);
2262 /* Move to next cache number */
2264 cache_list_cur
= cache_list_cur
->next
;
2266 if (cache_list_cur
!= NULL
)
2267 cache_cur_num
= ((MsgInfo
*)cache_list_cur
->data
)->msgnum
;
2269 cache_cur_num
= G_MAXINT
;
2271 update_flags
|= F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
;
2277 * Message number exists in folder and cache!
2278 * Check if the message has been modified
2280 if (cache_cur_num
== folder_cur_num
) {
2283 msginfo
= msgcache_get_msg(item
->cache
, folder_cur_num
);
2284 if (msginfo
&& folder
->klass
->is_msg_changed
&& folder
->klass
->is_msg_changed(folder
, item
, msginfo
)) {
2285 msgcache_remove_msg(item
->cache
, msginfo
->msgnum
);
2286 new_list
= g_slist_prepend(new_list
, GINT_TO_POINTER(msginfo
->msgnum
));
2287 procmsg_msginfo_free(&msginfo
);
2289 debug_print("Remembering message %d to update...\n", folder_cur_num
);
2290 } else if (msginfo
) {
2291 exists_list
= g_slist_prepend(exists_list
, msginfo
);
2293 if(prefs_common
.thread_by_subject
&&
2294 MSG_IS_IGNORE_THREAD(msginfo
->flags
) &&
2295 !subject_table_lookup(subject_table
, msginfo
->subject
)) {
2296 subject_table_insert(subject_table
, msginfo
->subject
, msginfo
);
2300 /* Move to next folder and cache number */
2302 cache_list_cur
= cache_list_cur
->next
;
2304 if (folder_list_cur
)
2305 folder_list_cur
= folder_list_cur
->next
;
2307 if (cache_list_cur
!= NULL
)
2308 cache_cur_num
= ((MsgInfo
*)cache_list_cur
->data
)->msgnum
;
2310 cache_cur_num
= G_MAXINT
;
2312 if (folder_list_cur
!= NULL
)
2313 folder_cur_num
= GPOINTER_TO_INT(folder_list_cur
->data
);
2315 folder_cur_num
= G_MAXINT
;
2321 for(cache_list_cur
= cache_list
; cache_list_cur
!= NULL
; cache_list_cur
= g_slist_next(cache_list_cur
))
2322 procmsg_msginfo_free((MsgInfo
**)&(cache_list_cur
->data
));
2324 g_slist_free(cache_list
);
2325 g_slist_free(folder_list
);
2327 if (new_list
!= NULL
) {
2328 GSList
*tmp_list
= NULL
;
2329 newmsg_list
= get_msginfos(item
, new_list
);
2330 g_slist_free(new_list
);
2331 tmp_list
= g_slist_concat(g_slist_copy(exists_list
), g_slist_copy(newmsg_list
));
2332 syncronize_flags(item
, tmp_list
);
2333 g_slist_free(tmp_list
);
2335 syncronize_flags(item
, exists_list
);
2338 folder_item_update_freeze();
2340 item
->scanning
= ITEM_SCANNING
;
2342 if (newmsg_list
!= NULL
) {
2343 GSList
*elem
, *to_filter
= NULL
;
2344 gboolean do_filter
= (filtering
== TRUE
) &&
2345 (item
->stype
== F_INBOX
) &&
2346 (item
->folder
->account
!= NULL
) &&
2347 (item
->folder
->account
->filter_on_recv
);
2349 for (elem
= newmsg_list
; elem
!= NULL
; elem
= g_slist_next(elem
)) {
2350 MsgInfo
*msginfo
= (MsgInfo
*) elem
->data
;
2352 msgcache_add_msg(item
->cache
, msginfo
);
2354 exists_list
= g_slist_prepend(exists_list
, msginfo
);
2356 if(prefs_common
.thread_by_subject
&&
2357 MSG_IS_IGNORE_THREAD(msginfo
->flags
) &&
2358 !subject_table_lookup(subject_table
, msginfo
->subject
)) {
2359 subject_table_insert(subject_table
, msginfo
->subject
, msginfo
);
2367 folder_item_set_batch(item
, TRUE
);
2368 procmsg_msglist_filter(newmsg_list
, item
->folder
->account
,
2369 &to_filter
, &unfiltered
,
2371 folder_item_set_batch(item
, FALSE
);
2373 filtering_move_and_copy_msgs(newmsg_list
);
2374 if (to_filter
!= NULL
) {
2375 for (elem
= to_filter
; elem
; elem
= g_slist_next(elem
)) {
2376 MsgInfo
*msginfo
= (MsgInfo
*)elem
->data
;
2377 procmsg_msginfo_free(&msginfo
);
2379 g_slist_free(to_filter
);
2381 if (unfiltered
!= NULL
) {
2382 for (elem
= unfiltered
; elem
; elem
= g_slist_next(elem
)) {
2383 MsgInfo
*msginfo
= (MsgInfo
*)elem
->data
;
2384 exists_list
= g_slist_prepend(exists_list
, msginfo
);
2386 if(prefs_common
.thread_by_subject
&&
2387 MSG_IS_IGNORE_THREAD(msginfo
->flags
) &&
2388 !subject_table_lookup(subject_table
, msginfo
->subject
)) {
2389 subject_table_insert(subject_table
, msginfo
->subject
, msginfo
);
2392 g_slist_free(unfiltered
);
2394 if (prefs_common
.real_time_sync
)
2395 folder_item_synchronise(item
);
2397 if (prefs_common
.real_time_sync
)
2398 folder_item_synchronise(item
);
2401 g_slist_free(newmsg_list
);
2403 update_flags
|= F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
;
2406 folder_item_set_batch(item
, TRUE
);
2407 for (elem
= exists_list
; elem
!= NULL
; elem
= g_slist_next(elem
)) {
2408 MsgInfo
*msginfo
, *parent_msginfo
;
2410 msginfo
= elem
->data
;
2411 if (MSG_IS_IGNORE_THREAD(msginfo
->flags
) && (MSG_IS_NEW(msginfo
->flags
) || MSG_IS_UNREAD(msginfo
->flags
)))
2412 procmsg_msginfo_unset_flags(msginfo
, MSG_NEW
| MSG_UNREAD
, 0);
2413 if (!MSG_IS_IGNORE_THREAD(msginfo
->flags
) && procmsg_msg_has_flagged_parent(msginfo
, MSG_IGNORE_THREAD
)) {
2414 procmsg_msginfo_change_flags(msginfo
, MSG_IGNORE_THREAD
, 0, MSG_NEW
| MSG_UNREAD
, 0);
2416 if (!MSG_IS_WATCH_THREAD(msginfo
->flags
) && procmsg_msg_has_flagged_parent(msginfo
, MSG_WATCH_THREAD
)) {
2417 procmsg_msginfo_set_flags(msginfo
, MSG_WATCH_THREAD
, 0);
2419 if(prefs_common
.thread_by_subject
&& !msginfo
->inreplyto
&&
2420 !msginfo
->references
&& !MSG_IS_IGNORE_THREAD(msginfo
->flags
) &&
2421 (parent_msginfo
= subject_table_lookup(subject_table
, msginfo
->subject
)))
2423 if(MSG_IS_IGNORE_THREAD(parent_msginfo
->flags
)) {
2424 procmsg_msginfo_change_flags(msginfo
, MSG_IGNORE_THREAD
, 0,
2425 MSG_NEW
| MSG_UNREAD
, 0);
2428 if ((folder_has_parent_of_type(item
, F_OUTBOX
) ||
2429 folder_has_parent_of_type(item
, F_QUEUE
) ||
2430 folder_has_parent_of_type(item
, F_TRASH
)) &&
2431 (MSG_IS_NEW(msginfo
->flags
) || MSG_IS_UNREAD(msginfo
->flags
)))
2432 procmsg_msginfo_unset_flags(msginfo
, MSG_NEW
| MSG_UNREAD
, 0);
2433 if (MSG_IS_NEW(msginfo
->flags
))
2435 if (MSG_IS_UNREAD(msginfo
->flags
))
2437 if (MSG_IS_UNREAD(msginfo
->flags
) && procmsg_msg_has_marked_parent(msginfo
))
2439 if (MSG_IS_MARKED(msginfo
->flags
))
2441 if (MSG_IS_REPLIED(msginfo
->flags
))
2443 if (MSG_IS_FORWARDED(msginfo
->flags
))
2445 if (MSG_IS_LOCKED(msginfo
->flags
))
2447 if (MSG_IS_IGNORE_THREAD(msginfo
->flags
))
2449 if (MSG_IS_WATCH_THREAD(msginfo
->flags
))
2454 procmsg_msginfo_free(&msginfo
);
2456 folder_item_set_batch(item
, FALSE
);
2457 g_slist_free(exists_list
);
2459 if(prefs_common
.thread_by_subject
) {
2460 g_hash_table_destroy(subject_table
);
2463 if (item
->new_msgs
!= newcnt
|| item
->unread_msgs
!= unreadcnt
2464 || item
->total_msgs
!= totalcnt
|| item
->marked_msgs
!= markedcnt
2465 || item
->unreadmarked_msgs
!= unreadmarkedcnt
2466 || item
->replied_msgs
!= repliedcnt
|| item
->forwarded_msgs
!= forwardedcnt
2467 || item
->locked_msgs
!= lockedcnt
|| item
->ignored_msgs
!= ignoredcnt
2468 || item
->watched_msgs
!= watchedcnt
) {
2469 update_flags
|= F_ITEM_UPDATE_CONTENT
;
2472 item
->new_msgs
= newcnt
;
2473 item
->unread_msgs
= unreadcnt
;
2474 item
->total_msgs
= totalcnt
;
2475 item
->unreadmarked_msgs
= unreadmarkedcnt
;
2476 item
->marked_msgs
= markedcnt
;
2477 item
->replied_msgs
= repliedcnt
;
2478 item
->forwarded_msgs
= forwardedcnt
;
2479 item
->locked_msgs
= lockedcnt
;
2480 item
->ignored_msgs
= ignoredcnt
;
2481 item
->watched_msgs
= watchedcnt
;
2483 update_flags
|= F_ITEM_UPDATE_MSGCNT
;
2485 folder_item_update(item
, update_flags
);
2486 folder_item_update_thaw();
2488 item
->scanning
= ITEM_NOT_SCANNING
;
2493 gint
folder_item_scan(FolderItem
*item
)
2495 return folder_item_scan_full(item
, TRUE
);
2498 static void folder_count_total_cache_memusage(FolderItem
*item
, gpointer data
)
2500 gint
*memusage
= (gint
*)data
;
2502 if (item
->cache
== NULL
)
2505 *memusage
+= msgcache_get_memory_usage(item
->cache
);
2508 static gint
folder_cache_time_compare_func(gconstpointer a
, gconstpointer b
)
2510 FolderItem
*fa
= (FolderItem
*)a
;
2511 FolderItem
*fb
= (FolderItem
*)b
;
2513 return (gint
) (msgcache_get_last_access_time(fa
->cache
) - msgcache_get_last_access_time(fb
->cache
));
2516 static void folder_find_expired_caches(FolderItem
*item
, gpointer data
)
2518 GSList
**folder_item_list
= (GSList
**)data
;
2519 gint difftime
, expiretime
;
2521 if (item
->cache
== NULL
)
2524 if (item
->opened
> 0)
2527 difftime
= (gint
) (time(NULL
) - msgcache_get_last_access_time(item
->cache
));
2528 expiretime
= prefs_common
.cache_min_keep_time
* 60;
2529 debug_print("Cache unused time: %d (Expire time: %d)\n", difftime
, expiretime
);
2531 if (difftime
> expiretime
&& !item
->opened
&& !item
->processing_pending
) {
2532 *folder_item_list
= g_slist_insert_sorted(*folder_item_list
, item
, folder_cache_time_compare_func
);
2536 gboolean
folder_item_free_cache(FolderItem
*item
, gboolean force
)
2538 cm_return_val_if_fail(item
!= NULL
, TRUE
);
2540 if (item
->cache
== NULL
)
2543 if (item
->opened
> 0 && !force
)
2546 folder_item_write_cache(item
);
2547 msgcache_destroy(item
->cache
);
2552 void folder_clean_cache_memory_force(void)
2554 int old_cache_max_mem_usage
= prefs_common
.cache_max_mem_usage
;
2555 int old_cache_min_keep_time
= prefs_common
.cache_min_keep_time
;
2557 prefs_common
.cache_max_mem_usage
= 0;
2558 prefs_common
.cache_min_keep_time
= 0;
2560 folder_clean_cache_memory(NULL
);
2562 prefs_common
.cache_max_mem_usage
= old_cache_max_mem_usage
;
2563 prefs_common
.cache_min_keep_time
= old_cache_min_keep_time
;
2566 void folder_clean_cache_memory(FolderItem
*protected_item
)
2570 folder_func_to_all_folders(folder_count_total_cache_memusage
, &memusage
);
2571 debug_print("Total cache memory usage: %d\n", memusage
);
2573 if (memusage
> (prefs_common
.cache_max_mem_usage
* 1024)) {
2574 GSList
*folder_item_list
= NULL
, *listitem
;
2576 debug_print("Trying to free cache memory\n");
2578 folder_func_to_all_folders(folder_find_expired_caches
, &folder_item_list
);
2579 listitem
= folder_item_list
;
2580 while((listitem
!= NULL
) && (memusage
> (prefs_common
.cache_max_mem_usage
* 1024))) {
2581 FolderItem
*item
= (FolderItem
*)(listitem
->data
);
2582 gint cache_size
= 0;
2583 if (item
== protected_item
) {
2584 listitem
= listitem
->next
;
2587 debug_print("Freeing cache memory for %s\n", item
->path
? item
->path
: item
->name
);
2588 cache_size
= msgcache_get_memory_usage(item
->cache
);
2589 if (folder_item_free_cache(item
, FALSE
))
2590 memusage
-= cache_size
;
2592 listitem
= listitem
->next
;
2594 g_slist_free(folder_item_list
);
2598 static void folder_item_remove_cached_msg(FolderItem
*item
, MsgInfo
*msginfo
)
2600 Folder
*folder
= item
->folder
;
2602 cm_return_if_fail(folder
!= NULL
);
2604 if (folder
->klass
->remove_cached_msg
== NULL
)
2607 folder
->klass
->remove_cached_msg(folder
, item
, msginfo
);
2610 static void folder_item_clean_local_files(FolderItem
*item
, gint days
)
2612 cm_return_if_fail(item
!= NULL
);
2613 cm_return_if_fail(item
->folder
!= NULL
);
2615 if (FOLDER_TYPE(item
->folder
) == F_IMAP
||
2616 FOLDER_TYPE(item
->folder
) == F_NEWS
) {
2617 GSList
*msglist
= folder_item_get_msg_list(item
);
2619 time_t t
= time(NULL
);
2620 for (cur
= msglist
; cur
; cur
= cur
->next
) {
2621 MsgInfo
*msginfo
= (MsgInfo
*)cur
->data
;
2622 gint age
= (t
- msginfo
->date_t
) / (60*60*24);
2624 folder_item_remove_cached_msg(item
, msginfo
);
2626 procmsg_msg_list_free(msglist
);
2630 static void folder_item_read_cache(FolderItem
*item
)
2632 gchar
*cache_file
, *mark_file
, *tags_file
;
2634 cm_return_if_fail(item
!= NULL
);
2636 if (item
->path
!= NULL
) {
2637 cache_file
= folder_item_get_cache_file(item
);
2638 mark_file
= folder_item_get_mark_file(item
);
2639 tags_file
= folder_item_get_tags_file(item
);
2640 item
->cache
= msgcache_read_cache(item
, cache_file
);
2641 item
->cache_dirty
= FALSE
;
2642 item
->mark_dirty
= FALSE
;
2643 item
->tags_dirty
= FALSE
;
2645 MsgInfoList
*list
, *cur
;
2646 guint newcnt
= 0, unreadcnt
= 0;
2647 guint markedcnt
= 0, unreadmarkedcnt
= 0;
2648 guint repliedcnt
= 0, forwardedcnt
= 0;
2649 guint lockedcnt
= 0, ignoredcnt
= 0;
2650 guint watchedcnt
= 0;
2653 item
->cache
= msgcache_new();
2654 item
->cache_dirty
= TRUE
;
2655 item
->mark_dirty
= TRUE
;
2656 item
->tags_dirty
= TRUE
;
2657 folder_item_scan_full(item
, TRUE
);
2659 msgcache_read_mark(item
->cache
, mark_file
);
2661 list
= msgcache_get_msg_list(item
->cache
);
2662 for (cur
= list
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
2663 msginfo
= cur
->data
;
2665 if (MSG_IS_NEW(msginfo
->flags
))
2667 if (MSG_IS_UNREAD(msginfo
->flags
))
2669 if (MSG_IS_UNREAD(msginfo
->flags
) && procmsg_msg_has_marked_parent(msginfo
))
2671 if (MSG_IS_MARKED(msginfo
->flags
))
2673 if (MSG_IS_REPLIED(msginfo
->flags
))
2675 if (MSG_IS_FORWARDED(msginfo
->flags
))
2677 if (MSG_IS_LOCKED(msginfo
->flags
))
2679 if (MSG_IS_IGNORE_THREAD(msginfo
->flags
))
2681 if (MSG_IS_WATCH_THREAD(msginfo
->flags
))
2683 procmsg_msginfo_unset_flags(msginfo
, MSG_FULLY_CACHED
, 0);
2685 item
->new_msgs
= newcnt
;
2686 item
->unread_msgs
= unreadcnt
;
2687 item
->unreadmarked_msgs
= unreadmarkedcnt
;
2688 item
->marked_msgs
= markedcnt
;
2689 item
->replied_msgs
= repliedcnt
;
2690 item
->forwarded_msgs
= forwardedcnt
;
2691 item
->locked_msgs
= lockedcnt
;
2692 item
->ignored_msgs
= ignoredcnt
;
2693 item
->watched_msgs
= watchedcnt
;
2694 procmsg_msg_list_free(list
);
2696 msgcache_read_mark(item
->cache
, mark_file
);
2698 msgcache_read_tags(item
->cache
, tags_file
);
2704 item
->cache
= msgcache_new();
2705 item
->cache_dirty
= TRUE
;
2706 item
->mark_dirty
= TRUE
;
2707 item
->tags_dirty
= TRUE
;
2711 folder_clean_cache_memory(item
);
2714 void folder_item_write_cache(FolderItem
*item
)
2716 gchar
*cache_file
= NULL
, *mark_file
= NULL
, *tags_file
= NULL
;
2717 FolderItemPrefs
*prefs
;
2720 time_t last_mtime
= (time_t)0;
2721 gboolean need_scan
= FALSE
;
2723 if (!item
|| !item
->path
|| !item
->cache
)
2726 last_mtime
= item
->mtime
;
2727 if (item
->folder
->klass
->set_mtime
) {
2728 if (item
->folder
->klass
->scan_required
)
2729 need_scan
= item
->folder
->klass
->scan_required(item
->folder
, item
);
2734 id
= folder_item_get_identifier(item
);
2735 debug_print("Save cache for folder %s\n", id
);
2738 if (item
->cache_dirty
)
2739 cache_file
= folder_item_get_cache_file(item
);
2740 if (item
->cache_dirty
|| item
->mark_dirty
)
2741 mark_file
= folder_item_get_mark_file(item
);
2742 if (item
->cache_dirty
|| item
->tags_dirty
)
2743 tags_file
= folder_item_get_tags_file(item
);
2744 if (msgcache_write(cache_file
, mark_file
, tags_file
, item
->cache
) < 0) {
2745 prefs
= item
->prefs
;
2746 if (prefs
&& prefs
->enable_folder_chmod
&& prefs
->folder_chmod
) {
2747 /* for cache file */
2748 filemode
= prefs
->folder_chmod
;
2749 if (filemode
& S_IRGRP
) filemode
|= S_IWGRP
;
2750 if (filemode
& S_IROTH
) filemode
|= S_IWOTH
;
2751 if (cache_file
!= NULL
)
2752 chmod(cache_file
, filemode
);
2755 item
->cache_dirty
= FALSE
;
2756 item
->mark_dirty
= FALSE
;
2757 item
->tags_dirty
= FALSE
;
2760 if (!need_scan
&& item
->folder
->klass
->set_mtime
) {
2761 if (item
->mtime
== last_mtime
) {
2762 item
->folder
->klass
->set_mtime(item
->folder
, item
);
2771 MsgInfo
*folder_item_get_msginfo(FolderItem
*item
, gint num
)
2773 MsgInfo
*msginfo
= NULL
;
2775 cm_return_val_if_fail(item
!= NULL
, NULL
);
2776 if (item
->no_select
)
2779 folder_item_read_cache(item
);
2781 if ((msginfo
= msgcache_get_msg(item
->cache
, num
)) != NULL
)
2784 msginfo
= get_msginfo(item
, num
);
2785 if (msginfo
!= NULL
) {
2786 msgcache_add_msg(item
->cache
, msginfo
);
2793 MsgInfo
*folder_item_get_msginfo_by_msgid(FolderItem
*item
, const gchar
*msgid
)
2797 cm_return_val_if_fail(item
!= NULL
, NULL
);
2798 cm_return_val_if_fail(msgid
!= NULL
, NULL
);
2799 if (item
->no_select
)
2803 folder_item_read_cache(item
);
2805 if ((msginfo
= msgcache_get_msg_by_id(item
->cache
, msgid
)) != NULL
)
2811 GSList
*folder_item_get_msg_list(FolderItem
*item
)
2813 cm_return_val_if_fail(item
!= NULL
, NULL
);
2814 if (item
->no_select
)
2817 if (item
->cache
== 0)
2818 folder_item_read_cache(item
);
2820 cm_return_val_if_fail(item
->cache
!= NULL
, NULL
);
2822 return msgcache_get_msg_list(item
->cache
);
2825 static void msginfo_set_mime_flags(GNode
*node
, gpointer data
)
2827 MsgInfo
*msginfo
= data
;
2828 MimeInfo
*mimeinfo
= node
->data
;
2830 if (mimeinfo
->disposition
== DISPOSITIONTYPE_ATTACHMENT
2831 && (!mimeinfo
->subtype
|| (strcmp(mimeinfo
->subtype
, "pgp-signature") &&
2832 strcmp(mimeinfo
->subtype
, "x-pkcs7-signature") &&
2833 strcmp(mimeinfo
->subtype
, "pkcs7-signature")))) {
2834 procmsg_msginfo_set_flags(msginfo
, 0, MSG_HAS_ATTACHMENT
);
2835 } else if (mimeinfo
->disposition
== DISPOSITIONTYPE_UNKNOWN
&&
2836 mimeinfo
->id
== NULL
&&
2837 mimeinfo
->type
!= MIMETYPE_TEXT
&&
2838 mimeinfo
->type
!= MIMETYPE_MULTIPART
) {
2839 if (!mimeinfo
->subtype
2840 || (strcmp(mimeinfo
->subtype
, "pgp-signature") &&
2841 strcmp(mimeinfo
->subtype
, "x-pkcs7-signature") &&
2842 strcmp(mimeinfo
->subtype
, "pkcs7-signature")))
2843 procmsg_msginfo_set_flags(msginfo
, 0, MSG_HAS_ATTACHMENT
);
2844 } else if (mimeinfo
->disposition
== DISPOSITIONTYPE_INLINE
&&
2845 mimeinfo
->id
== NULL
&&
2846 (strcmp(mimeinfo
->subtype
, "pgp-signature") &&
2847 strcmp(mimeinfo
->subtype
, "x-pkcs7-signature") &&
2848 strcmp(mimeinfo
->subtype
, "pkcs7-signature")) &&
2849 (procmime_mimeinfo_get_parameter(mimeinfo
, "name") != NULL
||
2850 procmime_mimeinfo_get_parameter(mimeinfo
, "filename") != NULL
)) {
2851 procmsg_msginfo_set_flags(msginfo
, 0, MSG_HAS_ATTACHMENT
);
2854 /* don't descend below top level message for signed and encrypted info */
2855 if (mimeinfo
->type
== MIMETYPE_MESSAGE
)
2858 if (privacy_mimeinfo_is_signed(mimeinfo
)) {
2859 procmsg_msginfo_set_flags(msginfo
, 0, MSG_SIGNED
);
2862 if (privacy_mimeinfo_is_encrypted(mimeinfo
)) {
2863 procmsg_msginfo_set_flags(msginfo
, 0, MSG_ENCRYPTED
);
2865 /* searching inside encrypted parts doesn't really make sense */
2866 g_node_children_foreach(mimeinfo
->node
, G_TRAVERSE_ALL
, msginfo_set_mime_flags
, msginfo
);
2870 gchar
*folder_item_fetch_msg(FolderItem
*item
, gint num
)
2876 cm_return_val_if_fail(item
!= NULL
, NULL
);
2878 folder
= item
->folder
;
2880 cm_return_val_if_fail(folder
->klass
->fetch_msg
!= NULL
, NULL
);
2881 if (item
->no_select
)
2884 msgfile
= folder
->klass
->fetch_msg(folder
, item
, num
);
2886 if (msgfile
!= NULL
) {
2887 msginfo
= folder_item_get_msginfo(item
, num
);
2888 if ((msginfo
!= NULL
) && !MSG_IS_SCANNED(msginfo
->flags
)) {
2891 if (!folder_has_parent_of_type(msginfo
->folder
, F_QUEUE
) &&
2892 !folder_has_parent_of_type(msginfo
->folder
, F_DRAFT
))
2893 mimeinfo
= procmime_scan_file(msgfile
);
2895 mimeinfo
= procmime_scan_queue_file(msgfile
);
2896 /* check for attachments */
2897 if (mimeinfo
!= NULL
) {
2898 g_node_children_foreach(mimeinfo
->node
, G_TRAVERSE_ALL
, msginfo_set_mime_flags
, msginfo
);
2899 procmime_mimeinfo_free_all(&mimeinfo
);
2901 procmsg_msginfo_set_flags(msginfo
, 0, MSG_SCANNED
);
2904 procmsg_msginfo_free(&msginfo
);
2910 gchar
*folder_item_fetch_msg_full(FolderItem
*item
, gint num
, gboolean headers
,
2917 cm_return_val_if_fail(item
!= NULL
, NULL
);
2918 if (item
->no_select
)
2921 folder
= item
->folder
;
2923 if (folder
->klass
->fetch_msg_full
== NULL
)
2924 return folder_item_fetch_msg(item
, num
);
2926 if (item
->prefs
->offlinesync
&& prefs_common
.real_time_sync
)
2927 msgfile
= folder
->klass
->fetch_msg_full(folder
, item
, num
,
2930 msgfile
= folder
->klass
->fetch_msg_full(folder
, item
, num
,
2933 if (msgfile
!= NULL
) {
2934 msginfo
= folder_item_get_msginfo(item
, num
);
2935 if ((msginfo
!= NULL
) && !MSG_IS_SCANNED(msginfo
->flags
)) {
2938 if (!folder_has_parent_of_type(msginfo
->folder
, F_QUEUE
) &&
2939 !folder_has_parent_of_type(msginfo
->folder
, F_DRAFT
))
2940 mimeinfo
= procmime_scan_file(msgfile
);
2942 mimeinfo
= procmime_scan_queue_file(msgfile
);
2943 /* check for attachments */
2944 if (mimeinfo
!= NULL
) {
2945 g_node_children_foreach(mimeinfo
->node
, G_TRAVERSE_ALL
, msginfo_set_mime_flags
, msginfo
);
2946 procmime_mimeinfo_free_all(&mimeinfo
);
2948 procmsg_msginfo_set_flags(msginfo
, 0, MSG_SCANNED
);
2951 procmsg_msginfo_free(&msginfo
);
2958 static gint
folder_item_get_msg_num_by_file(FolderItem
*dest
, const gchar
*file
)
2960 static HeaderEntry hentry
[] = {{"Message-ID:", NULL
, TRUE
},
2961 {NULL
, NULL
, FALSE
}};
2965 gchar buf
[BUFFSIZE
];
2967 if ((fp
= g_fopen(file
, "rb")) == NULL
)
2970 if ((folder_has_parent_of_type(dest
, F_QUEUE
)) ||
2971 (folder_has_parent_of_type(dest
, F_DRAFT
)))
2972 while (fgets(buf
, sizeof(buf
), fp
) != NULL
) {
2974 if ((!strncmp(buf
, "X-Claws-End-Special-Headers: 1",
2975 strlen("X-Claws-End-Special-Headers:"))) ||
2976 (!strncmp(buf
, "X-Sylpheed-End-Special-Headers: 1",
2977 strlen("X-Sylpheed-End-Special-Headers:"))))
2980 if (buf
[0] == '\r' || buf
[0] == '\n') break;
2981 /* from other mailers */
2982 if (!strncmp(buf
, "Date: ", 6)
2983 || !strncmp(buf
, "To: ", 4)
2984 || !strncmp(buf
, "From: ", 6)
2985 || !strncmp(buf
, "Subject: ", 9)) {
2991 procheader_get_header_fields(fp
, hentry
);
2992 debug_print("looking for %s\n", hentry
[0].body
);
2993 if (hentry
[0].body
) {
2994 extract_parenthesis(hentry
[0].body
, '<', '>');
2995 remove_space(hentry
[0].body
);
2996 if ((msginfo
= msgcache_get_msg_by_id(dest
->cache
, hentry
[0].body
)) != NULL
) {
2997 msgnum
= msginfo
->msgnum
;
2998 procmsg_msginfo_free(&msginfo
);
3000 debug_print("found message as uid %d\n", msgnum
);
3004 g_free(hentry
[0].body
);
3005 hentry
[0].body
= NULL
;
3011 static void copy_msginfo_flags(MsgInfo
*source
, MsgInfo
*dest
)
3013 MsgPermFlags perm_flags
= 0;
3014 MsgTmpFlags tmp_flags
= 0;
3016 /* create new flags */
3017 if (source
!= NULL
) {
3018 /* copy original flags */
3019 perm_flags
= source
->flags
.perm_flags
;
3020 tmp_flags
= source
->flags
.tmp_flags
;
3022 perm_flags
= dest
->flags
.perm_flags
;
3023 tmp_flags
= dest
->flags
.tmp_flags
;
3026 /* remove new, unread and deleted in special folders */
3027 if (folder_has_parent_of_type(dest
->folder
, F_OUTBOX
) ||
3028 folder_has_parent_of_type(dest
->folder
, F_QUEUE
) ||
3029 folder_has_parent_of_type(dest
->folder
, F_DRAFT
) ||
3030 folder_has_parent_of_type(dest
->folder
, F_TRASH
))
3031 perm_flags
&= ~(MSG_NEW
| MSG_UNREAD
| MSG_DELETED
);
3033 /* set ignore flag of ignored parent exists */
3034 if (procmsg_msg_has_flagged_parent(dest
, MSG_IGNORE_THREAD
))
3035 perm_flags
|= MSG_IGNORE_THREAD
;
3037 /* unset FULLY_CACHED flags */
3038 perm_flags
&= ~MSG_FULLY_CACHED
;
3040 if (procmsg_msg_has_flagged_parent(dest
, MSG_WATCH_THREAD
))
3041 perm_flags
|= MSG_WATCH_THREAD
;
3043 /* Unset tmp flags that should not be copied */
3044 tmp_flags
&= ~(MSG_MOVE
| MSG_COPY
| MSG_MOVE_DONE
);
3046 /* unset flags that are set but should not */
3047 /* and set new flags */
3048 procmsg_msginfo_change_flags(dest
,
3049 ~dest
->flags
.perm_flags
& perm_flags
,
3050 ~dest
->flags
.tmp_flags
& tmp_flags
,
3051 dest
->flags
.perm_flags
& ~perm_flags
,
3052 dest
->flags
.tmp_flags
& ~tmp_flags
);
3054 if (source
&& source
->tags
) {
3055 g_slist_free(dest
->tags
);
3056 dest
->tags
= g_slist_copy(source
->tags
);
3057 folder_item_commit_tags(dest
->folder
, dest
, dest
->tags
, NULL
);
3061 static void add_msginfo_to_cache(FolderItem
*item
, MsgInfo
*newmsginfo
, MsgInfo
*flagsource
)
3063 /* update folder stats */
3064 if (MSG_IS_NEW(newmsginfo
->flags
))
3066 if (MSG_IS_UNREAD(newmsginfo
->flags
))
3067 item
->unread_msgs
++;
3068 if (MSG_IS_UNREAD(newmsginfo
->flags
) && procmsg_msg_has_marked_parent(newmsginfo
))
3069 item
->unreadmarked_msgs
++;
3070 if (MSG_IS_MARKED(newmsginfo
->flags
))
3071 item
->marked_msgs
++;
3072 if (MSG_IS_REPLIED(newmsginfo
->flags
))
3073 item
->replied_msgs
++;
3074 if (MSG_IS_FORWARDED(newmsginfo
->flags
))
3075 item
->forwarded_msgs
++;
3076 if (MSG_IS_LOCKED(newmsginfo
->flags
))
3077 item
->locked_msgs
++;
3078 if (MSG_IS_IGNORE_THREAD(newmsginfo
->flags
))
3079 item
->ignored_msgs
++;
3080 if (MSG_IS_WATCH_THREAD(newmsginfo
->flags
))
3081 item
->watched_msgs
++;
3084 folder_item_update_freeze();
3087 folder_item_read_cache(item
);
3089 msgcache_add_msg(item
->cache
, newmsginfo
);
3090 copy_msginfo_flags(flagsource
, newmsginfo
);
3091 folder_item_update_with_msg(item
, F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
| F_ITEM_UPDATE_ADDMSG
, newmsginfo
);
3092 folder_item_update_thaw();
3095 static void remove_msginfo_from_cache(FolderItem
*item
, MsgInfo
*msginfo
)
3097 MsgInfoUpdate msginfo_update
;
3100 folder_item_read_cache(item
);
3102 if (MSG_IS_NEW(msginfo
->flags
) && !MSG_IS_IGNORE_THREAD(msginfo
->flags
))
3103 msginfo
->folder
->new_msgs
--;
3104 if (MSG_IS_UNREAD(msginfo
->flags
) && !MSG_IS_IGNORE_THREAD(msginfo
->flags
))
3105 msginfo
->folder
->unread_msgs
--;
3106 if (MSG_IS_UNREAD(msginfo
->flags
) && procmsg_msg_has_marked_parent(msginfo
))
3107 msginfo
->folder
->unreadmarked_msgs
--;
3108 if (MSG_IS_MARKED(msginfo
->flags
))
3109 item
->marked_msgs
--;
3110 if (MSG_IS_REPLIED(msginfo
->flags
))
3111 item
->replied_msgs
--;
3112 if (MSG_IS_FORWARDED(msginfo
->flags
))
3113 item
->forwarded_msgs
--;
3114 if (MSG_IS_LOCKED(msginfo
->flags
))
3115 item
->locked_msgs
--;
3116 if (MSG_IS_IGNORE_THREAD(msginfo
->flags
))
3117 item
->ignored_msgs
--;
3118 if (MSG_IS_WATCH_THREAD(msginfo
->flags
))
3119 item
->watched_msgs
--;
3121 msginfo
->folder
->total_msgs
--;
3123 msginfo_update
.msginfo
= msginfo
;
3124 msginfo_update
.flags
= MSGINFO_UPDATE_DELETED
;
3125 hooks_invoke(MSGINFO_UPDATE_HOOKLIST
, &msginfo_update
);
3127 msgcache_remove_msg(item
->cache
, msginfo
->msgnum
);
3128 folder_item_update_with_msg(msginfo
->folder
, F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
| F_ITEM_UPDATE_REMOVEMSG
, msginfo
);
3131 gint
folder_item_add_msg(FolderItem
*dest
, const gchar
*file
,
3132 MsgFlags
*flags
, gboolean remove_source
)
3135 MsgFileInfo fileinfo
;
3137 cm_return_val_if_fail(dest
!= NULL
, -1);
3138 cm_return_val_if_fail(file
!= NULL
, -1);
3140 fileinfo
.msginfo
= NULL
;
3141 fileinfo
.file
= (gchar
*)file
;
3142 fileinfo
.flags
= flags
;
3143 file_list
.data
= &fileinfo
;
3144 file_list
.next
= NULL
;
3146 return folder_item_add_msgs(dest
, &file_list
, remove_source
);
3149 gint
folder_item_add_msgs(FolderItem
*dest
, GSList
*file_list
,
3150 gboolean remove_source
)
3153 gint ret
, num
, lastnum
= -1;
3155 GHashTable
*relation
;
3156 MsgFileInfo
*fileinfo
= NULL
;
3157 gboolean folderscan
= FALSE
;
3159 cm_return_val_if_fail(dest
!= NULL
, -1);
3160 cm_return_val_if_fail(file_list
!= NULL
, -1);
3161 cm_return_val_if_fail(dest
->folder
!= NULL
, -1);
3162 if (dest
->no_select
)
3165 folder
= dest
->folder
;
3167 relation
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
3169 if (folder
->klass
->add_msgs
!= NULL
) {
3170 ret
= folder
->klass
->add_msgs(folder
, dest
, file_list
, relation
);
3172 g_hash_table_destroy(relation
);
3176 for (file_cur
= file_list
; file_cur
!= NULL
; file_cur
= g_slist_next(file_cur
)) {
3177 fileinfo
= (MsgFileInfo
*) file_cur
->data
;
3179 ret
= folder
->klass
->add_msg(folder
, dest
, fileinfo
->file
, fileinfo
->flags
);
3181 g_hash_table_destroy(relation
);
3184 g_hash_table_insert(relation
, fileinfo
, GINT_TO_POINTER(ret
));
3188 for (file_cur
= file_list
; file_cur
!= NULL
; file_cur
= g_slist_next(file_cur
)) {
3189 gpointer data
, old_key
;
3191 fileinfo
= (MsgFileInfo
*) file_cur
->data
;
3192 if (g_hash_table_lookup_extended(relation
, fileinfo
, &old_key
, &data
))
3193 num
= GPOINTER_TO_INT(data
);
3198 MsgInfo
*newmsginfo
;
3202 folder_item_scan_full(dest
, FALSE
);
3205 num
= folder_item_get_msg_num_by_file(dest
, fileinfo
->file
);
3206 debug_print("got num %d\n", num
);
3212 if (num
>= 0 && remove_source
) {
3213 if (claws_unlink(fileinfo
->file
) < 0)
3214 FILE_OP_ERROR(fileinfo
->file
, "unlink");
3221 ((newmsginfo
= get_msginfo(dest
, num
)) != NULL
)) {
3222 add_msginfo_to_cache(dest
, newmsginfo
, NULL
);
3223 procmsg_msginfo_free(&newmsginfo
);
3224 } else if ((newmsginfo
= msgcache_get_msg(dest
->cache
, num
)) != NULL
) {
3225 /* TODO: set default flags */
3226 procmsg_msginfo_free(&newmsginfo
);
3231 g_hash_table_destroy(relation
);
3236 static FolderItem
*folder_item_move_recursive(FolderItem
*src
, FolderItem
*dest
, gboolean copy
)
3239 FolderItem
*new_item
;
3240 FolderItem
*next_item
;
3242 gchar
*old_id
, *new_id
;
3243 FolderUpdateData hookdata
;
3246 debug_print("%s %s to %s\n", copy
?"Copying":"Moving", src
->path
, dest
->path
);
3247 new_item
= folder_create_folder(dest
, src
->name
);
3248 if (new_item
== NULL
) {
3249 g_print("Can't create folder\n");
3253 if (new_item
->folder
== NULL
)
3254 new_item
->folder
= dest
->folder
;
3257 log_message(LOG_PROTOCOL
, copy
?_("Copying %s to %s...\n"):_("Moving %s to %s...\n"),
3258 src
->name
, new_item
->path
);
3261 folder_item_prefs_copy_prefs(src
, new_item
);
3263 /* copy internal data */
3264 if (src
->folder
->klass
== new_item
->folder
->klass
&&
3265 src
->folder
->klass
->copy_private_data
!= NULL
)
3266 src
->folder
->klass
->copy_private_data(src
->folder
,
3268 new_item
->collapsed
= src
->collapsed
;
3269 new_item
->thread_collapsed
= src
->thread_collapsed
;
3270 new_item
->threaded
= src
->threaded
;
3271 new_item
->ret_rcpt
= src
->ret_rcpt
;
3272 new_item
->hide_read_msgs
= src
->hide_read_msgs
;
3273 new_item
->hide_del_msgs
= src
->hide_del_msgs
;
3274 new_item
->hide_read_threads
= src
->hide_read_threads
;
3275 new_item
->sort_key
= src
->sort_key
;
3276 new_item
->sort_type
= src
->sort_type
;
3278 mlist
= folder_item_get_msg_list(src
);
3280 if (mlist
!= NULL
) {
3282 folder_item_copy_msgs(new_item
, mlist
);
3284 folder_item_move_msgs(new_item
, mlist
);
3285 procmsg_msg_list_free(mlist
);
3288 prefs_matcher_write_config();
3291 srcnode
= src
->folder
->node
;
3292 srcnode
= g_node_find(srcnode
, G_PRE_ORDER
, G_TRAVERSE_ALL
, src
);
3293 srcnode
= srcnode
->children
;
3294 while (srcnode
!= NULL
) {
3295 if (srcnode
&& srcnode
->data
) {
3296 next_item
= (FolderItem
*) srcnode
->data
;
3297 srcnode
= srcnode
->next
;
3298 if (folder_item_move_recursive(next_item
, new_item
, copy
) == NULL
) {
3303 old_id
= folder_item_get_identifier(src
);
3304 new_id
= folder_item_get_identifier(new_item
);
3306 hookdata
.folder
= src
->folder
;
3307 hookdata
.update_flags
= FOLDER_TREE_CHANGED
| FOLDER_MOVE_FOLDERITEM
;
3308 hookdata
.item
= src
;
3309 hookdata
.item2
= new_item
;
3310 hooks_invoke(FOLDER_UPDATE_HOOKLIST
, &hookdata
);
3312 /* if src supports removing, otherwise only copy folder */
3313 if (src
->folder
->klass
->remove_folder
!= NULL
&& !copy
)
3314 src
->folder
->klass
->remove_folder(src
->folder
, src
);
3315 folder_write_list();
3318 debug_print("updating rules : %s => %s\n", old_id
, new_id
);
3319 if (old_id
!= NULL
&& new_id
!= NULL
) {
3320 prefs_filtering_rename_path(old_id
, new_id
);
3321 account_rename_path(old_id
, new_id
);
3330 gint
folder_item_move_to(FolderItem
*src
, FolderItem
*dest
, FolderItem
**new_item
, gboolean copy
)
3332 FolderItem
*tmp
= folder_item_parent(dest
);
3333 gchar
* src_identifier
, * dst_identifier
;
3334 gchar
* phys_srcpath
, * phys_dstpath
, *tmppath
;
3338 return F_MOVE_FAILED_DEST_IS_CHILD
;
3340 tmp
= folder_item_parent(tmp
);
3343 src_identifier
= folder_item_get_identifier(src
);
3344 dst_identifier
= folder_item_get_identifier(dest
);
3346 if(dst_identifier
== NULL
&& dest
->folder
&& folder_item_parent(dest
) == NULL
) {
3347 /* dest can be a root folder */
3348 dst_identifier
= folder_get_identifier(dest
->folder
);
3350 if (src_identifier
== NULL
|| dst_identifier
== NULL
) {
3351 debug_print("Can't get identifiers\n");
3352 return F_MOVE_FAILED
;
3355 if (src
->folder
!= dest
->folder
&& !copy
) {
3356 return F_MOVE_FAILED_DEST_OUTSIDE_MAILBOX
;
3359 phys_srcpath
= folder_item_get_path(src
);
3360 tmppath
= folder_item_get_path(dest
);
3361 phys_dstpath
= g_strconcat(tmppath
,
3363 g_path_get_basename(phys_srcpath
),
3367 if (folder_item_parent(src
) == dest
|| src
== dest
) {
3368 g_free(src_identifier
);
3369 g_free(dst_identifier
);
3370 g_free(phys_srcpath
);
3371 g_free(phys_dstpath
);
3372 return F_MOVE_FAILED_DEST_IS_PARENT
;
3374 debug_print("moving \"%s\" to \"%s\"\n", phys_srcpath
, phys_dstpath
);
3375 if ((tmp
= folder_item_move_recursive(src
, dest
, copy
)) == NULL
) {
3376 return F_MOVE_FAILED
;
3379 g_free(src_identifier
);
3380 g_free(dst_identifier
);
3381 g_free(phys_srcpath
);
3382 g_free(phys_dstpath
);
3393 static void find_num(gpointer key
, gpointer value
, gpointer data
)
3395 struct find_data
*fdata
= (struct find_data
*)data
;
3396 if (GPOINTER_TO_INT(value
) == 0)
3397 fdata
->found
= TRUE
;
3400 static gboolean
some_msgs_have_zero_num(GHashTable
*hashtable
)
3402 struct find_data fdata
;
3404 fdata
.found
= FALSE
;
3405 g_hash_table_foreach(hashtable
, find_num
, &fdata
);
3411 * Copy a list of message to a new folder and remove
3412 * source messages if wanted
3414 static gint
do_copy_msgs(FolderItem
*dest
, GSList
*msglist
, gboolean remove_source
)
3418 gint num
, lastnum
= -1;
3419 gboolean folderscan
= FALSE
;
3420 GHashTable
*relation
;
3421 GSList
*not_moved
= NULL
;
3422 gint total
= 0, curmsg
= 0;
3423 MsgInfo
*msginfo
= NULL
;
3425 cm_return_val_if_fail(dest
!= NULL
, -1);
3426 cm_return_val_if_fail(msglist
!= NULL
, -1);
3428 folder
= dest
->folder
;
3430 cm_return_val_if_fail(folder
->klass
->copy_msg
!= NULL
, -1);
3431 if (dest
->no_select
)
3434 msginfo
= (MsgInfo
*)msglist
->data
;
3439 if (!MSG_IS_QUEUED(msginfo
->flags
) &&
3440 MSG_IS_DRAFT(msginfo
->flags
) &&
3441 folder_has_parent_of_type(dest
, F_QUEUE
)) {
3442 GSList
*cur
= msglist
;
3443 gboolean queue_err
= FALSE
;
3444 for (; cur
; cur
= cur
->next
) {
3445 Compose
*compose
= NULL
;
3446 FolderItem
*queue
= dest
;
3449 msginfo
= (MsgInfo
*)cur
->data
;
3450 compose
= compose_reedit(msginfo
, TRUE
);
3451 if (compose
== NULL
) {
3455 val
= compose_queue(compose
, NULL
, &queue
, NULL
,
3459 } else if (remove_source
) {
3460 folder_item_remove_msg(msginfo
->folder
, msginfo
->msgnum
);
3463 compose_close(compose
);
3465 return queue_err
? -1:0;
3468 relation
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
3470 for (l
= msglist
; l
!= NULL
; l
= g_slist_next(l
)) {
3471 MsgInfo
* msginfo
= (MsgInfo
*) l
->data
;
3473 if (msginfo
->planned_download
!= 0) {
3474 int old_planned
= msginfo
->planned_download
;
3475 partial_unmark(msginfo
);
3476 /* little hack to reenable after */
3477 msginfo
->planned_download
= old_planned
;
3482 * Copy messages to destination folder and
3483 * store new message numbers in newmsgnums
3485 if (folder
->klass
->copy_msgs
!= NULL
) {
3486 if (folder
->klass
->copy_msgs(folder
, dest
, msglist
, relation
) < 0) {
3487 g_hash_table_destroy(relation
);
3494 /* immediately stop if src and dest folders are identical */
3496 msginfo
= (MsgInfo
*) l
->data
;
3497 if (msginfo
!= NULL
&& msginfo
->folder
== dest
) {
3498 g_hash_table_destroy(relation
);
3503 for (; l
!= NULL
; l
= g_slist_next(l
)) {
3504 msginfo
= (MsgInfo
*) l
->data
;
3506 num
= folder
->klass
->copy_msg(folder
, dest
, msginfo
);
3508 g_hash_table_insert(relation
, msginfo
, GINT_TO_POINTER(num
));
3510 not_moved
= g_slist_prepend(not_moved
, msginfo
);
3514 if (remove_source
) {
3515 MsgInfo
*msginfo
= (MsgInfo
*) msglist
->data
;
3516 FolderItem
*item
= msginfo
->folder
;
3518 * Remove source messages from their folders if
3519 * copying was successfull and update folder
3522 if (not_moved
== NULL
&& item
->folder
->klass
->remove_msgs
) {
3523 item
->folder
->klass
->remove_msgs(item
->folder
,
3528 for (l
= msglist
; l
!= NULL
; l
= g_slist_next(l
)) {
3529 gpointer old_key
, data
;
3530 msginfo
= (MsgInfo
*) l
->data
;
3531 item
= msginfo
->folder
;
3533 if (g_hash_table_lookup_extended(relation
, msginfo
, &old_key
, &data
))
3534 num
= GPOINTER_TO_INT(data
);
3538 if (g_slist_find(not_moved
, msginfo
))
3541 if ((num
>= 0) && (item
->folder
->klass
->remove_msg
!= NULL
)) {
3542 if (!item
->folder
->klass
->remove_msgs
)
3543 item
->folder
->klass
->remove_msg(item
->folder
,
3546 remove_msginfo_from_cache(item
, msginfo
);
3551 /* Read cache for dest folder */
3552 if (!dest
->cache
) folder_item_read_cache(dest
);
3555 * Fetch new MsgInfos for new messages in dest folder,
3556 * add them to the msgcache and update folder message counts
3558 if (some_msgs_have_zero_num(relation
)) {
3559 folder_item_scan_full(dest
, FALSE
);
3563 statusbar_print_all(_("Updating cache for %s..."), dest
->path
? dest
->path
: "(null)");
3564 total
= g_slist_length(msglist
);
3566 if (FOLDER_TYPE(dest
->folder
) == F_IMAP
&& total
> 1) {
3567 folder_item_scan_full(dest
, FALSE
);
3570 folder_item_set_batch(dest
, TRUE
);
3571 for (l
= msglist
; l
!= NULL
; l
= g_slist_next(l
)) {
3572 MsgInfo
*msginfo
= (MsgInfo
*) l
->data
;
3573 gpointer data
, old_key
;
3578 if (g_hash_table_lookup_extended(relation
, msginfo
, &old_key
, &data
))
3579 num
= GPOINTER_TO_INT(data
);
3583 statusbar_progress_all(curmsg
++,total
, 100);
3584 if (curmsg
% 100 == 0)
3588 MsgInfo
*newmsginfo
= NULL
;
3590 if (!folderscan
&& num
> 0) {
3591 newmsginfo
= get_msginfo(dest
, num
);
3592 if (newmsginfo
!= NULL
) {
3593 add_msginfo_to_cache(dest
, newmsginfo
, msginfo
);
3596 if (newmsginfo
== NULL
) {
3598 folder_item_scan_full(dest
, FALSE
);
3601 if (msginfo
->msgid
!= NULL
) {
3602 newmsginfo
= folder_item_get_msginfo_by_msgid(dest
, msginfo
->msgid
);
3603 if (newmsginfo
!= NULL
) {
3604 copy_msginfo_flags(msginfo
, newmsginfo
);
3605 num
= newmsginfo
->msgnum
;
3609 if (newmsginfo
!= NULL
3610 && msginfo
->planned_download
== POP3_PARTIAL_DLOAD_DELE
) {
3611 partial_mark_for_delete(newmsginfo
);
3613 if (newmsginfo
!= NULL
3614 && msginfo
->planned_download
== POP3_PARTIAL_DLOAD_DLOAD
) {
3615 partial_mark_for_download(newmsginfo
);
3617 if (!MSG_IS_POSTFILTERED (msginfo
->flags
)) {
3618 procmsg_msginfo_set_flags ( msginfo
, MSG_POSTFILTERED
, 0);
3620 procmsg_msginfo_set_flags (newmsginfo
, MSG_POSTFILTERED
, 0);
3621 hooks_invoke (MAIL_POSTFILTERING_HOOKLIST
, newmsginfo
);
3624 procmsg_msginfo_free(&newmsginfo
);
3631 folder_item_set_batch(dest
, FALSE
);
3632 statusbar_progress_all(0,0,0);
3633 statusbar_pop_all();
3635 g_hash_table_destroy(relation
);
3636 if (not_moved
!= NULL
) {
3637 g_slist_free(not_moved
);
3644 * Move a message to a new folder.
3646 * \param dest Destination folder
3647 * \param msginfo The message
3649 gint
folder_item_move_msg(FolderItem
*dest
, MsgInfo
*msginfo
)
3653 cm_return_val_if_fail(dest
!= NULL
, -1);
3654 cm_return_val_if_fail(msginfo
!= NULL
, -1);
3656 list
.data
= msginfo
;
3659 return do_copy_msgs(dest
, &list
, TRUE
);
3663 * Move a list of messages to a new folder.
3665 * \param dest Destination folder
3666 * \param msglist List of messages
3668 gint
folder_item_move_msgs(FolderItem
*dest
, GSList
*msglist
)
3671 cm_return_val_if_fail(dest
!= NULL
, -1);
3672 cm_return_val_if_fail(msglist
!= NULL
, -1);
3674 result
= do_copy_msgs(dest
, msglist
, TRUE
);
3680 * Copy a message to a new folder.
3682 * \param dest Destination folder
3683 * \param msginfo The message
3685 gint
folder_item_copy_msg(FolderItem
*dest
, MsgInfo
*msginfo
)
3689 cm_return_val_if_fail(dest
!= NULL
, -1);
3690 cm_return_val_if_fail(msginfo
!= NULL
, -1);
3692 list
.data
= msginfo
;
3695 return do_copy_msgs(dest
, &list
, FALSE
);
3699 * Copy a list of messages to a new folder.
3701 * \param dest Destination folder
3702 * \param msglist List of messages
3704 gint
folder_item_copy_msgs(FolderItem
*dest
, GSList
*msglist
)
3707 cm_return_val_if_fail(dest
!= NULL
, -1);
3708 cm_return_val_if_fail(msglist
!= NULL
, -1);
3711 result
= do_copy_msgs(dest
, msglist
, FALSE
);
3717 gint
folder_item_remove_msg(FolderItem
*item
, gint num
)
3723 cm_return_val_if_fail(item
!= NULL
, -1);
3724 folder
= item
->folder
;
3725 cm_return_val_if_fail(folder
->klass
->remove_msg
!= NULL
, -1);
3726 if (item
->no_select
)
3729 if (!item
->cache
) folder_item_read_cache(item
);
3731 msginfo
= msgcache_get_msg(item
->cache
, num
);
3732 if (msginfo
&& MSG_IS_LOCKED(msginfo
->flags
)) {
3733 procmsg_msginfo_free(&msginfo
);
3736 ret
= folder
->klass
->remove_msg(folder
, item
, num
);
3738 if (msginfo
!= NULL
) {
3740 remove_msginfo_from_cache(item
, msginfo
);
3741 procmsg_msginfo_free(&msginfo
);
3747 gint
folder_item_remove_msgs(FolderItem
*item
, GSList
*msglist
)
3751 GSList
*real_list
= NULL
, *cur
= NULL
;
3753 cm_return_val_if_fail(item
!= NULL
, -1);
3754 folder
= item
->folder
;
3755 cm_return_val_if_fail(folder
!= NULL
, -1);
3756 if (item
->no_select
)
3759 if (!item
->cache
) folder_item_read_cache(item
);
3761 folder_item_update_freeze();
3763 /* filter out locked mails */
3764 for (cur
= msglist
; cur
; cur
= cur
->next
) {
3765 MsgInfo
*info
= (MsgInfo
*)cur
->data
;
3766 if (!MSG_IS_LOCKED(info
->flags
))
3767 real_list
= g_slist_prepend(real_list
, info
);
3770 real_list
= g_slist_reverse(real_list
);
3772 if (item
->folder
->klass
->remove_msgs
) {
3773 ret
= item
->folder
->klass
->remove_msgs(item
->folder
,
3779 while (ret
== 0 && cur
!= NULL
) {
3780 MsgInfo
*msginfo
= (MsgInfo
*)cur
->data
;
3781 if (msginfo
&& MSG_IS_LOCKED(msginfo
->flags
)) {
3785 if (!item
->folder
->klass
->remove_msgs
)
3786 ret
= folder_item_remove_msg(item
, msginfo
->msgnum
);
3787 if (ret
!= 0) break;
3788 msgcache_remove_msg(item
->cache
, msginfo
->msgnum
);
3791 g_slist_free(real_list
);
3792 folder_item_scan_full(item
, FALSE
);
3793 folder_item_update_thaw();
3798 gint
folder_item_expunge(FolderItem
*item
)
3800 Folder
*folder
= item
->folder
;
3804 if (folder
->klass
->expunge
) {
3805 GSList
*msglist
= folder_item_get_msg_list(item
);
3807 result
= folder
->klass
->expunge(folder
, item
);
3809 for (cur
= msglist
; cur
; cur
= cur
->next
) {
3810 MsgInfo
*msginfo
= (MsgInfo
*)cur
->data
;
3811 if (MSG_IS_DELETED(msginfo
->flags
)) {
3812 remove_msginfo_from_cache(item
, msginfo
);
3816 procmsg_msg_list_free(msglist
);
3821 gint
folder_item_remove_all_msg(FolderItem
*item
)
3826 cm_return_val_if_fail(item
!= NULL
, -1);
3827 if (item
->no_select
)
3830 folder
= item
->folder
;
3833 if (folder
->klass
->remove_all_msg
!= NULL
) {
3834 result
= folder
->klass
->remove_all_msg(folder
, item
);
3837 folder_item_free_cache(item
, TRUE
);
3838 item
->cache
= msgcache_new();
3839 item
->cache_dirty
= TRUE
;
3840 item
->mark_dirty
= TRUE
;
3841 item
->tags_dirty
= TRUE
;
3844 MsgInfoList
*msglist
;
3846 msglist
= folder_item_get_msg_list(item
);
3847 result
= folder_item_remove_msgs(item
, msglist
);
3848 procmsg_msg_list_free(msglist
);
3853 item
->unread_msgs
= 0;
3854 item
->unreadmarked_msgs
= 0;
3855 item
->marked_msgs
= 0;
3856 item
->total_msgs
= 0;
3857 item
->replied_msgs
= 0;
3858 item
->forwarded_msgs
= 0;
3859 item
->locked_msgs
= 0;
3860 item
->ignored_msgs
= 0;
3861 item
->watched_msgs
= 0;
3862 folder_item_update(item
, F_ITEM_UPDATE_MSGCNT
| F_ITEM_UPDATE_CONTENT
);
3869 void folder_item_change_msg_flags(FolderItem
*item
, MsgInfo
*msginfo
, MsgPermFlags newflags
)
3871 cm_return_if_fail(item
!= NULL
);
3872 cm_return_if_fail(msginfo
!= NULL
);
3874 item
->mark_dirty
= TRUE
;
3876 if (item
->no_select
)
3879 if (item
->folder
->klass
->change_flags
!= NULL
&& item
->scanning
!= ITEM_SCANNING_WITH_FLAGS
) {
3880 item
->folder
->klass
->change_flags(item
->folder
, item
, msginfo
, newflags
);
3882 msginfo
->flags
.perm_flags
= newflags
;
3886 void folder_item_commit_tags(FolderItem
*item
, MsgInfo
*msginfo
, GSList
*tags_set
, GSList
*tags_unset
)
3888 Folder
*folder
= NULL
;
3894 if (!tags_set
&& !tags_unset
)
3897 folder
= item
->folder
;
3901 item
->tags_dirty
= TRUE
;
3903 if (folder
->klass
->commit_tags
== NULL
)
3906 folder
->klass
->commit_tags(item
, msginfo
, tags_set
, tags_unset
);
3909 gboolean
folder_item_is_msg_changed(FolderItem
*item
, MsgInfo
*msginfo
)
3913 cm_return_val_if_fail(item
!= NULL
, FALSE
);
3914 if (item
->no_select
)
3917 folder
= item
->folder
;
3919 cm_return_val_if_fail(folder
->klass
->is_msg_changed
!= NULL
, -1);
3921 return folder
->klass
->is_msg_changed(folder
, item
, msginfo
);
3924 void folder_item_discard_cache(FolderItem
*item
)
3933 msgcache_destroy(item
->cache
);
3936 dir
= folder_item_get_path(item
);
3937 if (is_dir_exist(dir
))
3938 remove_all_numbered_files(dir
);
3941 cache
= folder_item_get_cache_file(item
);
3942 if (is_file_exist(cache
))
3943 claws_unlink(cache
);
3948 static gchar
*folder_item_get_cache_file(FolderItem
*item
)
3954 cm_return_val_if_fail(item
!= NULL
, NULL
);
3955 cm_return_val_if_fail(item
->path
!= NULL
, NULL
);
3957 path
= folder_item_get_path(item
);
3958 cm_return_val_if_fail(path
!= NULL
, NULL
);
3959 if (!is_dir_exist(path
))
3960 make_dir_hier(path
);
3961 file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, CACHE_FILE
, NULL
);
3962 old_file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, OLD_CACHE_FILE
, NULL
);
3964 if (!is_file_exist(file
) && is_file_exist(old_file
))
3965 move_file(old_file
, file
, FALSE
);
3972 static gchar
*folder_item_get_mark_file(FolderItem
*item
)
3978 cm_return_val_if_fail(item
!= NULL
, NULL
);
3979 cm_return_val_if_fail(item
->path
!= NULL
, NULL
);
3981 path
= folder_item_get_path(item
);
3982 cm_return_val_if_fail(path
!= NULL
, NULL
);
3983 if (!is_dir_exist(path
))
3984 make_dir_hier(path
);
3985 file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, MARK_FILE
, NULL
);
3986 old_file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, OLD_MARK_FILE
, NULL
);
3988 if (!is_file_exist(file
) && is_file_exist(old_file
))
3989 move_file(old_file
, file
, FALSE
);
3996 static gchar
*folder_item_get_tags_file(FolderItem
*item
)
4002 /* we save tags files in rc_dir, because tagsrc is there too,
4003 * and storing tags directly in the mailboxes would give strange
4004 * result when using another Claws mailbox from another install
4005 * with different tags. */
4007 cm_return_val_if_fail(item
!= NULL
, NULL
);
4009 identifier
= folder_item_get_identifier(item
);
4010 cm_return_val_if_fail(identifier
!= NULL
, NULL
);
4013 while (strchr(identifier
, '/'))
4014 *strchr(identifier
, '/') = '\\';
4017 path
= g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S
,
4018 TAGS_DIR
, G_DIR_SEPARATOR_S
,
4023 if (!is_dir_exist(path
))
4024 make_dir_hier(path
);
4026 file
= g_strconcat(path
, G_DIR_SEPARATOR_S
, TAGS_FILE
, NULL
);
4033 static gpointer
xml_to_folder_item(gpointer nodedata
, gpointer data
)
4035 XMLNode
*xmlnode
= (XMLNode
*) nodedata
;
4036 Folder
*folder
= (Folder
*) data
;
4039 cm_return_val_if_fail(xmlnode
!= NULL
, NULL
);
4040 cm_return_val_if_fail(folder
!= NULL
, NULL
);
4042 if (strcmp2(xmlnode
->tag
->tag
, "folderitem") != 0) {
4043 g_warning("tag name != \"folderitem\"");
4047 item
= folder_item_new(folder
, "", "");
4048 if (folder
->klass
->item_set_xml
!= NULL
)
4049 folder
->klass
->item_set_xml(folder
, item
, xmlnode
->tag
);
4051 folder_item_set_xml(folder
, item
, xmlnode
->tag
);
4053 item
->folder
= folder
;
4055 switch (item
->stype
) {
4056 case F_INBOX
: folder
->inbox
= item
; break;
4057 case F_OUTBOX
: folder
->outbox
= item
; break;
4058 case F_DRAFT
: folder
->draft
= item
; break;
4059 case F_QUEUE
: folder
->queue
= item
; break;
4060 case F_TRASH
: folder
->trash
= item
; break;
4063 folder_item_prefs_read_config(item
);
4068 static gboolean
folder_item_set_node(GNode
*node
, gpointer data
)
4070 cm_return_val_if_fail(node
->data
!= NULL
, -1);
4072 FolderItem
*item
= (FolderItem
*) node
->data
;
4078 static Folder
*folder_get_from_xml(GNode
*node
)
4083 FolderClass
*klass
= NULL
;
4086 cm_return_val_if_fail(node
->data
!= NULL
, NULL
);
4088 xmlnode
= node
->data
;
4089 if (strcmp2(xmlnode
->tag
->tag
, "folder") != 0) {
4090 g_warning("tag name != \"folder\"");
4093 list
= xmlnode
->tag
->attr
;
4094 for (; list
!= NULL
; list
= list
->next
) {
4095 XMLAttr
*attr
= list
->data
;
4097 if (!attr
|| !attr
->name
|| !attr
->value
) continue;
4098 if (!strcmp(attr
->name
, "type"))
4099 klass
= folder_get_class_from_string(attr
->value
);
4104 folder
= folder_new(klass
, "", "");
4105 cm_return_val_if_fail(folder
!= NULL
, NULL
);
4108 klass
->set_xml(folder
, xmlnode
->tag
);
4110 folder_set_xml(folder
, xmlnode
->tag
);
4112 cur
= node
->children
;
4113 while (cur
!= NULL
) {
4116 itemnode
= g_node_map(cur
, xml_to_folder_item
, (gpointer
) folder
);
4117 g_node_append(folder
->node
, itemnode
);
4120 g_node_traverse(folder
->node
, G_IN_ORDER
, G_TRAVERSE_ALL
, -1, folder_item_set_node
, NULL
);
4125 gchar
*folder_get_list_path(void)
4127 static gchar
*filename
= NULL
;
4130 filename
= g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S
,
4136 static gpointer
folder_item_to_xml(gpointer nodedata
, gpointer data
)
4138 FolderItem
*item
= (FolderItem
*) nodedata
;
4141 cm_return_val_if_fail(item
!= NULL
, NULL
);
4143 if (item
->folder
->klass
->item_get_xml
!= NULL
)
4144 tag
= item
->folder
->klass
->item_get_xml(item
->folder
, item
);
4146 tag
= folder_item_get_xml(item
->folder
, item
);
4148 return xml_node_new(tag
, NULL
);
4151 static GNode
*folder_get_xml_node(Folder
*folder
)
4157 cm_return_val_if_fail(folder
!= NULL
, NULL
);
4159 if (folder
->klass
->get_xml
!= NULL
)
4160 tag
= folder
->klass
->get_xml(folder
);
4162 tag
= folder_get_xml(folder
);
4164 xml_tag_add_attr(tag
, xml_attr_new("type", folder
->klass
->idstr
));
4166 xmlnode
= xml_node_new(tag
, NULL
);
4168 node
= g_node_new(xmlnode
);
4170 cm_return_val_if_fail (folder
->node
!= NULL
, NULL
);
4172 if (folder
->node
->children
) {
4175 cur
= folder
->node
->children
;
4179 xmlnode
= g_node_map(cur
, folder_item_to_xml
, (gpointer
) folder
);
4180 g_node_append(node
, xmlnode
);
4188 static void folder_update_op_count_rec(GNode
*node
)
4190 FolderItem
*fitem
= FOLDER_ITEM(node
->data
);
4192 if (g_node_depth(node
) > 0) {
4193 if (fitem
->op_count
> 0) {
4194 fitem
->op_count
= 0;
4195 folder_item_update(fitem
, F_ITEM_UPDATE_MSGCNT
);
4197 if (node
->children
) {
4200 child
= node
->children
;
4206 folder_update_op_count_rec(cur
);
4212 void folder_update_op_count(void)
4217 for (cur
= folder_list
; cur
!= NULL
; cur
= cur
->next
) {
4219 folder_update_op_count_rec(folder
->node
);
4223 typedef struct _type_str
{
4230 static gchar * folder_item_get_tree_identifier(FolderItem * item)
4232 if (item->parent != NULL) {
4236 path = folder_item_get_tree_identifier(item->parent);
4240 id = g_strconcat(path, "/", item->name, NULL);
4246 return g_strconcat("/", item->name, NULL);
4251 /* CLAWS: temporary local folder for filtering */
4252 #define TEMP_FOLDER "TEMP_FOLDER"
4253 #define PROCESSING_FOLDER_ITEM "processing"
4255 static FolderItem
*folder_create_processing_folder(int account_id
)
4257 static Folder
*processing_folder
= NULL
;
4258 FolderItem
*processing_folder_item
;
4260 gchar
*processing_folder_item_name
= NULL
;
4262 processing_folder_item_name
= g_strdup_printf("%s-%d", PROCESSING_FOLDER_ITEM
, account_id
);
4264 if (processing_folder
== NULL
) {
4266 g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S
,
4267 "tempfolder", NULL
);
4269 folder_new(mh_get_class(), TEMP_FOLDER
, tmppath
);
4273 g_assert(processing_folder
!= NULL
);
4274 processing_folder
->klass
->scan_tree(processing_folder
);
4276 g_assert(processing_folder
!= NULL
);
4278 processing_folder_item
= folder_find_child_item_by_name(FOLDER_ITEM(processing_folder
->node
->data
),
4279 processing_folder_item_name
);
4280 if (processing_folder_item
) {
4281 debug_print("*TMP* already created %s\n", folder_item_get_path(processing_folder_item
));
4283 processing_folder_item
= processing_folder
->klass
->create_folder(processing_folder
,
4284 processing_folder
->node
->data
,
4285 processing_folder_item_name
);
4286 folder_item_append(FOLDER_ITEM(processing_folder
->node
->data
), processing_folder_item
);
4287 debug_print("*TMP* creating %s\n", folder_item_get_path(processing_folder_item
));
4289 g_free(processing_folder_item_name
);
4290 g_assert(processing_folder_item
!= NULL
);
4292 return(processing_folder_item
);
4295 FolderItem
*folder_get_default_processing(int account_id
)
4297 return folder_create_processing_folder(account_id
);
4300 /* folder_persist_prefs_new() - return hash table with persistent
4301 * settings (and folder name as key).
4302 * (note that in claws other options are in the folder_item_prefs_RC
4303 * file, so those don't need to be included in PersistPref yet)
4305 static GHashTable
*folder_persist_prefs_new(Folder
*folder
)
4307 GHashTable
*pptable
;
4309 cm_return_val_if_fail(folder
, NULL
);
4310 pptable
= g_hash_table_new(g_str_hash
, g_str_equal
);
4311 folder_get_persist_prefs_recursive(folder
->node
, pptable
);
4315 static void folder_persist_prefs_free(GHashTable
*pptable
)
4317 cm_return_if_fail(pptable
);
4318 g_hash_table_foreach_remove(pptable
, persist_prefs_free
, NULL
);
4319 g_hash_table_destroy(pptable
);
4322 static const PersistPrefs
*folder_get_persist_prefs(GHashTable
*pptable
, const char *name
)
4324 if (pptable
== NULL
|| name
== NULL
) return NULL
;
4325 return g_hash_table_lookup(pptable
, name
);
4328 static void folder_item_restore_persist_prefs(FolderItem
*item
, GHashTable
*pptable
)
4330 const PersistPrefs
*pp
;
4331 gchar
*id
= folder_item_get_identifier(item
);
4333 pp
= folder_get_persist_prefs(pptable
, id
);
4338 /* CLAWS: since not all folder properties have been migrated to
4339 * folderlist.xml, we need to call the old stuff first before
4340 * setting things that apply both to Main and Claws. */
4341 folder_item_prefs_read_config(item
);
4343 item
->collapsed
= pp
->collapsed
;
4344 item
->thread_collapsed
= pp
->thread_collapsed
;
4345 item
->threaded
= pp
->threaded
;
4346 item
->ret_rcpt
= pp
->ret_rcpt
;
4347 item
->hide_read_msgs
= pp
->hide_read_msgs
;
4348 item
->hide_del_msgs
= pp
->hide_del_msgs
;
4349 item
->hide_read_threads
= pp
->hide_read_threads
;
4350 item
->sort_key
= pp
->sort_key
;
4351 item
->sort_type
= pp
->sort_type
;
4354 static void folder_get_persist_prefs_recursive(GNode
*node
, GHashTable
*pptable
)
4356 FolderItem
*item
= FOLDER_ITEM(node
->data
);
4361 cm_return_if_fail(node
!= NULL
);
4362 cm_return_if_fail(item
!= NULL
);
4364 /* NOTE: item->path == NULL means top level folder; not interesting
4365 * to store preferences of that one. */
4367 id
= folder_item_get_identifier(item
);
4368 pp
= g_new0(PersistPrefs
, 1);
4369 cm_return_if_fail(pp
!= NULL
);
4370 pp
->collapsed
= item
->collapsed
;
4371 pp
->thread_collapsed
= item
->thread_collapsed
;
4372 pp
->threaded
= item
->threaded
;
4373 pp
->ret_rcpt
= item
->ret_rcpt
;
4374 pp
->hide_read_msgs
= item
->hide_read_msgs
;
4375 pp
->hide_del_msgs
= item
->hide_del_msgs
;
4376 pp
->hide_read_threads
= item
->hide_read_threads
;
4377 pp
->sort_key
= item
->sort_key
;
4378 pp
->sort_type
= item
->sort_type
;
4379 g_hash_table_insert(pptable
, id
, pp
);
4382 if (node
->children
) {
4383 child
= node
->children
;
4387 folder_get_persist_prefs_recursive(cur
, pptable
);
4392 static gboolean
persist_prefs_free(gpointer key
, gpointer val
, gpointer data
)
4399 void folder_item_apply_processing(FolderItem
*item
)
4401 GSList
*processing_list
;
4402 GSList
*mlist
, *cur
;
4403 guint total
= 0, curmsg
= 0;
4404 gint last_apply_per_account
;
4406 cm_return_if_fail(item
!= NULL
);
4408 if (item
->no_select
)
4411 processing_list
= item
->prefs
->processing
;
4413 if (!pre_global_processing
&& !processing_list
4414 && !post_global_processing
)
4417 debug_print("processing %s\n", item
->name
);
4418 folder_item_update_freeze();
4422 mlist
= folder_item_get_msg_list(item
);
4423 total
= g_slist_length(mlist
);
4424 statusbar_print_all(_("Processing messages..."));
4426 last_apply_per_account
= prefs_common
.apply_per_account_filtering_rules
;
4427 prefs_common
.apply_per_account_filtering_rules
= FILTERING_ACCOUNT_RULES_SKIP
;
4429 folder_item_set_batch(item
, TRUE
);
4430 for (cur
= mlist
; cur
!= NULL
; cur
= cur
->next
) {
4433 msginfo
= (MsgInfo
*) cur
->data
;
4435 /* reset parameters that can be modified by processing */
4436 msginfo
->hidden
= 0;
4439 statusbar_progress_all(curmsg
++,total
, 10);
4441 /* apply pre global rules */
4442 filter_message_by_msginfo(pre_global_processing
, msginfo
, NULL
,
4443 FILTERING_PRE_PROCESSING
, NULL
);
4445 /* apply rules of the folder */
4446 filter_message_by_msginfo(processing_list
, msginfo
, NULL
,
4447 FILTERING_FOLDER_PROCESSING
, item
->name
);
4449 /* apply post global rules */
4450 filter_message_by_msginfo(post_global_processing
, msginfo
, NULL
,
4451 FILTERING_POST_PROCESSING
, NULL
);
4452 if (curmsg
% 1000 == 0)
4455 folder_item_set_batch(item
, FALSE
);
4457 prefs_common
.apply_per_account_filtering_rules
= last_apply_per_account
;
4459 if (pre_global_processing
|| processing_list
4460 || post_global_processing
)
4461 filtering_move_and_copy_msgs(mlist
);
4462 for (cur
= mlist
; cur
!= NULL
; cur
= cur
->next
) {
4463 procmsg_msginfo_free((MsgInfo
**)&(cur
->data
));
4465 g_slist_free(mlist
);
4467 statusbar_progress_all(0,0,0);
4468 statusbar_pop_all();
4472 folder_item_update_thaw();
4476 * functions for handling FolderItem content changes
4478 static gint folder_item_update_freeze_cnt
= 0;
4480 static void folder_item_update_with_msg(FolderItem
*item
, FolderItemUpdateFlags update_flags
, MsgInfo
*msg
)
4482 if (folder_item_update_freeze_cnt
== 0 /* || (msg != NULL && item->opened) */) {
4483 FolderItemUpdateData source
;
4486 source
.update_flags
= update_flags
;
4488 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST
, &source
);
4490 item
->update_flags
|= update_flags
& ~(F_ITEM_UPDATE_ADDMSG
| F_ITEM_UPDATE_REMOVEMSG
);
4495 * Notify the folder system about changes to a folder. If the
4496 * update system is not frozen the FOLDER_ITEM_UPDATE_HOOKLIST will
4497 * be invoked, otherwise the changes will be remebered until
4498 * the folder system is thawed.
4500 * \param item The FolderItem that was changed
4501 * \param update_flags Type of changed that was made
4503 void folder_item_update(FolderItem
*item
, FolderItemUpdateFlags update_flags
)
4505 folder_item_update_with_msg(item
, update_flags
, NULL
);
4508 void folder_item_update_recursive(FolderItem
*item
, FolderItemUpdateFlags update_flags
)
4510 GNode
*node
= item
->folder
->node
;
4512 node
= g_node_find(node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, item
);
4513 node
= node
->children
;
4515 folder_item_update(item
, update_flags
);
4516 while (node
!= NULL
) {
4517 if (node
&& node
->data
) {
4518 FolderItem
*next_item
= (FolderItem
*) node
->data
;
4520 folder_item_update(next_item
, update_flags
);
4526 void folder_item_update_freeze(void)
4528 folder_item_update_freeze_cnt
++;
4531 static void folder_item_update_func(FolderItem
*item
, gpointer data
)
4533 FolderItemUpdateData source
;
4535 if (item
->update_flags
) {
4537 source
.update_flags
= item
->update_flags
;
4539 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST
, &source
);
4540 item
->update_flags
= 0;
4544 void folder_item_update_thaw(void)
4546 if (folder_item_update_freeze_cnt
> 0)
4547 folder_item_update_freeze_cnt
--;
4548 if (folder_item_update_freeze_cnt
== 0) {
4549 /* Update all folders */
4550 folder_func_to_all_folders(folder_item_update_func
, NULL
);
4554 void folder_item_synchronise(FolderItem
*item
)
4558 if (item
->prefs
->offlinesync
&& item
->folder
->klass
->synchronise
) {
4559 statuswindow_print_all(_("Synchronising %s for offline use...\n"), item
->path
? item
->path
: "(null)");
4560 item
->folder
->klass
->synchronise(item
,
4561 item
->prefs
->offlinesync_days
);
4562 if (item
->prefs
->offlinesync_days
> 0 &&
4563 item
->prefs
->remove_old_bodies
)
4564 folder_item_clean_local_files(item
, item
->prefs
->offlinesync_days
);
4565 statuswindow_pop_all();
4569 static void folder_item_synchronise_func(FolderItem
*item
, gpointer data
)
4571 Folder
*folder
= (Folder
*)data
;
4572 if (folder
== NULL
|| item
->folder
== folder
) {
4573 folder_item_synchronise(item
);
4577 void folder_synchronise(Folder
*folder
)
4579 folder_func_to_all_folders(folder_item_synchronise_func
, folder
);
4582 typedef struct _WantSyncData
{
4587 static void folder_item_want_synchronise_func(FolderItem
*item
, gpointer data
)
4589 WantSyncData
*want_sync_data
= (WantSyncData
*)data
;
4591 if (want_sync_data
->folder
== NULL
|| item
->folder
== want_sync_data
->folder
) {
4592 if (item
->prefs
->offlinesync
&& item
->folder
->klass
->synchronise
)
4593 want_sync_data
->want_sync
|= TRUE
;
4597 gboolean
folder_want_synchronise(Folder
*folder
)
4599 WantSyncData
*want_sync_data
= g_new0(WantSyncData
, 1);
4601 want_sync_data
->folder
= folder
;
4602 want_sync_data
->want_sync
= FALSE
;
4604 folder_func_to_all_folders(folder_item_want_synchronise_func
, want_sync_data
);
4605 result
= want_sync_data
->want_sync
;
4606 g_free(want_sync_data
);
4608 debug_print("Folder %s wants sync\n", folder
->name
);
4612 void folder_item_set_batch (FolderItem
*item
, gboolean batch
)
4614 if (!item
|| !item
->folder
)
4616 if (item
->folder
->klass
->set_batch
) {
4617 item
->folder
->klass
->set_batch(item
->folder
, item
, batch
);
4621 gboolean
folder_has_parent_of_type(FolderItem
*item
,
4622 SpecialFolderItemType type
)
4624 FolderItem
*cur
= item
;
4628 /* if we already know it, make it short */
4629 if (item
->parent_stype
!= -1) {
4630 return (item
->parent_stype
== type
);
4633 /* if we don't, find the type from the first possible parent,
4634 * and set our parent type to be faster next time */
4636 if (cur
->stype
== type
|| cur
->parent_stype
== type
) {
4637 item
->parent_stype
= type
;
4640 cur
= folder_item_parent(cur
);
4643 /* if we didn't match what was asked, we didn't return. If our
4644 * parent type is unknown, we may as well find it now to be faster
4646 if (item
->parent_stype
== -1) {
4649 /* here's an exception: Inbox subfolders are normal. */
4650 if (item
->parent_stype
== -1 && cur
->stype
== F_INBOX
4652 item
->parent_stype
= F_NORMAL
;
4655 /* ah, we know this parent's parent's type, we may as
4656 * well copy it instead of going up the full way */
4657 if (cur
->parent_stype
!= -1) {
4658 item
->parent_stype
= cur
->parent_stype
;
4661 /* we found a parent that has a special type. That's
4662 * our parent type. */
4663 if (cur
->stype
!= F_NORMAL
) {
4664 cur
->parent_stype
= cur
->stype
;
4665 item
->parent_stype
= cur
->stype
;
4668 /* if we didn't find anything, go up once more */
4669 cur
= folder_item_parent(cur
);
4671 /* as we still didn't find anything, our parents must all be
4673 if (item
->parent_stype
== -1) {
4674 item
->parent_stype
= F_NORMAL
;
4680 gboolean
folder_is_child_of(FolderItem
*item
, FolderItem
*parent
)
4682 if (item
== NULL
|| parent
== NULL
)
4685 while (item
!= NULL
) {
4689 item
= folder_item_parent(item
);
4696 gboolean
folder_subscribe (const gchar
*uri
)
4699 for (cur
= folder_get_list(); cur
!= NULL
; cur
= g_list_next(cur
)) {
4700 Folder
*folder
= (Folder
*) cur
->data
;
4702 if (folder
->klass
->subscribe
4703 && folder
->klass
->subscribe(folder
, uri
)) {
4711 gboolean
folder_get_sort_type (Folder
*folder
,
4712 FolderSortKey
*sort_key
,
4713 FolderSortType
*sort_type
)
4715 if (!folder
|| !sort_key
|| !sort_type
)
4717 if (folder
->klass
->get_sort_type
== NULL
)
4719 folder
->klass
->get_sort_type(folder
, sort_key
, sort_type
);
4723 gint
folder_item_search_msgs (Folder
*folder
,
4724 FolderItem
*container
,
4725 MsgNumberList
**msgs
,
4726 gboolean
*on_server
,
4727 MatcherList
*predicate
,
4728 SearchProgressNotify progress_cb
,
4729 gpointer progress_data
)
4733 folder_item_update_freeze();
4735 if (folder
->klass
->search_msgs
)
4736 result
= folder
->klass
->search_msgs(folder
, container
,
4737 msgs
, on_server
, predicate
, progress_cb
, progress_data
);
4739 result
= folder_item_search_msgs_local(folder
, container
,
4740 msgs
, on_server
, predicate
, progress_cb
, progress_data
);
4742 folder_item_update_thaw();
4747 MsgNumberList
*folder_item_get_number_list(FolderItem
*item
)
4749 GSList
*nums
= NULL
;
4750 GSList
*msglist
= folder_item_get_msg_list(item
);
4752 nums
= procmsg_get_number_list_for_msgs(msglist
);
4753 procmsg_msg_list_free(msglist
);
4758 gint
folder_item_search_msgs_local (Folder
*folder
,
4759 FolderItem
*container
,
4760 MsgNumberList
**msgs
,
4761 gboolean
*on_server
,
4762 MatcherList
*predicate
,
4763 SearchProgressNotify progress_cb
,
4764 gpointer progress_data
)
4766 GSList
*result
= NULL
;
4768 gint matched_count
= 0;
4769 guint processed_count
= 0;
4771 GSList
*nums
= NULL
;
4773 if (*msgs
== NULL
) {
4774 nums
= folder_item_get_number_list(container
);
4779 msgcount
= g_slist_length(nums
);
4784 for (cur
= nums
; cur
!= NULL
; cur
= cur
->next
) {
4785 guint msgnum
= GPOINTER_TO_UINT(cur
->data
);
4786 MsgInfo
*msg
= folder_item_get_msginfo(container
, msgnum
);
4789 g_slist_free(result
);
4793 if (matcherlist_match(predicate
, msg
)) {
4794 result
= g_slist_prepend(result
, GUINT_TO_POINTER(msg
->msgnum
));
4799 if (progress_cb
!= NULL
4800 && !progress_cb(progress_data
, FALSE
, processed_count
,
4801 matched_count
, msgcount
))
4806 *msgs
= g_slist_reverse(result
);
4808 return matched_count
;
4811 /* Tests if a local (on disk) folder name is acceptable. */
4812 gboolean
folder_local_name_ok(const gchar
*name
)
4815 if (name
[0] == '.' || name
[strlen(name
) - 1] == '.') {
4816 alertpanel_error(_("A folder name cannot begin or end with a dot."));
4819 if (name
[strlen(name
) - 1] == ' ') {
4820 alertpanel_error(_("A folder name can not end with a space."));