#include "prefs_common.h"
#include "account.h"
#include "prefs_account.h"
+#include "filtering.h"
+#include "scoring.h"
#include "prefs_folder_item.h"
#include "procheader.h"
(GNode *node, GHashTable *pptable);
static gboolean persist_prefs_free (gpointer key, gpointer val, gpointer data);
void folder_item_read_cache (FolderItem *item);
-void folder_item_write_cache (FolderItem *item);
-
+void folder_item_free_cache (FolderItem *item);
Folder *folder_new(FolderType type, const gchar *name, const gchar *path)
{
folder_set_name(folder, name);
/* Init folder data */
- folder->type = F_UNKNOWN;
folder->account = NULL;
folder->inbox = NULL;
folder->outbox = NULL;
folder->check_msgnum_validity = NULL;
/* Create root folder item */
- item = folder_item_new(name, NULL);
+ item = folder_item_new(folder, name, NULL);
item->folder = folder;
folder->node = g_node_new(item);
folder->data = NULL;
}
#endif
-FolderItem *folder_item_new(const gchar *name, const gchar *path)
+FolderItem *folder_item_new(Folder *folder, const gchar *name, const gchar *path)
{
- FolderItem *item;
+ FolderItem *item = NULL;
+
+ switch (folder->type) {
+ case F_IMAP:
+ item = imap_folder_item_new();
+ break;
+ case F_MH:
+ case F_NEWS:
+ case F_MBOX:
+ item = g_new0(FolderItem, 1);
+ break;
+ default:
+ return NULL;
+ }
- item = g_new0(FolderItem, 1);
+ g_return_val_if_fail(item != NULL, NULL);
item->stype = F_NORMAL;
item->name = g_strdup(name);
g_return_if_fail(item != NULL);
debug_print(_("Destroying folder item %s\n"), item->path);
-
+
+ if (item->folder != NULL) {
+ switch (item->folder->type) {
+ case F_IMAP:
+ imap_folder_item_destroy(item);
+ break;
+ default:
+ break;
+ }
+ }
+
if(item->cache)
folder_item_free_cache(item);
g_free(item->name);
void folder_tree_destroy(Folder *folder)
{
- /* TODO: destroy all FolderItem before */
+ g_return_if_fail(folder != NULL);
+ g_return_if_fail(folder->node != NULL);
+
+ prefs_scoring_clear();
+ prefs_filtering_clear();
+
g_node_traverse(folder->node, G_POST_ORDER, G_TRAVERSE_ALL, -1, folder_tree_destroy_func, NULL);
g_node_destroy(folder->node);
g_warning("failed to write folder list.\n");
}
+gboolean folder_scan_tree_func(GNode *node, gpointer data)
+{
+ GHashTable *pptable = (GHashTable *)data;
+ FolderItem *item = (FolderItem *)node->data;
+
+ folder_item_restore_persist_prefs(item, pptable);
+}
+
+void folder_scan_tree(Folder *folder)
+{
+ GHashTable *pptable;
+
+ if(!folder->scan_tree)
+ return;
+
+ pptable = folder_persist_prefs_new(folder);
+ folder_tree_destroy(folder);
+
+ folder->scan_tree(folder);
+
+ g_node_traverse(folder->node, G_POST_ORDER, G_TRAVERSE_ALL, -1, folder_scan_tree_func, pptable);
+ folder_persist_prefs_free(pptable);
+
+ prefs_matcher_read_config();
+}
+
struct TotalMsgCount
{
guint new;
return folder->trash;
}
-#define CREATE_FOLDER_IF_NOT_EXIST(member, dir, type) \
-{ \
- if (!folder->member) { \
- item = folder_item_new(dir, dir); \
- item->stype = type; \
- folder_item_append(rootitem, item); \
- folder->member = item; \
- } \
+#define CREATE_FOLDER_IF_NOT_EXIST(member, dir, type) \
+{ \
+ if (!folder->member) { \
+ item = folder_item_new(folder, dir, dir); \
+ item->stype = type; \
+ folder_item_append(rootitem, item); \
+ folder->member = item; \
+ } \
}
void folder_set_missing_folders(void)
Folder *folder;
GSList *folder_list, *cache_list, *elem, *new_list = NULL;
gint i;
- guint min = 0xffffffff, max = 0, cache_max = 0, maxgetcount = 0;
+ guint min = 0xffffffff, max = 0, cache_max = 0;
FolderScanInfo *folderscaninfo;
guint newcnt = 0, unreadcnt = 0, totalcnt = 0;
if( (folderscaninfo[i] & IN_FOLDER) &&
!(folderscaninfo[i] & IN_CACHE) &&
(folder->type != F_NEWS ||
- ((prefs_common.max_articles == 0) || (num > (max - prefs_common.max_articles))) &&
- (num > cache_max))
+ (((prefs_common.max_articles == 0) || (num > (max - prefs_common.max_articles))) &&
+ (num > cache_max)))
) {
new_list = g_slist_prepend(new_list, GINT_TO_POINTER(num));
debug_print(_("Remembered message %d for fetching\n"), num);
}
/* Check if msginfo needs update if in cache and in folder */
if((folderscaninfo[i] & IN_FOLDER) &&
- (folderscaninfo[i] & IN_CACHE) &&
- (folder->is_msg_changed != NULL)) {
+ (folderscaninfo[i] & IN_CACHE)) {
MsgInfo *msginfo;
msginfo = msgcache_get_msg(item->cache, num);
- if(folder->is_msg_changed(folder, item, msginfo)) {
+ if(folder->is_msg_changed && folder->is_msg_changed(folder, item, msginfo)) {
MsgInfo *newmsginfo;
msgcache_remove_msg(item->cache, msginfo->msgnum);
}
} else if (folder->fetch_msginfo) {
for(elem = new_list; elem != NULL; elem = g_slist_next(elem)) {
- MsgFlags flags;
MsgInfo *msginfo;
guint num;
void folder_item_free_cache(FolderItem *item)
{
g_return_if_fail(item != NULL);
- g_return_if_fail(item->cache != NULL);
+
+ if(item->cache == NULL)
+ return;
folder_item_write_cache(item);
msgcache_destroy(item->cache);
if(!item->cache)
folder_item_read_cache(item);
- if(msginfo = msgcache_get_msg(item->cache, num))
+ if((msginfo = msgcache_get_msg(item->cache, num)) != NULL)
return msginfo;
g_return_val_if_fail(folder->fetch_msginfo, NULL);
- msginfo = folder->fetch_msginfo(folder, item, num);
- return msginfo;
+ if((msginfo = folder->fetch_msginfo(folder, item, num)) != NULL) {
+ msgcache_add_msg(item->cache, msginfo);
+ return msginfo;
+ }
+
+ return NULL;
+}
+
+MsgInfo *folder_item_fetch_msginfo_by_id(FolderItem *item, const gchar *msgid)
+{
+ Folder *folder;
+ MsgInfo *msginfo;
+
+ g_return_val_if_fail(item != NULL, NULL);
+
+ folder = item->folder;
+ if(!item->cache)
+ folder_item_read_cache(item);
+
+ if((msginfo = msgcache_get_msg_by_id(item->cache, msgid)) != NULL)
+ return msginfo;
+
+ return NULL;
}
GSList *folder_item_get_msg_list(FolderItem *item)
{
Folder *folder;
gint num;
- gchar * filename;
Folder * src_folder;
g_return_val_if_fail(dest != NULL, -1);
gint folder_item_move_msgs_with_dest(FolderItem *dest, GSList *msglist)
{
Folder *folder;
- FolderItem * item;
- GSList * l;
- gchar * filename;
+ FolderItem *item;
+ GSList *newmsgnums = NULL;
+ GSList *l, *l2;
gint num;
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(folder->copy_msg != NULL, -1);
g_return_val_if_fail(folder->remove_msg != NULL, -1);
- if (!dest->cache) folder_item_read_cache(dest);
-
+ /*
+ * Copy messages to destination folder and
+ * store new message numbers in newmsgnums
+ */
item = NULL;
for(l = msglist ; l != NULL ; l = g_slist_next(l)) {
MsgInfo * msginfo = (MsgInfo *) l->data;
if (!item && msginfo->folder != NULL)
item = msginfo->folder;
- if (!item->cache) folder_item_read_cache(dest);
num = folder->copy_msg(folder, dest, msginfo);
+ newmsgnums = g_slist_append(newmsgnums, GINT_TO_POINTER(num));
+ }
+
+ /* Read cache for dest folder */
+ if (!dest->cache) folder_item_read_cache(dest);
+
+ /*
+ * Fetch new MsgInfos for new messages in dest folder,
+ * add them to the msgcache and update folder message counts
+ */
+ l2 = newmsgnums;
+ for(l = msglist; l != NULL; l = g_slist_next(l)) {
+ MsgInfo *msginfo = (MsgInfo *) l->data;
+
+ num = GPOINTER_TO_INT(l2->data);
+
if (num != -1) {
MsgInfo *newmsginfo;
MSG_NEW|MSG_UNREAD|MSG_DELETED);
msgcache_add_msg(dest->cache, newmsginfo);
- if (MSG_IS_NEW(msginfo->flags))
- msginfo->folder->new--;
if (MSG_IS_NEW(newmsginfo->flags))
dest->new++;
- if (MSG_IS_UNREAD(msginfo->flags))
- msginfo->folder->unread--;
if (MSG_IS_UNREAD(newmsginfo->flags))
dest->unread++;
- msginfo->folder->total--;
dest->total++;
procmsg_msginfo_free(newmsginfo);
}
+ }
+ l2 = g_slist_next(l2);
+ }
+
+ /*
+ * Remove source messages from their folders if
+ * copying was successfull and update folder
+ * message counts
+ */
+ l2 = newmsgnums;
+ for(l = msglist; l != NULL; l = g_slist_next(l)) {
+ MsgInfo *msginfo = (MsgInfo *) l->data;
+
+ num = GPOINTER_TO_INT(l2->data);
+
+ if(num != -1) {
item->folder->remove_msg(item->folder,
msginfo->folder,
msginfo->msgnum);
+ if(!item->cache)
+ folder_item_read_cache(item);
msgcache_remove_msg(item->cache, msginfo->msgnum);
+
+ if (MSG_IS_NEW(msginfo->flags))
+ msginfo->folder->new--;
+ if (MSG_IS_UNREAD(msginfo->flags))
+ msginfo->folder->unread--;
+ msginfo->folder->total--;
}
- }
+
+ l2 = g_slist_next(l2);
+ }
+
if (folder->finished_copy)
folder->finished_copy(folder, dest);
+ g_slist_free(newmsgnums);
return dest->last_num;
}
{
Folder *folder;
gint num;
- gchar * filename;
- Folder * src_folder;
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(msginfo != NULL, -1);
{
Folder *folder;
gint num;
- GSList * l;
- gchar * filename;
+ GSList *newmsgnums = NULL;
+ GSList *l, *l2;
g_return_val_if_fail(dest != NULL, -1);
g_return_val_if_fail(msglist != NULL, -1);
g_return_val_if_fail(folder->copy_msg != NULL, -1);
- if (!dest->cache) folder_item_read_cache(dest);
-
+ /*
+ * Copy messages to destination folder and
+ * store new message numbers in newmsgnums
+ */
for(l = msglist ; l != NULL ; l = g_slist_next(l)) {
MsgInfo * msginfo = (MsgInfo *) l->data;
num = folder->copy_msg(folder, dest, msginfo);
+ newmsgnums = g_slist_append(newmsgnums, GINT_TO_POINTER(num));
+ }
+
+ /* Read cache for dest folder */
+ if (!dest->cache) folder_item_read_cache(dest);
+
+ /*
+ * Fetch new MsgInfos for new messages in dest folder,
+ * add them to the msgcache and update folder message counts
+ */
+ l2 = newmsgnums;
+ for(l = msglist; l != NULL; l = g_slist_next(l)) {
+ MsgInfo *msginfo = (MsgInfo *) l->data;
+
+ num = GPOINTER_TO_INT(l2->data);
+
if (num != -1) {
MsgInfo *newmsginfo;
procmsg_msginfo_free(newmsginfo);
}
}
+ l2 = g_slist_next(l2);
}
-
+
if (folder->finished_copy)
folder->finished_copy(folder, dest);
+ g_slist_free(newmsgnums);
return dest->last_num;
}
if (result == 0) {
if (folder->finished_remove)
folder->finished_remove(folder, item);
+
+ folder_item_free_cache(item);
+ item->cache = msgcache_new();
+
+ item->new = 0;
+ item->unread = 0;
+ item->total = 0;
}
return result;
}
}
- item = folder_item_new(name, path);
+ item = folder_item_new(folder, name, path);
item->stype = stype;
item->account = account;
item->mtime = mtime;
{
#define PROCESSING_FOLDER ".processing"
Folder *tmpparent;
- FolderItem *tmpfolder;
gchar *tmpname;
tmpparent = folder_get_default_folder();
}
else {
debug_print("*TMP* already created\n");
- processing_folder_item = folder_item_new(".processing", ".processing");
+ processing_folder_item = folder_item_new(processing_folder, ".processing", ".processing");
g_assert(processing_folder_item);
folder_item_append(processing_folder->node->data, processing_folder_item);
}
void folder_item_restore_persist_prefs(FolderItem *item, GHashTable *pptable)
{
const PersistPrefs *pp;
+ gchar *id = folder_item_get_identifier(item);
+
+ pp = folder_get_persist_prefs(pptable, id);
+ g_free(id);
- pp = folder_get_persist_prefs(pptable, item->path);
if (!pp) return;
/* CLAWS: since not all folder properties have been migrated to
FolderItem *item = FOLDER_ITEM(node->data);
PersistPrefs *pp;
GNode *child, *cur;
+ gchar *id;
g_return_if_fail(node != NULL);
g_return_if_fail(item != NULL);
- /* FIXME: item->path == NULL for top level folder, so this means that
- * properties of MH folder root will not be stored. Not quite important,
- * because the top level folder properties are not special anyway. */
+ /* NOTE: item->path == NULL means top level folder; not interesting
+ * to store preferences of that one. */
if (item->path) {
+ id = folder_item_get_identifier(item);
pp = g_new0(PersistPrefs, 1);
g_return_if_fail(pp != NULL);
pp->collapsed = item->collapsed;
pp->hide_read_msgs = item->hide_read_msgs;
pp->sort_key = item->sort_key;
pp->sort_type = item->sort_type;
- g_hash_table_insert(pptable, item->path, pp);
- }
+ g_hash_table_insert(pptable, id, pp);
+ }
if (node->children) {
child = node->children;
static gboolean persist_prefs_free(gpointer key, gpointer val, gpointer data)
{
+ if (key)
+ g_free(key);
if (val)
g_free(val);
return TRUE;
}
+void folder_item_apply_processing(FolderItem *item)
+{
+ GSList *processing_list;
+ GSList *mlist, *cur;
+ GHashTable *folder_table;
+
+ g_return_if_fail(item != NULL);
+
+ processing_list = item->prefs->processing;
+ if (processing_list == NULL)
+ return;
+ folder_table = g_hash_table_new(NULL, NULL);
+
+ mlist = folder_item_get_msg_list(item);
+
+ for(cur = mlist ; cur != NULL ; cur = cur->next) {
+ MsgInfo * msginfo;
+
+ msginfo = (MsgInfo *) cur->data;
+ filter_message_by_msginfo(processing_list, msginfo,
+ folder_table);
+ procmsg_msginfo_free(msginfo);
+ }
+
+ /* folder_item_scan_foreach(summaryview->folder_table); */
+ folderview_update_item_foreach(folder_table);
+
+ g_slist_free(mlist);
+
+ g_hash_table_destroy(folder_table);
+}
projects / claws.git / blobdiff