src/folder.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2003 Hiroyuki Yamamoto
   4  *
   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 2 of the License, or
   8  * (at your option) any later version.
   9  *
  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.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <unistd.h>
  32 #include <stdlib.h>
  33
  34 #include "intl.h"
  35 #include "folder.h"
  36 #include "session.h"
  37 #include "imap.h"
  38 #include "news.h"
  39 #include "mh.h"
  40 #include "utils.h"
  41 #include "xml.h"
  42 #include "codeconv.h"
  43 #include "prefs_gtk.h"
  44 #include "account.h"
  45 #include "filtering.h"
  46 #include "procheader.h"
  47 #include "hooks.h"
  48 #include "log.h"
  49 #include "folder_item_prefs.h"
  50 #include "remotefolder.h"
  51
  52 /* Dependecies to be removed ?! */
  53 #include "prefs_common.h"
  54 #include "prefs_account.h"
  55
  56 static GList *folder_list = NULL;
  57
  58 void folder_init                (Folder         *folder,
  59                                  const gchar    *name);
  60
  61 static gboolean folder_read_folder_func (GNode          *node,
  62                                          gpointer        data);
  63 static gchar *folder_get_list_path      (void);
  64 static void folder_write_list_recursive (GNode          *node,
  65                                          gpointer        data);
  66 static void folder_update_op_count_rec  (GNode          *node);
  67
  68
  69 static void folder_get_persist_prefs_recursive
  70                                         (GNode *node, GHashTable *pptable);
  71 static gboolean persist_prefs_free      (gpointer key, gpointer val, gpointer data);
  72 void folder_item_read_cache             (FolderItem *item);
  73 void folder_item_free_cache             (FolderItem *item);
  74 gint folder_item_scan_full              (FolderItem *item, gboolean filtering);
  75
  76 static GSList *classlist;
  77
  78 void folder_system_init(void)
  79 {
  80         folder_register_class(mh_get_class());
  81         folder_register_class(imap_get_class());
  82         folder_register_class(news_get_class());
  83 }
  84
  85 GSList *folder_get_class_list(void)
  86 {
  87         return classlist;
  88 }
  89
  90 void folder_register_class(FolderClass *klass)
  91 {
  92         debug_print("registering folder class %s\n", klass->idstr);
  93         classlist = g_slist_append(classlist, klass);
  94 }
  95
  96 Folder *folder_new(FolderClass *klass, const gchar *name, const gchar *path)
  97 {
  98         Folder *folder = NULL;
  99         FolderItem *item;
 100
 101         g_return_val_if_fail(klass != NULL, NULL);
 102
 103         name = name ? name : path;
 104         folder = klass->new_folder(name, path);
 105
 106         /* Create root folder item */
 107         item = folder_item_new(folder, name, NULL);
 108         item->folder = folder;
 109         folder->node = item->node = g_node_new(item);
 110         folder->data = NULL;
 111
 112         return folder;
 113 }
 114
 115 void folder_init(Folder *folder, const gchar *name)
 116 {
 117         g_return_if_fail(folder != NULL);
 118
 119         folder_set_name(folder, name);
 120
 121         /* Init folder data */
 122         folder->account = NULL;
 123         folder->inbox = NULL;
 124         folder->outbox = NULL;
 125         folder->draft = NULL;
 126         folder->queue = NULL;
 127         folder->trash = NULL;
 128 }
 129
 130 void folder_destroy(Folder *folder)
 131 {
 132         g_return_if_fail(folder != NULL);
 133         g_return_if_fail(folder->klass->destroy_folder != NULL);
 134
 135         folder_list = g_list_remove(folder_list, folder);
 136
 137         folder_tree_destroy(folder);
 138
 139         folder->klass->destroy_folder(folder);
 140
 141         g_free(folder->name);
 142         g_free(folder);
 143 }
 144
 145 void folder_set_xml(Folder *folder, XMLTag *tag)
 146 {
 147         GList *cur;
 148
 149         for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
 150                 XMLAttr *attr = (XMLAttr *) cur->data;
 151
 152                 if (!attr || !attr->name || !attr->value) continue;
 153                 if (!strcmp(attr->name, "name")) {
 154                         if (folder->name != NULL)
 155                                 g_free(folder->name);
 156                         folder->name = g_strdup(attr->value);
 157                 } else if (!strcmp(attr->name, "account_id")) {
 158                         PrefsAccount *account;
 159
 160                         account = account_find_from_id(atoi(attr->value));
 161                         if (!account)
 162                                 g_warning("account_id: %s not found\n", attr->value);
 163                         else {
 164                                 folder->account = account;
 165                                 account->folder = folder;
 166                         }
 167                 }
 168         }
 169 }
 170
 171 XMLTag *folder_get_xml(Folder *folder)
 172 {
 173         XMLTag *tag;
 174
 175         tag = g_new0(XMLTag, 1);
 176         tag->tag = g_strdup("folder");
 177
 178         if (folder->name)
 179                 xml_tag_add_attr(tag, "name", g_strdup(folder->name));
 180         if (folder->account)
 181                 xml_tag_add_attr(tag, "account_id", g_strdup_printf("%d", folder->account->account_id));
 182
 183         return tag;
 184 }
 185
 186 FolderItem *folder_item_new(Folder *folder, const gchar *name, const gchar *path)
 187 {
 188         FolderItem *item = NULL;
 189
 190         if (folder->klass->item_new) {
 191                 item = folder->klass->item_new(folder);
 192         } else {
 193                 item = g_new0(FolderItem, 1);
 194         }
 195
 196         g_return_val_if_fail(item != NULL, NULL);
 197
 198         item->stype = F_NORMAL;
 199         item->name = g_strdup(name);
 200         item->path = g_strdup(path);
 201         item->mtime = 0;
 202         item->new_msgs = 0;
 203         item->unread_msgs = 0;
 204         item->unreadmarked_msgs = 0;
 205         item->total_msgs = 0;
 206         item->last_num = -1;
 207         item->cache = NULL;
 208         item->no_sub = FALSE;
 209         item->no_select = FALSE;
 210         item->collapsed = FALSE;
 211         item->thread_collapsed = FALSE;
 212         item->threaded  = TRUE;
 213         item->ret_rcpt  = FALSE;
 214         item->opened    = FALSE;
 215         item->node = NULL;
 216         item->parent = NULL;
 217         item->folder = NULL;
 218         item->account = NULL;
 219         item->apply_sub = FALSE;
 220         item->mark_queue = NULL;
 221         item->data = NULL;
 222
 223         item->prefs = folder_item_prefs_new();
 224
 225         return item;
 226 }
 227
 228 void folder_item_append(FolderItem *parent, FolderItem *item)
 229 {
 230         g_return_if_fail(parent != NULL);
 231         g_return_if_fail(parent->folder != NULL);
 232         g_return_if_fail(parent->node != NULL);
 233         g_return_if_fail(item != NULL);
 234
 235         item->parent = parent;
 236         item->folder = parent->folder;
 237         item->node = g_node_append_data(parent->node, item);
 238 }
 239
 240 static gboolean folder_item_remove_func(GNode *node, gpointer data)
 241 {
 242         FolderItem *item = FOLDER_ITEM(node->data);
 243         FolderUpdateData hookdata;
 244
 245         if (item->cache != NULL) {
 246                 msgcache_destroy(item->cache);
 247                 item->cache = NULL;
 248         }
 249
 250         hookdata.folder = item->folder;
 251         hookdata.update_flags = FOLDER_TREE_CHANGED | FOLDER_REMOVE_FOLDERITEM;
 252         hookdata.item = item;
 253         hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 254
 255         folder_item_destroy(item);
 256
 257         return FALSE;
 258 }
 259
 260 void folder_item_remove(FolderItem *item)
 261 {
 262         GNode *node;
 263
 264         g_return_if_fail(item != NULL);
 265         g_return_if_fail(item->folder != NULL);
 266         g_return_if_fail(item->node != NULL);
 267
 268         node = item->node;
 269
 270         if (item->folder->node == node)
 271                 item->folder->node = NULL;
 272
 273         g_node_traverse(node, G_POST_ORDER, G_TRAVERSE_ALL, -1,
 274                         folder_item_remove_func, NULL);
 275         g_node_destroy(node);
 276 }
 277
 278 void folder_item_remove_children(FolderItem *item)
 279 {
 280         GNode *node, *next;
 281
 282         g_return_if_fail(item != NULL);
 283         g_return_if_fail(item->folder != NULL);
 284         g_return_if_fail(item->node != NULL);
 285
 286         node = item->node->children;
 287         while (node != NULL) {
 288                 next = node->next;
 289                 folder_item_remove(FOLDER_ITEM(node->data));
 290                 node = next;
 291         }
 292 }
 293
 294 void folder_item_destroy(FolderItem *item)
 295 {
 296         Folder *folder;
 297
 298         g_return_if_fail(item != NULL);
 299
 300         folder = item->folder;
 301         if (folder) {
 302                 if (folder->inbox == item)
 303                         folder->inbox = NULL;
 304                 else if (folder->outbox == item)
 305                         folder->outbox = NULL;
 306                 else if (folder->draft == item)
 307                         folder->draft = NULL;
 308                 else if (folder->queue == item)
 309                         folder->queue = NULL;
 310                 else if (folder->trash == item)
 311                         folder->trash = NULL;
 312         }
 313
 314         if (item->cache)
 315                 folder_item_free_cache(item);
 316         if (item->prefs)
 317                 folder_item_prefs_free(item->prefs);
 318         g_free(item->name);
 319         g_free(item->path);
 320
 321         if (item->folder != NULL) {
 322                 if(item->folder->klass->item_destroy) {
 323                         item->folder->klass->item_destroy(item->folder, item);
 324                 } else {
 325                         g_free(item);
 326                 }
 327         }
 328 }
 329
 330 void folder_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag)
 331 {
 332         GList *cur;
 333
 334         for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
 335                 XMLAttr *attr = (XMLAttr *) cur->data;
 336
 337                 if (!attr || !attr->name || !attr->value) continue;
 338                 if (!strcmp(attr->name, "type")) {
 339                         if (!strcasecmp(attr->value, "normal"))
 340                                 item->stype = F_NORMAL;
 341                         else if (!strcasecmp(attr->value, "inbox"))
 342                                 item->stype = F_INBOX;
 343                         else if (!strcasecmp(attr->value, "outbox"))
 344                                 item->stype = F_OUTBOX;
 345                         else if (!strcasecmp(attr->value, "draft"))
 346                                 item->stype = F_DRAFT;
 347                         else if (!strcasecmp(attr->value, "queue"))
 348                                 item->stype = F_QUEUE;
 349                         else if (!strcasecmp(attr->value, "trash"))
 350                                 item->stype = F_TRASH;
 351                 } else if (!strcmp(attr->name, "name")) {
 352                         if (item->name != NULL)
 353                                 g_free(item->name);
 354                         item->name = g_strdup(attr->value);
 355                 } else if (!strcmp(attr->name, "path")) {
 356                         if (item->path != NULL)
 357                                 g_free(item->path);
 358                         item->path = g_strdup(attr->value);
 359                 } else if (!strcmp(attr->name, "mtime"))
 360                         item->mtime = strtoul(attr->value, NULL, 10);
 361                 else if (!strcmp(attr->name, "new"))
 362                         item->new_msgs = atoi(attr->value);
 363                 else if (!strcmp(attr->name, "unread"))
 364                         item->unread_msgs = atoi(attr->value);
 365                 else if (!strcmp(attr->name, "unreadmarked"))
 366                         item->unreadmarked_msgs = atoi(attr->value);
 367                 else if (!strcmp(attr->name, "total"))
 368                         item->total_msgs = atoi(attr->value);
 369                 else if (!strcmp(attr->name, "no_sub"))
 370                         item->no_sub = *attr->value == '1' ? TRUE : FALSE;
 371                 else if (!strcmp(attr->name, "no_select"))
 372                         item->no_select = *attr->value == '1' ? TRUE : FALSE;
 373                 else if (!strcmp(attr->name, "collapsed"))
 374                         item->collapsed = *attr->value == '1' ? TRUE : FALSE;
 375                 else if (!strcmp(attr->name, "thread_collapsed"))
 376                         item->thread_collapsed =  *attr->value == '1' ? TRUE : FALSE;
 377                 else if (!strcmp(attr->name, "threaded"))
 378                         item->threaded =  *attr->value == '1' ? TRUE : FALSE;
 379                 else if (!strcmp(attr->name, "hidereadmsgs"))
 380                         item->hide_read_msgs =  *attr->value == '1' ? TRUE : FALSE;
 381                 else if (!strcmp(attr->name, "reqretrcpt"))
 382                         item->ret_rcpt =  *attr->value == '1' ? TRUE : FALSE;
 383                 else if (!strcmp(attr->name, "sort_key")) {
 384                         if (!strcmp(attr->value, "none"))
 385                                 item->sort_key = SORT_BY_NONE;
 386                         else if (!strcmp(attr->value, "number"))
 387                                 item->sort_key = SORT_BY_NUMBER;
 388                         else if (!strcmp(attr->value, "size"))
 389                                 item->sort_key = SORT_BY_SIZE;
 390                         else if (!strcmp(attr->value, "date"))
 391                                 item->sort_key = SORT_BY_DATE;
 392                         else if (!strcmp(attr->value, "from"))
 393                                 item->sort_key = SORT_BY_FROM;
 394                         else if (!strcmp(attr->value, "subject"))
 395                                 item->sort_key = SORT_BY_SUBJECT;
 396                         else if (!strcmp(attr->value, "score"))
 397                                 item->sort_key = SORT_BY_SCORE;
 398                         else if (!strcmp(attr->value, "label"))
 399                                 item->sort_key = SORT_BY_LABEL;
 400                         else if (!strcmp(attr->value, "mark"))
 401                                 item->sort_key = SORT_BY_MARK;
 402                         else if (!strcmp(attr->value, "unread"))
 403                                 item->sort_key = SORT_BY_STATUS;
 404                         else if (!strcmp(attr->value, "mime"))
 405                                 item->sort_key = SORT_BY_MIME;
 406                         else if (!strcmp(attr->value, "to"))
 407                                 item->sort_key = SORT_BY_TO;
 408                         else if (!strcmp(attr->value, "locked"))
 409                                 item->sort_key = SORT_BY_LOCKED;
 410                 } else if (!strcmp(attr->name, "sort_type")) {
 411                         if (!strcmp(attr->value, "ascending"))
 412                                 item->sort_type = SORT_ASCENDING;
 413                         else
 414                                 item->sort_type = SORT_DESCENDING;
 415                 } else if (!strcmp(attr->name, "account_id")) {
 416                         PrefsAccount *account;
 417
 418                         account = account_find_from_id(atoi(attr->value));
 419                         if (!account)
 420                                 g_warning("account_id: %s not found\n", attr->value);
 421                         else
 422                                 item->account = account;
 423                 } else if (!strcmp(attr->name, "apply_sub"))
 424                         item->apply_sub = *attr->value == '1' ? TRUE : FALSE;
 425         }
 426 }
 427
 428 XMLTag *folder_item_get_xml(Folder *folder, FolderItem *item)
 429 {
 430         static gchar *folder_item_stype_str[] = {"normal", "inbox", "outbox",
 431                                                  "draft", "queue", "trash"};
 432         static gchar *sort_key_str[] = {"none", "number", "size", "date",
 433                                         "from", "subject", "score", "label",
 434                                         "mark", "unread", "mime", "to",
 435                                         "locked"};
 436         XMLTag *tag;
 437
 438         tag = g_new0(XMLTag, 1);
 439         tag->tag = g_strdup("folderitem");
 440
 441         xml_tag_add_attr(tag, "type", g_strdup(folder_item_stype_str[item->stype]));
 442         if (item->name)
 443                 xml_tag_add_attr(tag, "name", g_strdup(item->name));
 444         if (item->path)
 445                 xml_tag_add_attr(tag, "path", g_strdup(item->path));
 446         if (item->no_sub)
 447                 xml_tag_add_attr(tag, "no_sub", g_strdup("1"));
 448         if (item->no_select)
 449                 xml_tag_add_attr(tag, "no_select", g_strdup("1"));
 450         xml_tag_add_attr(tag, "collapsed", g_strdup(item->collapsed && item->node->children ? "1" : "0"));
 451         xml_tag_add_attr(tag, "thread_collapsed", g_strdup(item->thread_collapsed ? "1" : "0"));
 452         xml_tag_add_attr(tag, "threaded", g_strdup(item->threaded ? "1" : "0"));
 453         xml_tag_add_attr(tag, "hidereadmsgs", g_strdup(item->hide_read_msgs ? "1" : "0"));
 454         if (item->ret_rcpt)
 455                 xml_tag_add_attr(tag, "reqretrcpt", g_strdup("1"));
 456
 457         if (item->sort_key != SORT_BY_NONE) {
 458                 xml_tag_add_attr(tag, "sort_key", g_strdup(sort_key_str[item->sort_key]));
 459                 xml_tag_add_attr(tag, "sort_type", g_strdup(item->sort_type == SORT_ASCENDING ? "ascending" : "descending"));
 460         }
 461
 462         xml_tag_add_attr(tag, "mtime", g_strdup_printf("%ld", (unsigned long int) item->mtime));
 463         xml_tag_add_attr(tag, "new", g_strdup_printf("%d", item->new_msgs));
 464         xml_tag_add_attr(tag, "unread", g_strdup_printf("%d", item->unread_msgs));
 465         xml_tag_add_attr(tag, "unreadmarked", g_strdup_printf("%d", item->unreadmarked_msgs));
 466         xml_tag_add_attr(tag, "total", g_strdup_printf("%d", item->total_msgs));
 467
 468         if (item->account)
 469                 xml_tag_add_attr(tag, "account_id", g_strdup_printf("%d", item->account->account_id));
 470         if (item->apply_sub)
 471                 xml_tag_add_attr(tag, "apply_sub", g_strdup("1"));
 472
 473         return tag;
 474 }
 475
 476 void folder_set_ui_func(Folder *folder, FolderUIFunc func, gpointer data)
 477 {
 478         g_return_if_fail(folder != NULL);
 479
 480         folder->ui_func = func;
 481         folder->ui_func_data = data;
 482 }
 483
 484 void folder_set_name(Folder *folder, const gchar *name)
 485 {
 486         g_return_if_fail(folder != NULL);
 487
 488         g_free(folder->name);
 489         folder->name = name ? g_strdup(name) : NULL;
 490         if (folder->node && folder->node->data) {
 491                 FolderItem *item = (FolderItem *)folder->node->data;
 492
 493                 g_free(item->name);
 494                 item->name = name ? g_strdup(name) : NULL;
 495         }
 496 }
 497
 498 gboolean folder_tree_destroy_func(GNode *node, gpointer data) {
 499         FolderItem *item = (FolderItem *) node->data;
 500
 501         folder_item_destroy(item);
 502         return FALSE;
 503 }
 504
 505 void folder_tree_destroy(Folder *folder)
 506 {
 507         GNode *node;
 508
 509         g_return_if_fail(folder != NULL);
 510
 511         node = folder->node;
 512
 513         prefs_filtering_clear_folder(folder);
 514
 515         if (node != NULL) {
 516                 g_node_traverse(node, G_POST_ORDER, G_TRAVERSE_ALL, -1,
 517                                 folder_tree_destroy_func, NULL);
 518                 g_node_destroy(node);
 519                 folder->node = NULL;
 520         }
 521 }
 522
 523 void folder_add(Folder *folder)
 524 {
 525         Folder *cur_folder;
 526         GList *cur;
 527         gint i;
 528
 529         g_return_if_fail(folder != NULL);
 530
 531         for (i = 0, cur = folder_list; cur != NULL; cur = cur->next, i++) {
 532                 cur_folder = FOLDER(cur->data);
 533                 if (FOLDER_TYPE(folder) == F_MH) {
 534                         if (FOLDER_TYPE(cur_folder) != F_MH) break;
 535                 } else if (FOLDER_TYPE(folder) == F_MBOX) {
 536                         if (FOLDER_TYPE(cur_folder) != F_MH &&
 537                             FOLDER_TYPE(cur_folder) != F_MBOX) break;
 538                 } else if (FOLDER_TYPE(folder) == F_IMAP) {
 539                         if (FOLDER_TYPE(cur_folder) != F_MH &&
 540                             FOLDER_TYPE(cur_folder) != F_MBOX &&
 541                             FOLDER_TYPE(cur_folder) != F_IMAP) break;
 542                 } else if (FOLDER_TYPE(folder) == F_NEWS) {
 543                         if (FOLDER_TYPE(cur_folder) != F_MH &&
 544                             FOLDER_TYPE(cur_folder) != F_MBOX &&
 545                             FOLDER_TYPE(cur_folder) != F_IMAP &&
 546                             FOLDER_TYPE(cur_folder) != F_NEWS) break;
 547                 }
 548         }
 549
 550         folder_list = g_list_insert(folder_list, folder, i);
 551 }
 552
 553 GList *folder_get_list(void)
 554 {
 555         return folder_list;
 556 }
 557
 558 gint folder_read_list(void)
 559 {
 560         GNode *node;
 561         XMLNode *xmlnode;
 562         gchar *path;
 563
 564         path = folder_get_list_path();
 565         if (!is_file_exist(path)) return -1;
 566         node = xml_parse_file(path);
 567         if (!node) return -1;
 568
 569         xmlnode = node->data;
 570         if (strcmp2(xmlnode->tag->tag, "folderlist") != 0) {
 571                 g_warning("wrong folder list\n");
 572                 xml_free_tree(node);
 573                 return -1;
 574         }
 575
 576         g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, 2,
 577                         folder_read_folder_func, NULL);
 578
 579         xml_free_tree(node);
 580         if (folder_list)
 581                 return 0;
 582         else
 583                 return -1;
 584 }
 585
 586 void folder_write_list(void)
 587 {
 588         GList *list;
 589         Folder *folder;
 590         gchar *path;
 591         PrefFile *pfile;
 592
 593         path = folder_get_list_path();
 594         if ((pfile = prefs_write_open(path)) == NULL) return;
 595
 596         fprintf(pfile->fp, "<?xml version=\"1.0\" encoding=\"%s\"?>\n",
 597                 conv_get_current_charset_str());
 598         fputs("\n<folderlist>\n", pfile->fp);
 599
 600         for (list = folder_list; list != NULL; list = list->next) {
 601                 folder = list->data;
 602                 folder_write_list_recursive(folder->node, pfile->fp);
 603         }
 604
 605         fputs("</folderlist>\n", pfile->fp);
 606
 607         if (prefs_file_close(pfile) < 0)
 608                 g_warning("failed to write folder list.\n");
 609 }
 610
 611 gboolean folder_scan_tree_func(GNode *node, gpointer data)
 612 {
 613         GHashTable *pptable = (GHashTable *)data;
 614         FolderItem *item = (FolderItem *)node->data;
 615
 616         folder_item_restore_persist_prefs(item, pptable);
 617         folder_item_scan_full(item, FALSE);
 618
 619         return FALSE;
 620 }
 621
 622 void folder_scan_tree(Folder *folder)
 623 {
 624         GHashTable *pptable;
 625         FolderUpdateData hookdata;
 626
 627         if (!folder->klass->scan_tree)
 628                 return;
 629
 630         pptable = folder_persist_prefs_new(folder);
 631
 632         /*
 633          * should be changed and tree update should be done without
 634          * destroying the tree first
 635          */
 636         folder_tree_destroy(folder);
 637         folder->klass->scan_tree(folder);
 638
 639         hookdata.folder = folder;
 640         hookdata.update_flags = FOLDER_TREE_CHANGED;
 641         hookdata.item = NULL;
 642         hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 643
 644         g_node_traverse(folder->node, G_POST_ORDER, G_TRAVERSE_ALL, -1, folder_scan_tree_func, pptable);
 645         folder_persist_prefs_free(pptable);
 646
 647         prefs_matcher_read_config();
 648
 649         folder_write_list();
 650 }
 651
 652 FolderItem *folder_create_folder(FolderItem *parent, const gchar *name)
 653 {
 654         FolderItem *new_item;
 655         FolderUpdateData hookdata;
 656
 657         new_item = parent->folder->klass->create_folder(parent->folder, parent, name);
 658         if (new_item) {
 659                 new_item->cache = msgcache_new();
 660
 661                 hookdata.folder = new_item->folder;
 662                 hookdata.update_flags = FOLDER_TREE_CHANGED | FOLDER_NEW_FOLDERITEM;
 663                 hookdata.item = new_item;
 664                 hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 665         }
 666
 667         return new_item;
 668 }
 669
 670 struct TotalMsgCount
 671 {
 672         guint new_msgs;
 673         guint unread_msgs;
 674         guint unreadmarked_msgs;
 675         guint total_msgs;
 676 };
 677
 678 struct FuncToAllFoldersData
 679 {
 680         FolderItemFunc  function;
 681         gpointer        data;
 682 };
 683
 684 static gboolean folder_func_to_all_folders_func(GNode *node, gpointer data)
 685 {
 686         FolderItem *item;
 687         struct FuncToAllFoldersData *function_data = (struct FuncToAllFoldersData *) data;
 688
 689         g_return_val_if_fail(node->data != NULL, FALSE);
 690
 691         item = FOLDER_ITEM(node->data);
 692         g_return_val_if_fail(item != NULL, FALSE);
 693
 694         function_data->function(item, function_data->data);
 695
 696         return FALSE;
 697 }
 698
 699 void folder_func_to_all_folders(FolderItemFunc function, gpointer data)
 700 {
 701         GList *list;
 702         Folder *folder;
 703         struct FuncToAllFoldersData function_data;
 704
 705         function_data.function = function;
 706         function_data.data = data;
 707
 708         for (list = folder_list; list != NULL; list = list->next) {
 709                 folder = FOLDER(list->data);
 710                 if (folder->node)
 711                         g_node_traverse(folder->node, G_PRE_ORDER,
 712                                         G_TRAVERSE_ALL, -1,
 713                                         folder_func_to_all_folders_func,
 714                                         &function_data);
 715         }
 716 }
 717
 718 static void folder_count_total_msgs_func(FolderItem *item, gpointer data)
 719 {
 720         struct TotalMsgCount *count = (struct TotalMsgCount *)data;
 721
 722         count->new_msgs += item->new_msgs;
 723         count->unread_msgs += item->unread_msgs;
 724         count->unreadmarked_msgs += item->unreadmarked_msgs;
 725         count->total_msgs += item->total_msgs;
 726 }
 727
 728 struct TotalMsgStatus
 729 {
 730         guint new;
 731         guint unread;
 732         guint total;
 733         GString *str;
 734 };
 735
 736 static gboolean folder_get_status_full_all_func(GNode *node, gpointer data)
 737 {
 738         FolderItem *item;
 739         struct TotalMsgStatus *status = (struct TotalMsgStatus *)data;
 740         gchar *id;
 741
 742         g_return_val_if_fail(node->data != NULL, FALSE);
 743
 744         item = FOLDER_ITEM(node->data);
 745
 746         if (!item->path) return FALSE;
 747
 748         status->new += item->new_msgs;
 749         status->unread += item->unread_msgs;
 750         status->total += item->total_msgs;
 751
 752         if (status->str) {
 753                 id = folder_item_get_identifier(item);
 754                 g_string_sprintfa(status->str, "%5d %5d %5d %s\n",
 755                                   item->new_msgs, item->unread_msgs,
 756                                   item->total_msgs, id);
 757                 g_free(id);
 758         }
 759
 760         return FALSE;
 761  }
 762
 763 static void folder_get_status_full_all(GString *str, guint *new, guint *unread,
 764                                        guint *total)
 765 {
 766         GList *list;
 767         Folder *folder;
 768         struct TotalMsgStatus status;
 769
 770         status.new = status.unread = status.total = 0;
 771         status.str = str;
 772
 773         debug_print("Counting total number of messages...\n");
 774
 775         for (list = folder_list; list != NULL; list = list->next) {
 776                 folder = FOLDER(list->data);
 777                 if (folder->node)
 778                         g_node_traverse(folder->node, G_PRE_ORDER,
 779                                         G_TRAVERSE_ALL, -1,
 780                                         folder_get_status_full_all_func,
 781                                         &status);
 782         }
 783
 784         *new = status.new;
 785         *unread = status.unread;
 786         *total = status.total;
 787 }
 788
 789 gchar *folder_get_status(GPtrArray *folders, gboolean full)
 790 {
 791         guint new, unread, total;
 792         GString *str;
 793         gint i;
 794         gchar *ret;
 795
 796         new = unread = total = 0;
 797
 798         str = g_string_new(NULL);
 799
 800         if (folders) {
 801                 for (i = 0; i < folders->len; i++) {
 802                         FolderItem *item;
 803
 804                         item = g_ptr_array_index(folders, i);
 805                         new += item->new_msgs;
 806                         unread += item->unread_msgs;
 807                         total += item->total_msgs;
 808
 809                         if (full) {
 810                                 gchar *id;
 811
 812                                 id = folder_item_get_identifier(item);
 813                                 g_string_sprintfa(str, "%5d %5d %5d %s\n",
 814                                                   item->new_msgs, item->unread_msgs,
 815                                                   item->total_msgs, id);
 816                                 g_free(id);
 817                         }
 818                 }
 819         } else {
 820                 folder_get_status_full_all(full ? str : NULL,
 821                                            &new, &unread, &total);
 822         }
 823
 824         if (full)
 825                 g_string_sprintfa(str, "%5d %5d %5d\n", new, unread, total);
 826         else
 827                 g_string_sprintfa(str, "%d %d %d\n", new, unread, total);
 828
 829         ret = str->str;
 830         g_string_free(str, FALSE);
 831
 832         return ret;
 833 }
 834
 835 void folder_count_total_msgs(guint *new_msgs, guint *unread_msgs, guint *unreadmarked_msgs, guint *total_msgs)
 836 {
 837         struct TotalMsgCount count;
 838
 839         count.new_msgs = count.unread_msgs = count.unreadmarked_msgs = count.total_msgs = 0;
 840
 841         debug_print("Counting total number of messages...\n");
 842
 843         folder_func_to_all_folders(folder_count_total_msgs_func, &count);
 844
 845         *new_msgs = count.new_msgs;
 846         *unread_msgs = count.unread_msgs;
 847         *unreadmarked_msgs = count.unreadmarked_msgs;
 848         *total_msgs = count.total_msgs;
 849 }
 850
 851 Folder *folder_find_from_path(const gchar *path)
 852 {
 853         GList *list;
 854         Folder *folder;
 855
 856         for (list = folder_list; list != NULL; list = list->next) {
 857                 folder = list->data;
 858                 if ((FOLDER_TYPE(folder) == F_MH ||
 859                      FOLDER_TYPE(folder) == F_MBOX) &&
 860                     !path_cmp(LOCAL_FOLDER(folder)->rootpath, path))
 861                         return folder;
 862         }
 863
 864         return NULL;
 865 }
 866
 867 Folder *folder_find_from_name(const gchar *name, FolderClass *klass)
 868 {
 869         GList *list;
 870         Folder *folder;
 871
 872         for (list = folder_list; list != NULL; list = list->next) {
 873                 folder = list->data;
 874                 if (folder->klass == klass &&
 875                     strcmp2(name, folder->name) == 0)
 876                         return folder;
 877         }
 878
 879         return NULL;
 880 }
 881
 882 static gboolean folder_item_find_func(GNode *node, gpointer data)
 883 {
 884         FolderItem *item = node->data;
 885         gpointer *d = data;
 886         const gchar *path = d[0];
 887
 888         if (path_cmp(path, item->path) != 0)
 889                 return FALSE;
 890
 891         d[1] = item;
 892
 893         return TRUE;
 894 }
 895
 896 FolderItem *folder_find_item_from_path(const gchar *path)
 897 {
 898         Folder *folder;
 899         gpointer d[2];
 900
 901         folder = folder_get_default_folder();
 902         g_return_val_if_fail(folder != NULL, NULL);
 903
 904         d[0] = (gpointer)path;
 905         d[1] = NULL;
 906         g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
 907                         folder_item_find_func, d);
 908         return d[1];
 909 }
 910
 911 FolderClass *folder_get_class_from_string(const gchar *str)
 912 {
 913         GSList *classlist;
 914
 915         classlist = folder_get_class_list();
 916         for (; classlist != NULL; classlist = g_slist_next(classlist)) {
 917                 FolderClass *class = (FolderClass *) classlist->data;
 918                 if (g_strcasecmp(class->idstr, str) == 0)
 919                         return class;
 920         }
 921
 922         return NULL;
 923 }
 924
 925 gchar *folder_get_identifier(Folder *folder)
 926 {
 927         gchar *type_str;
 928
 929         g_return_val_if_fail(folder != NULL, NULL);
 930
 931         type_str = folder->klass->idstr;
 932         return g_strconcat("#", type_str, "/", folder->name, NULL);
 933 }
 934
 935 gchar *folder_item_get_identifier(FolderItem *item)
 936 {
 937         gchar *id;
 938         gchar *folder_id;
 939
 940         g_return_val_if_fail(item != NULL, NULL);
 941         g_return_val_if_fail(item->path != NULL, NULL);
 942
 943         folder_id = folder_get_identifier(item->folder);
 944         id = g_strconcat(folder_id, "/", item->path, NULL);
 945         g_free(folder_id);
 946
 947         return id;
 948 }
 949
 950 FolderItem *folder_find_item_from_identifier(const gchar *identifier)
 951 {
 952         Folder *folder;
 953         gpointer d[2];
 954         gchar *str;
 955         gchar *p;
 956         gchar *name;
 957         gchar *path;
 958         FolderClass *class;
 959
 960         g_return_val_if_fail(identifier != NULL, NULL);
 961
 962         if (*identifier != '#')
 963                 return folder_find_item_from_path(identifier);
 964
 965         Xstrdup_a(str, identifier, return NULL);
 966
 967         p = strchr(str, '/');
 968         if (!p)
 969                 return folder_find_item_from_path(identifier);
 970         *p = '\0';
 971         p++;
 972         class = folder_get_class_from_string(&str[1]);
 973         if (class == NULL)
 974                 return folder_find_item_from_path(identifier);
 975
 976         name = p;
 977         p = strchr(p, '/');
 978         if (!p)
 979                 return folder_find_item_from_path(identifier);
 980         *p = '\0';
 981         p++;
 982
 983         folder = folder_find_from_name(name, class);
 984         if (!folder)
 985                 return folder_find_item_from_path(identifier);
 986
 987         path = p;
 988
 989         d[0] = (gpointer)path;
 990         d[1] = NULL;
 991         g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
 992                         folder_item_find_func, d);
 993         return d[1];
 994 }
 995
 996 /**
 997  * Get a displayable name for a FolderItem
 998  *
 999  * \param item FolderItem for that a name should be created
1000  * \return Displayable name for item, returned string has to
1001  *         be freed
1002  */
1003 gchar *folder_item_get_name(FolderItem *item)
1004 {
1005         gchar *name = NULL;
1006
1007         g_return_val_if_fail(item != NULL, g_strdup(""));
1008
1009         switch (item->stype) {
1010         case F_INBOX:
1011                 name = g_strdup(!strcmp2(item->name, INBOX_DIR) ? _("Inbox") :
1012                                 item->name);
1013                 break;
1014         case F_OUTBOX:
1015                 name = g_strdup(!strcmp2(item->name, OUTBOX_DIR) ? _("Sent") :
1016                                 item->name);
1017                 break;
1018         case F_QUEUE:
1019                 name = g_strdup(!strcmp2(item->name, QUEUE_DIR) ? _("Queue") :
1020                                 item->name);
1021                 break;
1022         case F_TRASH:
1023                 name = g_strdup(!strcmp2(item->name, TRASH_DIR) ? _("Trash") :
1024                                 item->name);
1025                 break;
1026         case F_DRAFT:
1027                 name = g_strdup(!strcmp2(item->name, DRAFT_DIR) ? _("Drafts") :
1028                                 item->name);
1029                 break;
1030         default:
1031                 break;
1032         }
1033
1034         if (name == NULL) {
1035                 /*
1036                  * should probably be done by a virtual function,
1037                  * the folder knows the ui string and how to abbrev
1038                 */
1039                 if (!item->parent) {
1040                         name = g_strconcat(item->name, " (", item->folder->klass->uistr, ")", NULL);
1041                 } else {
1042                         if (FOLDER_CLASS(item->folder) == news_get_class() &&
1043                             item->path && !strcmp2(item->name, item->path))
1044                                 name = get_abbrev_newsgroup_name
1045                                         (item->path,
1046                                          prefs_common.ng_abbrev_len);
1047                         else
1048                                 name = g_strdup(item->name);
1049                 }
1050         }
1051
1052         if (name == NULL)
1053                 name = g_strdup("");
1054
1055         return name;
1056 }
1057
1058 Folder *folder_get_default_folder(void)
1059 {
1060         return folder_list ? FOLDER(folder_list->data) : NULL;
1061 }
1062
1063 FolderItem *folder_get_default_inbox(void)
1064 {
1065         Folder *folder;
1066
1067         if (!folder_list) return NULL;
1068         folder = FOLDER(folder_list->data);
1069         g_return_val_if_fail(folder != NULL, NULL);
1070         return folder->inbox;
1071 }
1072
1073 FolderItem *folder_get_default_outbox(void)
1074 {
1075         Folder *folder;
1076
1077         if (!folder_list) return NULL;
1078         folder = FOLDER(folder_list->data);
1079         g_return_val_if_fail(folder != NULL, NULL);
1080         return folder->outbox;
1081 }
1082
1083 FolderItem *folder_get_default_draft(void)
1084 {
1085         Folder *folder;
1086
1087         if (!folder_list) return NULL;
1088         folder = FOLDER(folder_list->data);
1089         g_return_val_if_fail(folder != NULL, NULL);
1090         return folder->draft;
1091 }
1092
1093 FolderItem *folder_get_default_queue(void)
1094 {
1095         Folder *folder;
1096
1097         if (!folder_list) return NULL;
1098         folder = FOLDER(folder_list->data);
1099         g_return_val_if_fail(folder != NULL, NULL);
1100         return folder->queue;
1101 }
1102
1103 FolderItem *folder_get_default_trash(void)
1104 {
1105         Folder *folder;
1106
1107         if (!folder_list) return NULL;
1108         folder = FOLDER(folder_list->data);
1109         g_return_val_if_fail(folder != NULL, NULL);
1110         return folder->trash;
1111 }
1112
1113 #define CREATE_FOLDER_IF_NOT_EXIST(member, dir, type)           \
1114 {                                                               \
1115         if (!folder->member) {                                  \
1116                 item = folder_item_new(folder, dir, dir);       \
1117                 item->stype = type;                             \
1118                 folder_item_append(rootitem, item);             \
1119                 folder->member = item;                          \
1120         }                                                       \
1121 }
1122
1123 void folder_set_missing_folders(void)
1124 {
1125         Folder *folder;
1126         FolderItem *rootitem;
1127         FolderItem *item;
1128         GList *list;
1129
1130         for (list = folder_list; list != NULL; list = list->next) {
1131                 folder = list->data;
1132                 if (FOLDER_TYPE(folder) != F_MH) continue;
1133                 rootitem = FOLDER_ITEM(folder->node->data);
1134                 g_return_if_fail(rootitem != NULL);
1135
1136                 if (folder->inbox && folder->outbox && folder->draft &&
1137                     folder->queue && folder->trash)
1138                         continue;
1139
1140                 if (folder->klass->create_tree(folder) < 0) {
1141                         g_warning("%s: can't create the folder tree.\n",
1142                                   LOCAL_FOLDER(folder)->rootpath);
1143                         continue;
1144                 }
1145
1146                 CREATE_FOLDER_IF_NOT_EXIST(inbox,  INBOX_DIR,  F_INBOX);
1147                 CREATE_FOLDER_IF_NOT_EXIST(outbox, OUTBOX_DIR, F_OUTBOX);
1148                 CREATE_FOLDER_IF_NOT_EXIST(draft,  DRAFT_DIR,  F_DRAFT);
1149                 CREATE_FOLDER_IF_NOT_EXIST(queue,  QUEUE_DIR,  F_QUEUE);
1150                 CREATE_FOLDER_IF_NOT_EXIST(trash,  TRASH_DIR,  F_TRASH);
1151         }
1152 }
1153
1154 static gboolean folder_unref_account_func(GNode *node, gpointer data)
1155 {
1156         FolderItem *item = node->data;
1157         PrefsAccount *account = data;
1158
1159         if (item->account == account)
1160                 item->account = NULL;
1161
1162         return FALSE;
1163 }
1164
1165 void folder_unref_account_all(PrefsAccount *account)
1166 {
1167         Folder *folder;
1168         GList *list;
1169
1170         if (!account) return;
1171
1172         for (list = folder_list; list != NULL; list = list->next) {
1173                 folder = list->data;
1174                 if (folder->account == account)
1175                         folder->account = NULL;
1176                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1177                                 folder_unref_account_func, account);
1178         }
1179 }
1180
1181 #undef CREATE_FOLDER_IF_NOT_EXIST
1182
1183 gchar *folder_item_get_path(FolderItem *item)
1184 {
1185         Folder *folder;
1186
1187         g_return_val_if_fail(item != NULL, NULL);
1188         folder = item->folder;
1189         g_return_val_if_fail(folder != NULL, NULL);
1190
1191         return folder->klass->item_get_path(folder, item);
1192 }
1193
1194 void folder_item_set_default_flags(FolderItem *dest, MsgFlags *flags)
1195 {
1196         if (!(dest->stype == F_OUTBOX ||
1197               dest->stype == F_QUEUE  ||
1198               dest->stype == F_DRAFT  ||
1199               dest->stype == F_TRASH)) {
1200                 flags->perm_flags = MSG_NEW|MSG_UNREAD;
1201         } else {
1202                 flags->perm_flags = 0;
1203         }
1204         flags->tmp_flags = MSG_CACHED;
1205         if (FOLDER_TYPE(dest->folder) == F_MH) {
1206                 if (dest->stype == F_QUEUE) {
1207                         MSG_SET_TMP_FLAGS(*flags, MSG_QUEUED);
1208                 } else if (dest->stype == F_DRAFT) {
1209                         MSG_SET_TMP_FLAGS(*flags, MSG_DRAFT);
1210                 }
1211         }
1212 }
1213
1214 static gint folder_sort_cache_list_by_msgnum(gconstpointer a, gconstpointer b)
1215 {
1216         MsgInfo *msginfo_a = (MsgInfo *) a;
1217         MsgInfo *msginfo_b = (MsgInfo *) b;
1218
1219         return (msginfo_a->msgnum - msginfo_b->msgnum);
1220 }
1221
1222 static gint folder_sort_folder_list(gconstpointer a, gconstpointer b)
1223 {
1224         guint gint_a = GPOINTER_TO_INT(a);
1225         guint gint_b = GPOINTER_TO_INT(b);
1226
1227         return (gint_a - gint_b);
1228 }
1229
1230 gint folder_item_open(FolderItem *item)
1231 {
1232         if((item->folder->klass->scan_required != NULL) && (item->folder->klass->scan_required(item->folder, item))) {
1233                 folder_item_scan_full(item, TRUE);
1234         }
1235
1236         /* Processing */
1237         if(item->prefs->processing != NULL) {
1238                 gchar *buf;
1239
1240                 buf = g_strdup_printf(_("Processing (%s)...\n"), item->path);
1241                 debug_print("%s\n", buf);
1242                 g_free(buf);
1243
1244                 folder_item_apply_processing(item);
1245
1246                 debug_print("done.\n");
1247         }
1248
1249         return 0;
1250 }
1251
1252 gint folder_item_close(FolderItem *item)
1253 {
1254         GSList *mlist, *cur;
1255         Folder *folder;
1256
1257         g_return_val_if_fail(item != NULL, -1);
1258
1259         if (item->new_msgs) {
1260                 folder_item_update_freeze();
1261                 mlist = folder_item_get_msg_list(item);
1262                 for (cur = mlist ; cur != NULL ; cur = cur->next) {
1263                         MsgInfo * msginfo;
1264
1265                         msginfo = (MsgInfo *) cur->data;
1266                         if (MSG_IS_NEW(msginfo->flags))
1267                                 procmsg_msginfo_unset_flags(msginfo, MSG_NEW, 0);
1268                         procmsg_msginfo_free(msginfo);
1269                 }
1270                 g_slist_free(mlist);
1271                 folder_item_update_thaw();
1272         }
1273
1274         folder_item_write_cache(item);
1275
1276         folder_item_update(item, F_ITEM_UPDATE_MSGCNT);
1277
1278         item->opened = FALSE;
1279         folder = item->folder;
1280
1281         if (folder->klass->close == NULL)
1282                 return 0;
1283
1284         return folder->klass->close(folder, item);
1285 }
1286
1287 gint folder_item_scan_full(FolderItem *item, gboolean filtering)
1288 {
1289         Folder *folder;
1290         GSList *folder_list = NULL, *cache_list = NULL;
1291         GSList *folder_list_cur, *cache_list_cur, *new_list = NULL;
1292         GSList *exists_list = NULL, *elem;
1293         GSList *newmsg_list = NULL;
1294         guint newcnt = 0, unreadcnt = 0, totalcnt = 0, unreadmarkedcnt = 0;
1295         guint cache_max_num, folder_max_num, cache_cur_num, folder_cur_num;
1296         gboolean update_flags = 0, old_uids_valid = FALSE;
1297
1298         g_return_val_if_fail(item != NULL, -1);
1299         if (item->path == NULL) return -1;
1300
1301         folder = item->folder;
1302
1303         g_return_val_if_fail(folder != NULL, -1);
1304         g_return_val_if_fail(folder->klass->get_num_list != NULL, -1);
1305
1306         debug_print("Scanning folder %s for cache changes.\n", item->path);
1307
1308         /* Get list of messages for folder and cache */
1309         if (folder->klass->get_num_list(item->folder, item, &folder_list, &old_uids_valid) < 0) {
1310                 debug_print("Error fetching list of message numbers\n");
1311                 return(-1);
1312         }
1313
1314         if (old_uids_valid) {
1315                 if (!item->cache)
1316                         folder_item_read_cache(item);
1317                 cache_list = msgcache_get_msg_list(item->cache);
1318         } else {
1319                 if (item->cache)
1320                         msgcache_destroy(item->cache);
1321                 item->cache = msgcache_new();
1322                 cache_list = NULL;
1323         }
1324
1325         /* Sort both lists */
1326         cache_list = g_slist_sort(cache_list, folder_sort_cache_list_by_msgnum);
1327         folder_list = g_slist_sort(folder_list, folder_sort_folder_list);
1328
1329         cache_list_cur = cache_list;
1330         folder_list_cur = folder_list;
1331
1332         if (cache_list_cur != NULL) {
1333                 GSList *cache_list_last;
1334
1335                 cache_cur_num = ((MsgInfo *)cache_list_cur->data)->msgnum;
1336                 cache_list_last = g_slist_last(cache_list);
1337                 cache_max_num = ((MsgInfo *)cache_list_last->data)->msgnum;
1338         } else {
1339                 cache_cur_num = G_MAXINT;
1340                 cache_max_num = 0;
1341         }
1342
1343         if (folder_list_cur != NULL) {
1344                 GSList *folder_list_last;
1345
1346                 folder_cur_num = GPOINTER_TO_INT(folder_list_cur->data);
1347                 folder_list_last = g_slist_last(folder_list);
1348                 folder_max_num = GPOINTER_TO_INT(folder_list_last->data);
1349         } else {
1350                 folder_cur_num = G_MAXINT;
1351                 folder_max_num = 0;
1352         }
1353
1354         while ((cache_cur_num != G_MAXINT) || (folder_cur_num != G_MAXINT)) {
1355                 /*
1356                  *  Message only exists in the folder
1357                  *  Remember message for fetching
1358                  */
1359                 if (folder_cur_num < cache_cur_num) {
1360                         gboolean add = FALSE;
1361
1362                         switch(FOLDER_TYPE(folder)) {
1363                                 case F_NEWS:
1364                                         if (folder_cur_num < cache_max_num)
1365                                                 break;
1366
1367                                         if (folder->account->max_articles == 0) {
1368                                                 add = TRUE;
1369                                         }
1370
1371                                         if (folder_max_num <= folder->account->max_articles) {
1372                                                 add = TRUE;
1373                                         } else if (folder_cur_num > (folder_max_num - folder->account->max_articles)) {
1374                                                 add = TRUE;
1375                                         }
1376                                         break;
1377                                 default:
1378                                         add = TRUE;
1379                                         break;
1380                         }
1381
1382                         if (add) {
1383                                 new_list = g_slist_prepend(new_list, GINT_TO_POINTER(folder_cur_num));
1384                                 debug_print("Remembered message %d for fetching\n", folder_cur_num);
1385                         }
1386
1387                         /* Move to next folder number */
1388                         folder_list_cur = folder_list_cur->next;
1389
1390                         if (folder_list_cur != NULL)
1391                                 folder_cur_num = GPOINTER_TO_INT(folder_list_cur->data);
1392                         else
1393                                 folder_cur_num = G_MAXINT;
1394
1395                         continue;
1396                 }
1397
1398                 /*
1399                  *  Message only exists in the cache
1400                  *  Remove the message from the cache
1401                  */
1402                 if (cache_cur_num < folder_cur_num) {
1403                         msgcache_remove_msg(item->cache, cache_cur_num);
1404                         debug_print("Removed message %d from cache.\n", cache_cur_num);
1405
1406                         /* Move to next cache number */
1407                         cache_list_cur = cache_list_cur->next;
1408
1409                         if (cache_list_cur != NULL)
1410                                 cache_cur_num = ((MsgInfo *)cache_list_cur->data)->msgnum;
1411                         else
1412                                 cache_cur_num = G_MAXINT;
1413
1414                         update_flags |= F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT;
1415
1416                         continue;
1417                 }
1418
1419                 /*
1420                  *  Message number exists in folder and cache!
1421                  *  Check if the message has been modified
1422                  */
1423                 if (cache_cur_num == folder_cur_num) {
1424                         MsgInfo *msginfo;
1425
1426                         msginfo = msgcache_get_msg(item->cache, folder_cur_num);
1427                         if (folder->klass->is_msg_changed && folder->klass->is_msg_changed(folder, item, msginfo)) {
1428                                 msgcache_remove_msg(item->cache, msginfo->msgnum);
1429                                 new_list = g_slist_prepend(new_list, GINT_TO_POINTER(msginfo->msgnum));
1430                                 procmsg_msginfo_free(msginfo);
1431
1432                                 debug_print("Remembering message %d to update...\n", folder_cur_num);
1433                         } else
1434                                 exists_list = g_slist_prepend(exists_list, msginfo);
1435
1436                         /* Move to next folder and cache number */
1437                         cache_list_cur = cache_list_cur->next;
1438                         folder_list_cur = folder_list_cur->next;
1439
1440                         if (cache_list_cur != NULL)
1441                                 cache_cur_num = ((MsgInfo *)cache_list_cur->data)->msgnum;
1442                         else
1443                                 cache_cur_num = G_MAXINT;
1444
1445                         if (folder_list_cur != NULL)
1446                                 folder_cur_num = GPOINTER_TO_INT(folder_list_cur->data);
1447                         else
1448                                 folder_cur_num = G_MAXINT;
1449
1450                         continue;
1451                 }
1452         }
1453
1454         for(cache_list_cur = cache_list; cache_list_cur != NULL; cache_list_cur = g_slist_next(cache_list_cur))
1455                 procmsg_msginfo_free((MsgInfo *) cache_list_cur->data);
1456
1457         g_slist_free(cache_list);
1458         g_slist_free(folder_list);
1459
1460         if (new_list != NULL) {
1461                 if (folder->klass->get_msginfos) {
1462                         newmsg_list = folder->klass->get_msginfos(folder, item, new_list);
1463                 } else if (folder->klass->get_msginfo) {
1464                         GSList *elem;
1465
1466                         for (elem = new_list; elem != NULL; elem = g_slist_next(elem)) {
1467                                 MsgInfo *msginfo;
1468                                 guint num;
1469
1470                                 num = GPOINTER_TO_INT(elem->data);
1471                                 msginfo = folder->klass->get_msginfo(folder, item, num);
1472                                 if (msginfo != NULL) {
1473                                         newmsg_list = g_slist_prepend(newmsg_list, msginfo);
1474                                         debug_print("Added newly found message %d to cache.\n", num);
1475                                 }
1476                         }
1477                 }
1478                 g_slist_free(new_list);
1479         }
1480
1481         folder_item_update_freeze();
1482         if (newmsg_list != NULL) {
1483                 GSList *elem;
1484
1485                 for (elem = newmsg_list; elem != NULL; elem = g_slist_next(elem)) {
1486                         MsgInfo *msginfo = (MsgInfo *) elem->data;
1487
1488                         msgcache_add_msg(item->cache, msginfo);
1489                         if ((filtering == TRUE) &&
1490                             (item->stype == F_INBOX) &&
1491                             (item->folder->account != NULL) &&
1492                             (item->folder->account->filter_on_recv) &&
1493                             procmsg_msginfo_filter(msginfo))
1494                                 procmsg_msginfo_free(msginfo);
1495                         else
1496                                 exists_list = g_slist_prepend(exists_list, msginfo);
1497                 }
1498                 g_slist_free(newmsg_list);
1499
1500                 update_flags |= F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT;
1501         }
1502
1503         for (elem = exists_list; elem != NULL; elem = g_slist_next(elem)) {
1504                 MsgInfo *msginfo;
1505
1506                 msginfo = elem->data;
1507                 if (MSG_IS_IGNORE_THREAD(msginfo->flags) && (MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags)))
1508                         procmsg_msginfo_unset_flags(msginfo, MSG_NEW | MSG_UNREAD, 0);
1509                 if (!MSG_IS_IGNORE_THREAD(msginfo->flags) && procmsg_msg_has_flagged_parent(msginfo, MSG_IGNORE_THREAD)) {
1510                         procmsg_msginfo_unset_flags(msginfo, MSG_NEW | MSG_UNREAD, 0);
1511                         procmsg_msginfo_set_flags(msginfo, MSG_IGNORE_THREAD, 0);
1512                 }
1513                 if ((item->stype == F_OUTBOX ||
1514                      item->stype == F_QUEUE  ||
1515                      item->stype == F_DRAFT  ||
1516                      item->stype == F_TRASH) &&
1517                     (MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags)))
1518                         procmsg_msginfo_unset_flags(msginfo, MSG_NEW | MSG_UNREAD, 0);
1519                 if (MSG_IS_NEW(msginfo->flags))
1520                         newcnt++;
1521                 if (MSG_IS_UNREAD(msginfo->flags))
1522                         unreadcnt++;
1523                 if (MSG_IS_UNREAD(msginfo->flags) && procmsg_msg_has_marked_parent(msginfo))
1524                         unreadmarkedcnt++;
1525                 totalcnt++;
1526
1527                 procmsg_msginfo_free(msginfo);
1528         }
1529         g_slist_free(exists_list);
1530
1531         item->new_msgs = newcnt;
1532         item->unread_msgs = unreadcnt;
1533         item->total_msgs = totalcnt;
1534         item->unreadmarked_msgs = unreadmarkedcnt;
1535
1536         update_flags |= F_ITEM_UPDATE_MSGCNT;
1537
1538         folder_item_update(item, update_flags);
1539         folder_item_update_thaw();
1540
1541         return 0;
1542 }
1543
1544 gint folder_item_scan(FolderItem *item)
1545 {
1546         return folder_item_scan_full(item, TRUE);
1547 }
1548
1549 static gboolean folder_scan_all_items_func(GNode *node, gpointer data)
1550 {
1551         FolderItem *item = node->data;
1552
1553         folder_item_scan(item);
1554
1555         return FALSE;
1556 }
1557
1558 void folder_scan_all_items(Folder * folder)
1559 {
1560         g_node_traverse(folder->node, G_PRE_ORDER,
1561                         G_TRAVERSE_ALL, -1, folder_scan_all_items_func, NULL);
1562 }
1563
1564 static void folder_item_scan_foreach_func(gpointer key, gpointer val,
1565                                           gpointer data)
1566 {
1567         folder_item_scan(FOLDER_ITEM(key));
1568 }
1569
1570 void folder_item_scan_foreach(GHashTable *table)
1571 {
1572         g_hash_table_foreach(table, folder_item_scan_foreach_func, NULL);
1573 }
1574
1575 void folder_count_total_cache_memusage(FolderItem *item, gpointer data)
1576 {
1577         gint *memusage = (gint *)data;
1578
1579         if (item->cache == NULL)
1580                 return;
1581
1582         *memusage += msgcache_get_memory_usage(item->cache);
1583 }
1584
1585 gint folder_cache_time_compare_func(gconstpointer a, gconstpointer b)
1586 {
1587         FolderItem *fa = (FolderItem *)a;
1588         FolderItem *fb = (FolderItem *)b;
1589
1590         return (gint) (msgcache_get_last_access_time(fa->cache) - msgcache_get_last_access_time(fb->cache));
1591 }
1592
1593 void folder_find_expired_caches(FolderItem *item, gpointer data)
1594 {
1595         GSList **folder_item_list = (GSList **)data;
1596         gint difftime, expiretime;
1597
1598         if (item->cache == NULL)
1599                 return;
1600
1601         if (item->opened > 0)
1602                 return;
1603
1604         difftime = (gint) (time(NULL) - msgcache_get_last_access_time(item->cache));
1605         expiretime = prefs_common.cache_min_keep_time * 60;
1606         debug_print("Cache unused time: %d (Expire time: %d)\n", difftime, expiretime);
1607         if (difftime > expiretime) {
1608                 *folder_item_list = g_slist_insert_sorted(*folder_item_list, item, folder_cache_time_compare_func);
1609         }
1610 }
1611
1612 void folder_item_free_cache(FolderItem *item)
1613 {
1614         g_return_if_fail(item != NULL);
1615
1616         if (item->cache == NULL)
1617                 return;
1618
1619         if (item->opened > 0)
1620                 return;
1621
1622         folder_item_write_cache(item);
1623         msgcache_destroy(item->cache);
1624         item->cache = NULL;
1625 }
1626
1627 void folder_clean_cache_memory(void)
1628 {
1629         gint memusage = 0;
1630
1631         folder_func_to_all_folders(folder_count_total_cache_memusage, &memusage);
1632         debug_print("Total cache memory usage: %d\n", memusage);
1633
1634         if (memusage > (prefs_common.cache_max_mem_usage * 1024)) {
1635                 GSList *folder_item_list = NULL, *listitem;
1636
1637                 debug_print("Trying to free cache memory\n");
1638
1639                 folder_func_to_all_folders(folder_find_expired_caches, &folder_item_list);
1640                 listitem = folder_item_list;
1641                 while((listitem != NULL) && (memusage > (prefs_common.cache_max_mem_usage * 1024))) {
1642                         FolderItem *item = (FolderItem *)(listitem->data);
1643
1644                         debug_print("Freeing cache memory for %s\n", item->path);
1645                         memusage -= msgcache_get_memory_usage(item->cache);
1646                         folder_item_free_cache(item);
1647                         listitem = listitem->next;
1648                 }
1649                 g_slist_free(folder_item_list);
1650         }
1651 }
1652
1653 void folder_item_read_cache(FolderItem *item)
1654 {
1655         gchar *cache_file, *mark_file;
1656
1657         g_return_if_fail(item != NULL);
1658
1659         cache_file = folder_item_get_cache_file(item);
1660         mark_file = folder_item_get_mark_file(item);
1661         item->cache = msgcache_read_cache(item, cache_file);
1662         if (!item->cache) {
1663                 item->cache = msgcache_new();
1664                 folder_item_scan_full(item, TRUE);
1665         }
1666         msgcache_read_mark(item->cache, mark_file);
1667         g_free(cache_file);
1668         g_free(mark_file);
1669
1670         folder_clean_cache_memory();
1671 }
1672
1673 void folder_item_write_cache(FolderItem *item)
1674 {
1675         gchar *cache_file, *mark_file;
1676         FolderItemPrefs *prefs;
1677         gint filemode = 0;
1678         gchar *id;
1679
1680         if (!item || !item->path || !item->cache)
1681                 return;
1682
1683         id = folder_item_get_identifier(item);
1684         debug_print("Save cache for folder %s\n", id);
1685         g_free(id);
1686
1687         cache_file = folder_item_get_cache_file(item);
1688         mark_file = folder_item_get_mark_file(item);
1689         if (msgcache_write(cache_file, mark_file, item->cache) < 0) {
1690                 prefs = item->prefs;
1691                 if (prefs && prefs->enable_folder_chmod && prefs->folder_chmod) {
1692                         /* for cache file */
1693                         filemode = prefs->folder_chmod;
1694                         if (filemode & S_IRGRP) filemode |= S_IWGRP;
1695                         if (filemode & S_IROTH) filemode |= S_IWOTH;
1696                         chmod(cache_file, filemode);
1697                 }
1698         }
1699
1700         g_free(cache_file);
1701         g_free(mark_file);
1702 }
1703
1704 MsgInfo *folder_item_get_msginfo(FolderItem *item, gint num)
1705 {
1706         Folder *folder;
1707         MsgInfo *msginfo;
1708
1709         g_return_val_if_fail(item != NULL, NULL);
1710
1711         folder = item->folder;
1712         if (!item->cache)
1713                 folder_item_read_cache(item);
1714
1715         if ((msginfo = msgcache_get_msg(item->cache, num)) != NULL)
1716                 return msginfo;
1717
1718         g_return_val_if_fail(folder->klass->get_msginfo, NULL);
1719         if ((msginfo = folder->klass->get_msginfo(folder, item, num)) != NULL) {
1720                 msgcache_add_msg(item->cache, msginfo);
1721                 return msginfo;
1722         }
1723
1724         return NULL;
1725 }
1726
1727 MsgInfo *folder_item_get_msginfo_by_msgid(FolderItem *item, const gchar *msgid)
1728 {
1729         Folder *folder;
1730         MsgInfo *msginfo;
1731
1732         g_return_val_if_fail(item != NULL, NULL);
1733         g_return_val_if_fail(msgid != NULL, NULL);
1734
1735         folder = item->folder;
1736         if (!item->cache)
1737                 folder_item_read_cache(item);
1738
1739         if ((msginfo = msgcache_get_msg_by_id(item->cache, msgid)) != NULL)
1740                 return msginfo;
1741
1742         return NULL;
1743 }
1744
1745 GSList *folder_item_get_msg_list(FolderItem *item)
1746 {
1747         g_return_val_if_fail(item != NULL, NULL);
1748
1749         if (item->cache == 0)
1750                 folder_item_read_cache(item);
1751
1752         g_return_val_if_fail(item->cache != NULL, NULL);
1753
1754         return msgcache_get_msg_list(item->cache);
1755 }
1756
1757 gchar *folder_item_fetch_msg(FolderItem *item, gint num)
1758 {
1759         Folder *folder;
1760
1761         g_return_val_if_fail(item != NULL, NULL);
1762
1763         folder = item->folder;
1764
1765         g_return_val_if_fail(folder->klass->fetch_msg != NULL, NULL);
1766
1767         return folder->klass->fetch_msg(folder, item, num);
1768 }
1769
1770 static gint folder_item_get_msg_num_by_file(FolderItem *dest, const gchar *file)
1771 {
1772         static HeaderEntry hentry[] = {{"Message-ID:",  NULL, TRUE},
1773                                        {NULL,           NULL, FALSE}};
1774         FILE *fp;
1775         MsgInfo *msginfo;
1776         gint msgnum = 0;
1777         gchar buf[BUFFSIZE];
1778
1779         if ((fp = fopen(file, "rb")) == NULL)
1780                 return 0;
1781
1782         if ((dest->stype == F_QUEUE) || (dest->stype == F_DRAFT))
1783                 while (fgets(buf, sizeof(buf), fp) != NULL)
1784                         if (buf[0] == '\r' || buf[0] == '\n') break;
1785
1786         procheader_get_header_fields(fp, hentry);
1787         if (hentry[0].body) {
1788                 extract_parenthesis(hentry[0].body, '<', '>');
1789                 remove_space(hentry[0].body);
1790                 if ((msginfo = msgcache_get_msg_by_id(dest->cache, hentry[0].body)) != NULL) {
1791                         msgnum = msginfo->msgnum;
1792                         procmsg_msginfo_free(msginfo);
1793
1794                         debug_print("found message as uid %d\n", msgnum);
1795                 }
1796         }
1797
1798         g_free(hentry[0].body);
1799         hentry[0].body = NULL;
1800         fclose(fp);
1801
1802         return msgnum;
1803 }
1804
1805 static void copy_msginfo_flags(MsgInfo *source, MsgInfo *dest)
1806 {
1807         MsgPermFlags perm_flags = 0;
1808         MsgTmpFlags tmp_flags = 0;
1809
1810         /* create new flags */
1811         if (source != NULL) {
1812                 /* copy original flags */
1813                 perm_flags = source->flags.perm_flags;
1814                 tmp_flags = source->flags.tmp_flags;
1815         } else {
1816                 perm_flags = dest->flags.perm_flags;
1817                 tmp_flags = dest->flags.tmp_flags;
1818         }
1819
1820         /* remove new, unread and deleted in special folders */
1821         if (dest->folder->stype == F_OUTBOX ||
1822             dest->folder->stype == F_QUEUE  ||
1823             dest->folder->stype == F_DRAFT  ||
1824             dest->folder->stype == F_TRASH)
1825                 perm_flags &= ~(MSG_NEW | MSG_UNREAD | MSG_DELETED);
1826
1827         /* set ignore flag of ignored parent exists */
1828         if (procmsg_msg_has_flagged_parent(dest, MSG_IGNORE_THREAD))
1829                 perm_flags |= MSG_IGNORE_THREAD;
1830
1831         /* Unset tmp flags that should not be copied */
1832         tmp_flags &= ~(MSG_MOVE | MSG_COPY);
1833
1834         /* unset flags that are set but should not */
1835         procmsg_msginfo_unset_flags(dest,
1836                                     dest->flags.perm_flags & ~perm_flags,
1837                                     dest->flags.tmp_flags  & ~tmp_flags);
1838         /* set new flags */
1839         procmsg_msginfo_set_flags(dest,
1840                                   ~dest->flags.perm_flags & perm_flags,
1841                                   ~dest->flags.tmp_flags  & tmp_flags);
1842 }
1843
1844 static void add_msginfo_to_cache(FolderItem *item, MsgInfo *newmsginfo, MsgInfo *flagsource)
1845 {
1846         /* update folder stats */
1847         if (MSG_IS_NEW(newmsginfo->flags))
1848                 item->new_msgs++;
1849         if (MSG_IS_UNREAD(newmsginfo->flags))
1850                 item->unread_msgs++;
1851         if (MSG_IS_UNREAD(newmsginfo->flags) && procmsg_msg_has_marked_parent(newmsginfo))
1852                 item->unreadmarked_msgs++;
1853         item->total_msgs++;
1854
1855         folder_item_update_freeze();
1856         msgcache_add_msg(item->cache, newmsginfo);
1857         copy_msginfo_flags(flagsource, newmsginfo);
1858         folder_item_update(item, F_ITEM_UPDATE_CONTENT);
1859         folder_item_update_thaw();
1860 }
1861
1862 static void remove_msginfo_from_cache(FolderItem *item, MsgInfo *msginfo)
1863 {
1864         MsgInfoUpdate msginfo_update;
1865
1866         if (!item->cache)
1867                 folder_item_read_cache(item);
1868
1869         if (MSG_IS_NEW(msginfo->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags))
1870                 msginfo->folder->new_msgs--;
1871         if (MSG_IS_UNREAD(msginfo->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags))
1872                 msginfo->folder->unread_msgs--;
1873         if (MSG_IS_UNREAD(msginfo->flags) && procmsg_msg_has_marked_parent(msginfo))
1874                 msginfo->folder->unreadmarked_msgs--;
1875         msginfo->folder->total_msgs--;
1876
1877         msginfo_update.msginfo = msginfo;
1878         msginfo_update.flags = MSGINFO_UPDATE_DELETED;
1879         hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
1880
1881         msgcache_remove_msg(item->cache, msginfo->msgnum);
1882         folder_item_update(msginfo->folder, F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT);
1883 }
1884
1885 gint folder_item_add_msg(FolderItem *dest, const gchar *file,
1886                          MsgFlags *flags, gboolean remove_source)
1887 {
1888         GSList file_list;
1889         MsgFileInfo fileinfo;
1890
1891         g_return_val_if_fail(dest != NULL, -1);
1892         g_return_val_if_fail(file != NULL, -1);
1893
1894         fileinfo.msginfo = NULL;
1895         fileinfo.file = (gchar *)file;
1896         fileinfo.flags = flags;
1897         file_list.data = &fileinfo;
1898         file_list.next = NULL;
1899
1900         return folder_item_add_msgs(dest, &file_list, remove_source);
1901 }
1902
1903 gint folder_item_add_msgs(FolderItem *dest, GSList *file_list,
1904                           gboolean remove_source)
1905 {
1906         Folder *folder;
1907         gint ret, num, lastnum = -1;
1908         GSList *file_cur;
1909         GRelation *relation;
1910         MsgFileInfo *fileinfo = NULL;
1911         gboolean folderscan = FALSE;
1912
1913         g_return_val_if_fail(dest != NULL, -1);
1914         g_return_val_if_fail(file_list != NULL, -1);
1915         g_return_val_if_fail(dest->folder != NULL, -1);
1916
1917         folder = dest->folder;
1918
1919         relation = g_relation_new(2);
1920         g_relation_index(relation, 0, g_direct_hash, g_direct_equal);
1921
1922         if (folder->klass->add_msgs != NULL) {
1923                 ret = folder->klass->add_msgs(folder, dest, file_list, relation);
1924                 if (ret < 0) {
1925                         g_relation_destroy(relation);
1926                         return ret;
1927                 }
1928         } else {
1929                 for (file_cur = file_list; file_cur != NULL; file_cur = g_slist_next(file_cur)) {
1930                         fileinfo = (MsgFileInfo *) file_cur->data;
1931
1932                         ret = folder->klass->add_msg(folder, dest, fileinfo->file, fileinfo->flags);
1933                         if (ret < 0) {
1934                                 g_relation_destroy(relation);
1935                                 return ret;
1936                         }
1937                         g_relation_insert(relation, fileinfo, GINT_TO_POINTER(ret));
1938                 }
1939         }
1940
1941         for (file_cur = file_list; file_cur != NULL; file_cur = g_slist_next(file_cur)) {
1942                 GTuples *tuples;
1943
1944                 fileinfo = (MsgFileInfo *) file_cur->data;
1945                 tuples = g_relation_select(relation, fileinfo, 0);
1946                 num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
1947                 g_tuples_destroy(tuples);
1948
1949                 if (num >= 0) {
1950                         MsgInfo *newmsginfo;
1951
1952                         if (num == 0) {
1953                                 if (!folderscan) {
1954                                         folder_item_scan_full(dest, FALSE);
1955                                         folderscan = TRUE;
1956                                 }
1957                                 num = folder_item_get_msg_num_by_file(dest, fileinfo->file);
1958                         }
1959
1960                         if (num > lastnum)
1961                                 lastnum = num;
1962
1963                         if (num >= 0 && remove_source) {
1964                                 if (unlink(fileinfo->file) < 0)
1965                                         FILE_OP_ERROR(fileinfo->file, "unlink");
1966                         }
1967
1968                         if (num == 0)
1969                                 continue;
1970
1971                         if (!folderscan &&
1972                             ((newmsginfo = folder->klass->get_msginfo(folder, dest, num)) != NULL)) {
1973                                 add_msginfo_to_cache(dest, newmsginfo, NULL);
1974                                 procmsg_msginfo_free(newmsginfo);
1975                         } else if ((newmsginfo = msgcache_get_msg(dest->cache, num)) != NULL) {
1976                                 /* TODO: set default flags */
1977                                 procmsg_msginfo_free(newmsginfo);
1978                         }
1979                 }
1980         }
1981
1982         g_relation_destroy(relation);
1983
1984         return lastnum;
1985 }
1986
1987 /*
1988 gint folder_item_move_msg(FolderItem *dest, MsgInfo *msginfo)
1989 {
1990         Folder *folder;
1991         gint num;
1992
1993         g_return_val_if_fail(dest != NULL, -1);
1994         g_return_val_if_fail(msginfo != NULL, -1);
1995
1996         folder = dest->folder;
1997         if (dest->last_num < 0) folder->scan(folder, dest);
1998
1999         num = folder->move_msg(folder, dest, msginfo);
2000         if (num > 0) dest->last_num = num;
2001
2002         return num;
2003 }
2004 */
2005
2006 FolderItem *folder_item_move_recursive(FolderItem *src, FolderItem *dest)
2007 {
2008         GSList *mlist;
2009         FolderItem *new_item;
2010         FolderItem *next_item;
2011         GNode *srcnode;
2012         gchar *old_id, *new_id;
2013
2014         mlist = folder_item_get_msg_list(src);
2015
2016         /* move messages */
2017         debug_print("Moving %s to %s\n", src->path, dest->path);
2018         new_item = folder_create_folder(dest, g_basename(src->path));
2019         if (new_item == NULL) {
2020                 printf("Can't create folder\n");
2021                 return NULL;
2022         }
2023
2024         if (new_item->folder == NULL)
2025                 new_item->folder = dest->folder;
2026
2027         /* move messages */
2028         log_message(_("Moving %s to %s...\n"),
2029                         src->name, new_item->path);
2030         folder_item_move_msgs(new_item, mlist);
2031
2032         /*copy prefs*/
2033         folder_item_prefs_copy_prefs(src, new_item);
2034         new_item->collapsed = src->collapsed;
2035         new_item->thread_collapsed = src->thread_collapsed;
2036         new_item->threaded  = src->threaded;
2037         new_item->ret_rcpt  = src->ret_rcpt;
2038         new_item->hide_read_msgs = src->hide_read_msgs;
2039         new_item->sort_key  = src->sort_key;
2040         new_item->sort_type = src->sort_type;
2041
2042         prefs_matcher_write_config();
2043
2044         /* recurse */
2045         srcnode = src->folder->node;
2046         srcnode = g_node_find(srcnode, G_PRE_ORDER, G_TRAVERSE_ALL, src);
2047         srcnode = srcnode->children;
2048         while (srcnode != NULL) {
2049                 if (srcnode && srcnode->data) {
2050                         next_item = (FolderItem*) srcnode->data;
2051                         srcnode = srcnode->next;
2052                         if (folder_item_move_recursive(next_item, new_item) == NULL)
2053                                 return NULL;
2054                 }
2055         }
2056         old_id = folder_item_get_identifier(src);
2057         new_id = folder_item_get_identifier(new_item);
2058         debug_print("updating rules : %s => %s\n", old_id, new_id);
2059
2060         src->folder->klass->remove_folder(src->folder, src);
2061         folder_write_list();
2062
2063         if (old_id != NULL && new_id != NULL)
2064                 prefs_filtering_rename_path(old_id, new_id);
2065         g_free(old_id);
2066         g_free(new_id);
2067
2068         return new_item;
2069 }
2070
2071 gint folder_item_move_to(FolderItem *src, FolderItem *dest, FolderItem **new_item)
2072 {
2073         FolderItem *tmp = dest->parent;
2074         gchar * src_identifier, * dst_identifier;
2075         gchar * phys_srcpath, * phys_dstpath;
2076
2077         while (tmp) {
2078                 if (tmp == src) {
2079                         return F_MOVE_FAILED_DEST_IS_CHILD;
2080                 }
2081                 tmp = tmp->parent;
2082         }
2083
2084         tmp = src->parent;
2085
2086         src_identifier = folder_item_get_identifier(src);
2087         dst_identifier = folder_item_get_identifier(dest);
2088
2089         if(dst_identifier == NULL && dest->folder && dest->parent == NULL) {
2090                 /* dest can be a root folder */
2091                 dst_identifier = folder_get_identifier(dest->folder);
2092         }
2093         if (src_identifier == NULL || dst_identifier == NULL) {
2094                 debug_print("Can't get identifiers\n");
2095                 return F_MOVE_FAILED;
2096         }
2097
2098         if (src->folder != dest->folder) {
2099                 return F_MOVE_FAILED_DEST_OUTSIDE_MAILBOX;
2100         }
2101
2102         phys_srcpath = folder_item_get_path(src);
2103         phys_dstpath = g_strconcat(folder_item_get_path(dest),G_DIR_SEPARATOR_S,g_basename(phys_srcpath),NULL);
2104
2105         if (src->parent == dest || src == dest) {
2106                 g_free(src_identifier);
2107                 g_free(dst_identifier);
2108                 g_free(phys_srcpath);
2109                 g_free(phys_dstpath);
2110                 return F_MOVE_FAILED_DEST_IS_PARENT;
2111         }
2112         debug_print("moving \"%s\" to \"%s\"\n", phys_srcpath, phys_dstpath);
2113         if ((tmp = folder_item_move_recursive(src, dest)) == NULL) {
2114                 return F_MOVE_FAILED;
2115         }
2116
2117         g_free(src_identifier);
2118         g_free(dst_identifier);
2119         g_free(phys_srcpath);
2120         g_free(phys_dstpath);
2121
2122         *new_item = tmp;
2123
2124         return F_MOVE_OK;
2125 }
2126
2127 /**
2128  * Copy a list of message to a new folder and remove
2129  * source messages if wanted
2130  */
2131 static gint do_copy_msgs(FolderItem *dest, GSList *msglist, gboolean remove_source)
2132 {
2133         Folder *folder;
2134         GSList *l;
2135         gint num, lastnum = -1;
2136         gboolean folderscan = FALSE;
2137         GRelation *relation;
2138
2139         g_return_val_if_fail(dest != NULL, -1);
2140         g_return_val_if_fail(msglist != NULL, -1);
2141
2142         folder = dest->folder;
2143
2144         g_return_val_if_fail(folder->klass->copy_msg != NULL, -1);
2145
2146         relation = g_relation_new(2);
2147         g_relation_index(relation, 0, g_direct_hash, g_direct_equal);
2148         g_relation_index(relation, 1, g_direct_hash, g_direct_equal);
2149
2150         /*
2151          * Copy messages to destination folder and
2152          * store new message numbers in newmsgnums
2153          */
2154         if (folder->klass->copy_msgs != NULL) {
2155                 if (folder->klass->copy_msgs(folder, dest, msglist, relation) < 0) {
2156                         g_relation_destroy(relation);
2157                         return -1;
2158                 }
2159         } else {
2160                 for (l = msglist ; l != NULL ; l = g_slist_next(l)) {
2161                         MsgInfo * msginfo = (MsgInfo *) l->data;
2162
2163                         num = folder->klass->copy_msg(folder, dest, msginfo);
2164                         g_relation_insert(relation, msginfo, GINT_TO_POINTER(num));
2165                 }
2166         }
2167
2168         /* Read cache for dest folder */
2169         if (!dest->cache) folder_item_read_cache(dest);
2170
2171         /*
2172          * Fetch new MsgInfos for new messages in dest folder,
2173          * add them to the msgcache and update folder message counts
2174          */
2175         if (g_relation_count(relation, GINT_TO_POINTER(0), 1) > 0) {
2176                 folder_item_scan_full(dest, FALSE);
2177                 folderscan = TRUE;
2178         }
2179
2180         for (l = msglist; l != NULL; l = g_slist_next(l)) {
2181                 MsgInfo *msginfo = (MsgInfo *) l->data;
2182                 GTuples *tuples;
2183
2184                 tuples = g_relation_select(relation, msginfo, 0);
2185                 num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
2186                 g_tuples_destroy(tuples);
2187
2188                 if (num >= 0) {
2189                         MsgInfo *newmsginfo;
2190
2191                         if (folderscan) {
2192                                 if (msginfo->msgid != NULL) {
2193                                         newmsginfo = folder_item_get_msginfo_by_msgid(dest, msginfo->msgid);
2194                                         if (newmsginfo != NULL) {
2195                                                 copy_msginfo_flags(msginfo, newmsginfo);
2196                                                 num = newmsginfo->msgnum;
2197                                                 procmsg_msginfo_free(newmsginfo);
2198                                         }
2199                                 }
2200                         } else {
2201                                 newmsginfo = folder->klass->get_msginfo(folder, dest, num);
2202                                 if (newmsginfo != NULL) {
2203                                         add_msginfo_to_cache(dest, newmsginfo, msginfo);
2204                                         procmsg_msginfo_free(newmsginfo);
2205                                 }
2206                         }
2207
2208                         if (num > lastnum)
2209                                 lastnum = num;
2210                 }
2211         }
2212
2213         if (remove_source) {
2214                 /*
2215                  * Remove source messages from their folders if
2216                  * copying was successfull and update folder
2217                  * message counts
2218                  */
2219                 for (l = msglist; l != NULL; l = g_slist_next(l)) {
2220                         MsgInfo *msginfo = (MsgInfo *) l->data;
2221                         FolderItem *item = msginfo->folder;
2222                         GTuples *tuples;
2223
2224                         tuples = g_relation_select(relation, msginfo, 0);
2225                         num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
2226                         g_tuples_destroy(tuples);
2227
2228                         if ((num >= 0) && (item->folder->klass->remove_msg != NULL)) {
2229                                 item->folder->klass->remove_msg(item->folder,
2230                                                                 msginfo->folder,
2231                                                                 msginfo->msgnum);
2232                                 remove_msginfo_from_cache(item, msginfo);
2233                         }
2234                 }
2235         }
2236
2237         if (folder->klass->finished_copy)
2238                 folder->klass->finished_copy(folder, dest);
2239
2240         g_relation_destroy(relation);
2241         return lastnum;
2242 }
2243
2244 /**
2245  * Move a message to a new folder.
2246  *
2247  * \param dest Destination folder
2248  * \param msginfo The message
2249  */
2250 gint folder_item_move_msg(FolderItem *dest, MsgInfo *msginfo)
2251 {
2252         GSList list;
2253
2254         g_return_val_if_fail(dest != NULL, -1);
2255         g_return_val_if_fail(msginfo != NULL, -1);
2256
2257         list.data = msginfo;
2258         list.next = NULL;
2259
2260         return do_copy_msgs(dest, &list, TRUE);
2261 }
2262
2263 /**
2264  * Move a list of messages to a new folder.
2265  *
2266  * \param dest Destination folder
2267  * \param msglist List of messages
2268  */
2269 gint folder_item_move_msgs(FolderItem *dest, GSList *msglist)
2270 {
2271         g_return_val_if_fail(dest != NULL, -1);
2272         g_return_val_if_fail(msglist != NULL, -1);
2273
2274         return do_copy_msgs(dest, msglist, TRUE);
2275 }
2276
2277 /**
2278  * Copy a message to a new folder.
2279  *
2280  * \param dest Destination folder
2281  * \param msginfo The message
2282  */
2283 gint folder_item_copy_msg(FolderItem *dest, MsgInfo *msginfo)
2284 {
2285         GSList list;
2286
2287         g_return_val_if_fail(dest != NULL, -1);
2288         g_return_val_if_fail(msginfo != NULL, -1);
2289
2290         list.data = msginfo;
2291         list.next = NULL;
2292
2293         return do_copy_msgs(dest, &list, FALSE);
2294 }
2295
2296 /**
2297  * Copy a list of messages to a new folder.
2298  *
2299  * \param dest Destination folder
2300  * \param msglist List of messages
2301  */
2302 gint folder_item_copy_msgs(FolderItem *dest, GSList *msglist)
2303 {
2304         g_return_val_if_fail(dest != NULL, -1);
2305         g_return_val_if_fail(msglist != NULL, -1);
2306
2307         return do_copy_msgs(dest, msglist, FALSE);
2308 }
2309
2310 gint folder_item_remove_msg(FolderItem *item, gint num)
2311 {
2312         Folder *folder;
2313         gint ret;
2314         MsgInfo *msginfo;
2315
2316         g_return_val_if_fail(item != NULL, -1);
2317         folder = item->folder;
2318         g_return_val_if_fail(folder->klass->remove_msg != NULL, -1);
2319
2320         if (!item->cache) folder_item_read_cache(item);
2321
2322         ret = folder->klass->remove_msg(folder, item, num);
2323
2324         msginfo = msgcache_get_msg(item->cache, num);
2325         if (msginfo != NULL) {
2326                 remove_msginfo_from_cache(item, msginfo);
2327                 procmsg_msginfo_free(msginfo);
2328         }
2329         folder_item_update(item, F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT);
2330
2331         return ret;
2332 }
2333
2334 gint folder_item_remove_msgs(FolderItem *item, GSList *msglist)
2335 {
2336         Folder *folder;
2337         gint ret = 0;
2338
2339         g_return_val_if_fail(item != NULL, -1);
2340         folder = item->folder;
2341         g_return_val_if_fail(folder != NULL, -1);
2342
2343         if (!item->cache) folder_item_read_cache(item);
2344
2345         while (msglist != NULL) {
2346                 MsgInfo *msginfo = (MsgInfo *)msglist->data;
2347
2348                 ret = folder_item_remove_msg(item, msginfo->msgnum);
2349                 if (ret != 0) break;
2350                 msgcache_remove_msg(item->cache, msginfo->msgnum);
2351                 msglist = msglist->next;
2352         }
2353
2354         return ret;
2355 }
2356
2357 gint folder_item_remove_all_msg(FolderItem *item)
2358 {
2359         Folder *folder;
2360         gint result;
2361
2362         g_return_val_if_fail(item != NULL, -1);
2363
2364         folder = item->folder;
2365
2366         g_return_val_if_fail(folder->klass->remove_all_msg != NULL, -1);
2367
2368         result = folder->klass->remove_all_msg(folder, item);
2369
2370         if (result == 0) {
2371                 if (folder->klass->finished_remove)
2372                         folder->klass->finished_remove(folder, item);
2373
2374                 folder_item_free_cache(item);
2375                 item->cache = msgcache_new();
2376
2377                 item->new_msgs = 0;
2378                 item->unread_msgs = 0;
2379                 item->unreadmarked_msgs = 0;
2380                 item->total_msgs = 0;
2381                 folder_item_update(item, F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT);
2382         }
2383
2384         return result;
2385 }
2386
2387 void folder_item_change_msg_flags(FolderItem *item, MsgInfo *msginfo, MsgPermFlags newflags)
2388 {
2389         g_return_if_fail(item != NULL);
2390         g_return_if_fail(msginfo != NULL);
2391
2392         if (item->folder->klass->change_flags != NULL) {
2393                 item->folder->klass->change_flags(item->folder, item, msginfo, newflags);
2394         } else {
2395                 msginfo->flags.perm_flags = newflags;
2396         }
2397 }
2398
2399 gboolean folder_item_is_msg_changed(FolderItem *item, MsgInfo *msginfo)
2400 {
2401         Folder *folder;
2402
2403         g_return_val_if_fail(item != NULL, FALSE);
2404
2405         folder = item->folder;
2406
2407         g_return_val_if_fail(folder->klass->is_msg_changed != NULL, -1);
2408
2409         return folder->klass->is_msg_changed(folder, item, msginfo);
2410 }
2411
2412 gchar *folder_item_get_cache_file(FolderItem *item)
2413 {
2414         gchar *path;
2415         gchar *file;
2416
2417         g_return_val_if_fail(item != NULL, NULL);
2418         g_return_val_if_fail(item->path != NULL, NULL);
2419
2420         path = folder_item_get_path(item);
2421         g_return_val_if_fail(path != NULL, NULL);
2422         if (!is_dir_exist(path))
2423                 make_dir_hier(path);
2424         file = g_strconcat(path, G_DIR_SEPARATOR_S, CACHE_FILE, NULL);
2425         g_free(path);
2426
2427         return file;
2428 }
2429
2430 gchar *folder_item_get_mark_file(FolderItem *item)
2431 {
2432         gchar *path;
2433         gchar *file;
2434
2435         g_return_val_if_fail(item != NULL, NULL);
2436         g_return_val_if_fail(item->path != NULL, NULL);
2437
2438         path = folder_item_get_path(item);
2439         g_return_val_if_fail(path != NULL, NULL);
2440         if (!is_dir_exist(path))
2441                 make_dir_hier(path);
2442         file = g_strconcat(path, G_DIR_SEPARATOR_S, MARK_FILE, NULL);
2443         g_free(path);
2444
2445         return file;
2446 }
2447
2448 static gboolean folder_build_tree(GNode *node, gpointer data)
2449 {
2450         Folder *folder = FOLDER(data);
2451         FolderItem *item;
2452         XMLNode *xmlnode;
2453
2454         g_return_val_if_fail(node->data != NULL, FALSE);
2455         if (!node->parent) return FALSE;
2456
2457         xmlnode = node->data;
2458         if (strcmp2(xmlnode->tag->tag, "folderitem") != 0) {
2459                 g_warning("tag name != \"folderitem\"\n");
2460                 return FALSE;
2461         }
2462
2463         item = folder_item_new(folder, "", "");
2464         if (folder->klass->item_set_xml != NULL)
2465                 folder->klass->item_set_xml(folder, item, xmlnode->tag);
2466         else
2467                 folder_item_set_xml(folder, item, xmlnode->tag);
2468         item->node = node;
2469         item->parent = FOLDER_ITEM(node->parent->data);
2470         item->folder = folder;
2471         switch (item->stype) {
2472         case F_INBOX:  folder->inbox  = item; break;
2473         case F_OUTBOX: folder->outbox = item; break;
2474         case F_DRAFT:  folder->draft  = item; break;
2475         case F_QUEUE:  folder->queue  = item; break;
2476         case F_TRASH:  folder->trash  = item; break;
2477         default:       break;
2478         }
2479         folder_item_prefs_read_config(item);
2480
2481         node->data = item;
2482         xml_free_node(xmlnode);
2483
2484         return FALSE;
2485 }
2486
2487 static gboolean folder_read_folder_func(GNode *node, gpointer data)
2488 {
2489         Folder *folder;
2490         FolderItem *item;
2491         XMLNode *xmlnode;
2492         GList *list;
2493         FolderClass *klass = NULL;
2494
2495         if (g_node_depth(node) != 2) return FALSE;
2496         g_return_val_if_fail(node->data != NULL, FALSE);
2497
2498         xmlnode = node->data;
2499         if (strcmp2(xmlnode->tag->tag, "folder") != 0) {
2500                 g_warning("tag name != \"folder\"\n");
2501                 return TRUE;
2502         }
2503         g_node_unlink(node);
2504         list = xmlnode->tag->attr;
2505         for (; list != NULL; list = list->next) {
2506                 XMLAttr *attr = list->data;
2507
2508                 if (!attr || !attr->name || !attr->value) continue;
2509                 if (!strcmp(attr->name, "type"))
2510                         klass = folder_get_class_from_string(attr->value);
2511         }
2512
2513         folder = folder_new(klass, "", "");
2514         g_return_val_if_fail(folder != NULL, FALSE);
2515
2516         item = FOLDER_ITEM(folder->node->data);
2517
2518         node->data = item;
2519         item->node = node;
2520         g_node_destroy(folder->node);
2521         folder->node = node;
2522         if (klass->set_xml)
2523                 klass->set_xml(folder, xmlnode->tag);
2524         else
2525                 folder_set_xml(folder, xmlnode->tag);
2526
2527         if (folder->klass->item_set_xml != NULL)
2528                 folder->klass->item_set_xml(folder, item, xmlnode->tag);
2529         else
2530                 folder_item_set_xml(folder, item, xmlnode->tag);
2531
2532         folder_add(folder);
2533         g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
2534                         folder_build_tree, folder);
2535
2536         return FALSE;
2537 }
2538
2539 static gchar *folder_get_list_path(void)
2540 {
2541         static gchar *filename = NULL;
2542
2543         if (!filename)
2544                 filename =  g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
2545                                         FOLDER_LIST, NULL);
2546
2547         return filename;
2548 }
2549
2550 #define PUT_ESCAPE_STR(fp, attr, str)                   \
2551 {                                                       \
2552         fputs(" " attr "=\"", fp);                      \
2553         xml_file_put_escape_str(fp, str);               \
2554         fputs("\"", fp);                                \
2555 }
2556
2557 gint xml_attr_cmp_name(gconstpointer _a, gconstpointer _b)
2558 {
2559         XMLAttr *a = (XMLAttr *) _a;
2560         XMLAttr *b = (XMLAttr *) _b;
2561
2562         return g_str_equal(a->name, b->name) ? 0 : 1;
2563 }
2564
2565 static void folder_write_list_recursive(GNode *node, gpointer data)
2566 {
2567         FILE *fp = (FILE *)data;
2568         FolderItem *item;
2569         gint i, depth;
2570         XMLTag *tag;
2571         GList *cur;
2572
2573         g_return_if_fail(node != NULL);
2574         g_return_if_fail(fp != NULL);
2575
2576         item = FOLDER_ITEM(node->data);
2577         g_return_if_fail(item != NULL);
2578
2579         depth = g_node_depth(node);
2580         for (i = 0; i < depth; i++)
2581                 fputs("    ", fp);
2582         if (depth == 1) {
2583                 XMLTag *folderitem_tag;
2584                 GList *cur;
2585
2586                 if (item->folder->klass->get_xml != NULL)
2587                         tag = item->folder->klass->get_xml(item->folder);
2588                 else
2589                         tag = folder_get_xml(item->folder);
2590
2591                 if (item->folder->klass->item_get_xml != NULL)
2592                         folderitem_tag = item->folder->klass->item_get_xml(item->folder, item);
2593                 else
2594                         folderitem_tag = folder_item_get_xml(item->folder, item);
2595                 xml_tag_add_attr(tag, "type", g_strdup(item->folder->klass->idstr));
2596
2597                 for (cur = folderitem_tag->attr; cur != NULL; cur = g_list_next(cur)) {
2598                         XMLAttr *attr = (XMLAttr *) cur->data;
2599
2600                         if (g_list_find_custom(tag->attr, attr, xml_attr_cmp_name) == NULL)
2601                                 tag->attr = g_list_append(tag->attr, xml_copy_attr(attr));
2602                 }
2603                 xml_free_tag(folderitem_tag);
2604
2605         } else {
2606
2607                 if (item->folder->klass->item_get_xml != NULL)
2608                         tag = item->folder->klass->item_get_xml(item->folder, item);
2609                 else
2610                         tag = folder_item_get_xml(item->folder, item);
2611
2612         }
2613
2614         fprintf(fp, "<%s", tag->tag);
2615         for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
2616                 XMLAttr *attr = (XMLAttr *) cur->data;
2617
2618                 fprintf(fp, " %s=\"", attr->name);
2619                 xml_file_put_escape_str(fp, attr->value);
2620                 fputs("\"", fp);
2621         }
2622
2623         if (node->children) {
2624                 GNode *child;
2625                 fputs(">\n", fp);
2626
2627                 child = node->children;
2628                 while (child) {
2629                         GNode *cur;
2630
2631                         cur = child;
2632                         child = cur->next;
2633                         folder_write_list_recursive(cur, data);
2634                 }
2635
2636                 for (i = 0; i < depth; i++)
2637                         fputs("    ", fp);
2638                 fprintf(fp, "</%s>\n", tag->tag);
2639         } else
2640                 fputs(" />\n", fp);
2641         xml_free_tag(tag);
2642 }
2643
2644 static void folder_update_op_count_rec(GNode *node)
2645 {
2646         FolderItem *fitem = FOLDER_ITEM(node->data);
2647
2648         if (g_node_depth(node) > 0) {
2649                 if (fitem->op_count > 0) {
2650                         fitem->op_count = 0;
2651                         folder_item_update(fitem, F_ITEM_UPDATE_MSGCNT);
2652                 }
2653                 if (node->children) {
2654                         GNode *child;
2655
2656                         child = node->children;
2657                         while (child) {
2658                                 GNode *cur;
2659
2660                                 cur = child;
2661                                 child = cur->next;
2662                                 folder_update_op_count_rec(cur);
2663                         }
2664                 }
2665         }
2666 }
2667
2668 void folder_update_op_count(void)
2669 {
2670         GList *cur;
2671         Folder *folder;
2672
2673         for (cur = folder_list; cur != NULL; cur = cur->next) {
2674                 folder = cur->data;
2675                 folder_update_op_count_rec(folder->node);
2676         }
2677 }
2678
2679 typedef struct _type_str {
2680         gchar * str;
2681         gint type;
2682 } type_str;
2683
2684
2685 /*
2686 static gchar * folder_item_get_tree_identifier(FolderItem * item)
2687 {
2688         if (item->parent != NULL) {
2689                 gchar * path;
2690                 gchar * id;
2691
2692                 path = folder_item_get_tree_identifier(item->parent);
2693                 if (path == NULL)
2694                         return NULL;
2695
2696                 id = g_strconcat(path, "/", item->name, NULL);
2697                 g_free(path);
2698
2699                 return id;
2700         }
2701         else {
2702                 return g_strconcat("/", item->name, NULL);
2703         }
2704 }
2705 */
2706
2707 /* CLAWS: temporary local folder for filtering */
2708 #define TEMP_FOLDER "TEMP_FOLDER"
2709 #define PROCESSING_FOLDER_ITEM "processing"
2710
2711 static FolderItem *processing_folder_item;
2712
2713 static void folder_create_processing_folder(void)
2714 {
2715         Folder *processing_folder;
2716         gchar      *tmpname;
2717
2718         if ((processing_folder = folder_find_from_name(TEMP_FOLDER, mh_get_class())) == NULL) {
2719                 gchar *tmppath;
2720
2721                 tmppath =
2722                     g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
2723                                 "tempfolder", NULL);
2724                 processing_folder =
2725                     folder_new(mh_get_class(), TEMP_FOLDER, tmppath);
2726                 g_free(tmppath);
2727         }
2728         g_assert(processing_folder != NULL);
2729
2730         debug_print("tmpparentroot %s\n", LOCAL_FOLDER(processing_folder)->rootpath);
2731         if (LOCAL_FOLDER(processing_folder)->rootpath[0] == '/')
2732                 tmpname = g_strconcat(LOCAL_FOLDER(processing_folder)->rootpath,
2733                                       G_DIR_SEPARATOR_S, PROCESSING_FOLDER_ITEM,
2734                                       NULL);
2735         else
2736                 tmpname = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
2737                                       LOCAL_FOLDER(processing_folder)->rootpath,
2738                                       G_DIR_SEPARATOR_S, PROCESSING_FOLDER_ITEM,
2739                                       NULL);
2740
2741         if (!is_dir_exist(tmpname)) {
2742                 debug_print("*TMP* creating %s\n", tmpname);
2743                 processing_folder_item = processing_folder->klass->create_folder(processing_folder,
2744                                                                                  processing_folder->node->data,
2745                                                                                  PROCESSING_FOLDER_ITEM);
2746         } else {
2747                 debug_print("*TMP* already created\n");
2748                 processing_folder_item = folder_item_new(processing_folder, PROCESSING_FOLDER_ITEM, PROCESSING_FOLDER_ITEM);
2749                 g_assert(processing_folder_item);
2750                 folder_item_append(processing_folder->node->data, processing_folder_item);
2751         }
2752         g_assert(processing_folder_item != NULL);
2753         g_free(tmpname);
2754 }
2755
2756 FolderItem *folder_get_default_processing(void)
2757 {
2758         if (!processing_folder_item) {
2759                 folder_create_processing_folder();
2760         }
2761         return processing_folder_item;
2762 }
2763
2764 /* folder_persist_prefs_new() - return hash table with persistent
2765  * settings (and folder name as key).
2766  * (note that in claws other options are in the folder_item_prefs_RC
2767  * file, so those don't need to be included in PersistPref yet)
2768  */
2769 GHashTable *folder_persist_prefs_new(Folder *folder)
2770 {
2771         GHashTable *pptable;
2772
2773         g_return_val_if_fail(folder, NULL);
2774         pptable = g_hash_table_new(g_str_hash, g_str_equal);
2775         folder_get_persist_prefs_recursive(folder->node, pptable);
2776         return pptable;
2777 }
2778
2779 void folder_persist_prefs_free(GHashTable *pptable)
2780 {
2781         g_return_if_fail(pptable);
2782         g_hash_table_foreach_remove(pptable, persist_prefs_free, NULL);
2783         g_hash_table_destroy(pptable);
2784 }
2785
2786 const PersistPrefs *folder_get_persist_prefs(GHashTable *pptable, const char *name)
2787 {
2788         if (pptable == NULL || name == NULL) return NULL;
2789         return g_hash_table_lookup(pptable, name);
2790 }
2791
2792 void folder_item_restore_persist_prefs(FolderItem *item, GHashTable *pptable)
2793 {
2794         const PersistPrefs *pp;
2795         gchar *id = folder_item_get_identifier(item);
2796
2797         pp = folder_get_persist_prefs(pptable, id);
2798         g_free(id);
2799
2800         if (!pp) return;
2801
2802         /* CLAWS: since not all folder properties have been migrated to
2803          * folderlist.xml, we need to call the old stuff first before
2804          * setting things that apply both to Main and Claws. */
2805         folder_item_prefs_read_config(item);
2806
2807         item->collapsed = pp->collapsed;
2808         item->thread_collapsed = pp->thread_collapsed;
2809         item->threaded  = pp->threaded;
2810         item->ret_rcpt  = pp->ret_rcpt;
2811         item->hide_read_msgs = pp->hide_read_msgs;
2812         item->sort_key  = pp->sort_key;
2813         item->sort_type = pp->sort_type;
2814 }
2815
2816 static void folder_get_persist_prefs_recursive(GNode *node, GHashTable *pptable)
2817 {
2818         FolderItem *item = FOLDER_ITEM(node->data);
2819         PersistPrefs *pp;
2820         GNode *child, *cur;
2821         gchar *id;
2822
2823         g_return_if_fail(node != NULL);
2824         g_return_if_fail(item != NULL);
2825
2826         /* NOTE: item->path == NULL means top level folder; not interesting
2827          * to store preferences of that one.  */
2828         if (item->path) {
2829                 id = folder_item_get_identifier(item);
2830                 pp = g_new0(PersistPrefs, 1);
2831                 g_return_if_fail(pp != NULL);
2832                 pp->collapsed = item->collapsed;
2833                 pp->thread_collapsed = item->thread_collapsed;
2834                 pp->threaded  = item->threaded;
2835                 pp->ret_rcpt  = item->ret_rcpt;
2836                 pp->hide_read_msgs = item->hide_read_msgs;
2837                 pp->sort_key  = item->sort_key;
2838                 pp->sort_type = item->sort_type;
2839                 g_hash_table_insert(pptable, id, pp);
2840         }
2841
2842         if (node->children) {
2843                 child = node->children;
2844                 while (child) {
2845                         cur = child;
2846                         child = cur->next;
2847                         folder_get_persist_prefs_recursive(cur, pptable);
2848                 }
2849         }
2850 }
2851
2852 static gboolean persist_prefs_free(gpointer key, gpointer val, gpointer data)
2853 {
2854         if (key)
2855                 g_free(key);
2856         if (val)
2857                 g_free(val);
2858         return TRUE;
2859 }
2860
2861 void folder_item_apply_processing(FolderItem *item)
2862 {
2863         GSList *processing_list;
2864         GSList *mlist, *cur;
2865
2866         g_return_if_fail(item != NULL);
2867
2868         processing_list = item->prefs->processing;
2869         if (processing_list == NULL)
2870                 return;
2871
2872         folder_item_update_freeze();
2873
2874         mlist = folder_item_get_msg_list(item);
2875         for (cur = mlist ; cur != NULL ; cur = cur->next) {
2876                 MsgInfo * msginfo;
2877
2878                 msginfo = (MsgInfo *) cur->data;
2879
2880                 /* reset parameters that can be modified by processing */
2881                 msginfo->hidden = 0;
2882                 msginfo->score = 0;
2883
2884                 /* apply pre global rules */
2885                 filter_message_by_msginfo(pre_global_processing, msginfo);
2886
2887                 /* apply rules of the folder */
2888                 filter_message_by_msginfo(processing_list, msginfo);
2889
2890                 /* apply post global rules */
2891                 filter_message_by_msginfo(post_global_processing, msginfo);
2892
2893                 procmsg_msginfo_free(msginfo);
2894         }
2895         g_slist_free(mlist);
2896
2897         folder_item_update_thaw();
2898 }
2899
2900 /*
2901  *  functions for handling FolderItem content changes
2902  */
2903 static gint folder_item_update_freeze_cnt = 0;
2904
2905 /**
2906  * Notify the folder system about changes to a folder. If the
2907  * update system is not frozen the FOLDER_ITEM_UPDATE_HOOKLIST will
2908  * be invoked, otherwise the changes will be remebered until
2909  * the folder system is thawed.
2910  *
2911  * \param item The FolderItem that was changed
2912  * \param update_flags Type of changed that was made
2913  */
2914 void folder_item_update(FolderItem *item, FolderItemUpdateFlags update_flags)
2915 {
2916         if (folder_item_update_freeze_cnt == 0) {
2917                 FolderItemUpdateData source;
2918
2919                 source.item = item;
2920                 source.update_flags = update_flags;
2921                 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
2922         } else {
2923                 item->update_flags |= update_flags;
2924         }
2925 }
2926
2927 void folder_item_update_recursive(FolderItem *item, FolderItemUpdateFlags update_flags)
2928 {
2929         GNode *node = item->folder->node;
2930
2931         node = g_node_find(node, G_PRE_ORDER, G_TRAVERSE_ALL, item);
2932         node = node->children;
2933
2934         folder_item_update(item, update_flags);
2935         while (node != NULL) {
2936                 if (node && node->data) {
2937                         FolderItem *next_item = (FolderItem*) node->data;
2938
2939                         folder_item_update(next_item, update_flags);
2940                 }
2941                 node = node->next;
2942         }
2943 }
2944
2945 void folder_item_update_freeze(void)
2946 {
2947         folder_item_update_freeze_cnt++;
2948 }
2949
2950 static void folder_item_update_func(FolderItem *item, gpointer data)
2951 {
2952         FolderItemUpdateData source;
2953
2954         if (item->update_flags) {
2955                 source.item = item;
2956                 source.update_flags = item->update_flags;
2957                 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
2958                 item->update_flags = 0;
2959         }
2960 }
2961
2962 void folder_item_update_thaw(void)
2963 {
2964         if (folder_item_update_freeze_cnt > 0)
2965                 folder_item_update_freeze_cnt--;
2966         if (folder_item_update_freeze_cnt == 0) {
2967                 /* Update all folders */
2968                 folder_func_to_all_folders(folder_item_update_func, NULL);
2969         }
2970 }
2971
2972 #undef PUT_ESCAPE_STR