make folder properties persistent so they are properly restored after rescanning...
[claws.git] / src / folder.c
index ca10f0e70d5444d36a70d94881db9c59b6c0ab0d..35dbbf9ecd95c948f9a7d0e5cfeaac716f025d4f 100644 (file)
 #include "account.h"
 #include "prefs_account.h"
 #include "mbox_folder.h"
+#include "prefs_folder_item.h"
+
+#include <sys/stat.h>
+#include <sys/types.h>
 
 static GList *folder_list = NULL;
 
@@ -64,6 +68,11 @@ static void folder_write_list_recursive      (GNode          *node,
 static void folder_update_op_count_rec (GNode          *node);
 
 
+static void folder_get_persist_prefs_recursive
+                                       (GNode *node, GHashTable *pptable);
+static gboolean persist_prefs_free     (gpointer key, gpointer val, gpointer data);
+
+
 Folder *folder_new(FolderType type, const gchar *name, const gchar *path)
 {
        Folder *folder = NULL;
@@ -1107,7 +1116,7 @@ static gboolean folder_build_tree(GNode *node, gpointer data)
        const gchar *path = NULL;
        PrefsAccount *account = NULL;
        gboolean no_sub = FALSE, no_select = FALSE, collapsed = FALSE, 
-                threaded = TRUE, ret_rcpt = FALSE;
+                threaded = TRUE, ret_rcpt = FALSE, hidereadmsgs = FALSE;
        gint mtime = 0, new = 0, unread = 0, total = 0;
 
        g_return_val_if_fail(node->data != NULL, FALSE);
@@ -1161,6 +1170,8 @@ static gboolean folder_build_tree(GNode *node, gpointer data)
                        collapsed = *attr->value == '1' ? TRUE : FALSE;
                else if (!strcmp(attr->name, "threaded"))
                        threaded =  *attr->value == '1' ? TRUE : FALSE;
+               else if (!strcmp(attr->name, "hidereadmsgs"))
+                       hidereadmsgs =  *attr->value == '1' ? TRUE : FALSE;
                else if (!strcmp(attr->name, "reqretrcpt"))
                        ret_rcpt =  *attr->value == '1' ? TRUE : FALSE;
        }
@@ -1176,6 +1187,7 @@ static gboolean folder_build_tree(GNode *node, gpointer data)
        item->no_select = no_select;
        item->collapsed = collapsed;
        item->threaded  = threaded;
+       item->hide_read_msgs  = hidereadmsgs;
        item->ret_rcpt  = ret_rcpt;
        item->parent = FOLDER_ITEM(node->parent->data);
        item->folder = folder;
@@ -1342,6 +1354,10 @@ static void folder_write_list_recursive(GNode *node, gpointer data)
                        fputs(" threaded=\"1\"", fp);
                else
                        fputs(" threaded=\"0\"", fp);
+               if (item->hide_read_msgs)
+                       fputs(" hidereadmsgs=\"1\"", fp);
+               else
+                       fputs(" hidereadmsgs=\"0\"", fp);
                if (item->ret_rcpt)
                        fputs(" reqretrcpt=\"1\"", fp);
                fprintf(fp,
@@ -1558,18 +1574,24 @@ static void folder_create_processing_folder(void)
        Folder     *tmpparent;
        FolderItem *tmpfolder;
        gchar      *tmpname;
+       struct stat s;
 
        tmpparent = folder_get_default_folder();
        g_assert(tmpparent);
        debug_print("tmpparentroot %s\n", LOCAL_FOLDER(tmpparent)->rootpath);
-       tmpname = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
-                             LOCAL_FOLDER(tmpparent)->rootpath,
-                             G_DIR_SEPARATOR_S, PROCESSING_FOLDER,
-                             NULL);
+       if (LOCAL_FOLDER(tmpparent)->rootpath[0] == '/')
+               tmpname = g_strconcat(LOCAL_FOLDER(tmpparent)->rootpath,
+                                     G_DIR_SEPARATOR_S, PROCESSING_FOLDER,
+                                     NULL);
+       else
+               tmpname = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
+                                     LOCAL_FOLDER(tmpparent)->rootpath,
+                                     G_DIR_SEPARATOR_S, PROCESSING_FOLDER,
+                                     NULL);
 
        processing_folder = folder_new(F_MH, "PROCESSING", LOCAL_FOLDER(tmpparent)->rootpath);
        g_assert(processing_folder);
-                             
+
        if (!is_dir_exist(tmpname)) {
                debug_print("*TMP* creating %s\n", tmpname);
                processing_folder_item = processing_folder->create_folder(processing_folder,
@@ -1594,3 +1616,88 @@ FolderItem *folder_get_default_processing(void)
        return processing_folder_item;
 }
 
+/* folder_persist_prefs_new() - return hash table with persistent
+ * settings (and folder name as key). 
+ * (note that in claws other options are in the PREFS_FOLDER_ITEM_RC
+ * file, so those don't need to be included in PersistPref yet) 
+ */
+GHashTable *folder_persist_prefs_new(Folder *folder)
+{
+       GHashTable *pptable;
+
+       g_return_val_if_fail(folder, NULL);
+       pptable = g_hash_table_new(g_str_hash, g_str_equal);
+       folder_get_persist_prefs_recursive(folder->node, pptable);
+       return pptable;
+}
+
+void folder_persist_prefs_free(GHashTable *pptable)
+{
+       g_return_if_fail(pptable);
+       g_hash_table_foreach_remove(pptable, persist_prefs_free, NULL);
+       g_hash_table_destroy(pptable);
+}
+
+const PersistPrefs *folder_get_persist_prefs(GHashTable *pptable, const char *name)
+{
+       if (pptable == NULL || name == NULL) return NULL;
+       return g_hash_table_lookup(pptable, name);
+}
+
+void folder_item_restore_persist_prefs(FolderItem *item, GHashTable *pptable)
+{
+       const PersistPrefs *pp;
+
+       pp = folder_get_persist_prefs(pptable, item->path); 
+       if (!pp) return;
+
+       /* CLAWS: since not all folder properties have been migrated to 
+        * folderlist.xml, we need to call the old stuff first before
+        * setting things that apply both to Main and Claws. */
+       prefs_folder_item_read_config(item); 
+        
+       item->collapsed = pp->collapsed;
+       item->threaded  = pp->threaded;
+       item->ret_rcpt  = pp->ret_rcpt;
+       item->hide_read_msgs = pp->hide_read_msgs;
+}
+
+static void folder_get_persist_prefs_recursive(GNode *node, GHashTable *pptable)
+{
+       FolderItem *item = FOLDER_ITEM(node->data);
+       PersistPrefs *pp;
+       GNode *child, *cur;
+
+       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. */
+       if (item->path) {
+               pp = g_new0(PersistPrefs, 1);
+               g_return_if_fail(pp != NULL);
+               pp->collapsed = item->collapsed;
+               pp->threaded  = item->threaded;
+               pp->ret_rcpt  = item->ret_rcpt; 
+               pp->hide_read_msgs = item->hide_read_msgs;
+               g_hash_table_insert(pptable, item->path, pp);
+       }               
+
+       if (node->children) {
+               child = node->children;
+               while (child) {
+                       cur = child;
+                       child = cur->next;
+                       folder_get_persist_prefs_recursive(cur, pptable);
+               }
+       }       
+}
+
+static gboolean persist_prefs_free(gpointer key, gpointer val, gpointer data)
+{
+       if (val) 
+               g_free(val);
+       return TRUE;    
+}
+