src/folder.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2008 Hiroyuki Yamamoto and the Claws Mail team
   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 3 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, see <http://www.gnu.org/licenses/>.
  17  *
  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 <glib/gi18n.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34 #ifdef WIN32
  35 #include <w32lib.h>
  36 #endif
  37
  38 #include "folder.h"
  39 #include "session.h"
  40 #include "inc.h"
  41 #include "imap.h"
  42 #include "news.h"
  43 #include "mh.h"
  44 #include "utils.h"
  45 #include "xml.h"
  46 #include "codeconv.h"
  47 #include "prefs_gtk.h"
  48 #include "account.h"
  49 #include "filtering.h"
  50 #include "procheader.h"
  51 #include "hooks.h"
  52 #include "log.h"
  53 #include "folder_item_prefs.h"
  54 #include "remotefolder.h"
  55 #include "partial_download.h"
  56 #include "statusbar.h"
  57 #include "gtkutils.h"
  58 #include "timing.h"
  59 #include "compose.h"
  60 #include "main.h"
  61
  62 /* Dependecies to be removed ?! */
  63 #include "prefs_common.h"
  64 #include "prefs_account.h"
  65
  66 /* Define possible missing constants for Windows. */
  67 #ifdef G_OS_WIN32
  68 # ifndef S_IRGRP
  69 # define S_IRGRP 0
  70 # define S_IWGRP 0
  71 # endif
  72 # ifndef S_IROTH
  73 # define S_IROTH 0
  74 # define S_IWOTH 0
  75 # endif
  76 #endif
  77
  78 static GList *folder_list = NULL;
  79 static GSList *class_list = NULL;
  80 static GSList *folder_unloaded_list = NULL;
  81
  82 void folder_init                (Folder         *folder,
  83                                  const gchar    *name);
  84
  85 static gchar *folder_item_get_cache_file        (FolderItem     *item);
  86 static gchar *folder_item_get_mark_file (FolderItem     *item);
  87 static gchar *folder_item_get_tags_file (FolderItem     *item);
  88 static gchar *folder_get_list_path      (void);
  89 static GNode *folder_get_xml_node       (Folder         *folder);
  90 static Folder *folder_get_from_xml      (GNode          *node);
  91 static void folder_update_op_count_rec  (GNode          *node);
  92
  93
  94 static void folder_get_persist_prefs_recursive
  95                                         (GNode *node, GHashTable *pptable);
  96 static gboolean persist_prefs_free      (gpointer key, gpointer val, gpointer data);
  97 static void folder_item_read_cache              (FolderItem *item);
  98 gint folder_item_scan_full              (FolderItem *item, gboolean filtering);
  99 static void folder_item_update_with_msg (FolderItem *item, FolderItemUpdateFlags update_flags,
 100                                          MsgInfo *msg);
 101 static GHashTable *folder_persist_prefs_new     (Folder *folder);
 102 static void folder_persist_prefs_free           (GHashTable *pptable);
 103 static void folder_item_restore_persist_prefs   (FolderItem *item, GHashTable *pptable);
 104
 105 void folder_system_init(void)
 106 {
 107         folder_register_class(mh_get_class());
 108         folder_register_class(imap_get_class());
 109         folder_register_class(news_get_class());
 110 }
 111
 112 static GSList *folder_get_class_list(void)
 113 {
 114         return class_list;
 115 }
 116
 117 void folder_register_class(FolderClass *klass)
 118 {
 119         GSList *xmllist, *cur;
 120
 121         debug_print("registering folder class %s\n", klass->idstr);
 122
 123         class_list = g_slist_append(class_list, klass);
 124
 125         xmllist = g_slist_copy(folder_unloaded_list);
 126         for (cur = xmllist; cur != NULL; cur = g_slist_next(cur)) {
 127                 GNode *node = (GNode *) cur->data;
 128                 XMLNode *xmlnode = (XMLNode *) node->data;
 129                 GList *cur = xmlnode->tag->attr;
 130
 131                 for (; cur != NULL; cur = g_list_next(cur)) {
 132                         XMLAttr *attr = (XMLAttr *) cur->data;
 133
 134                         if (!attr || !attr->name || !attr->value) continue;
 135                         if (!strcmp(attr->name, "type") && !strcmp(attr->value, klass->idstr)) {
 136                                 Folder *folder;
 137
 138                                 folder = folder_get_from_xml(node);
 139                                 if (folder) {
 140                                         folder_add(folder);
 141                                         folder_unloaded_list = g_slist_remove(folder_unloaded_list, node);
 142                                 }
 143                                 cur = NULL;
 144                                 continue;
 145                         }
 146                 }
 147         }
 148         g_slist_free(xmllist);
 149 }
 150
 151 void folder_unregister_class(FolderClass *klass)
 152 {
 153         GList *folderlist, *cur;
 154
 155         debug_print("unregistering folder class %s\n", klass->idstr);
 156
 157         class_list = g_slist_remove(class_list, klass);
 158
 159         folderlist = g_list_copy(folder_get_list());
 160         for (cur = folderlist; cur != NULL; cur = g_list_next(cur)) {
 161                 Folder *folder = (Folder *) cur->data;
 162
 163                 if (folder->klass == klass) {
 164                         GNode *xmlnode = folder_get_xml_node(folder);
 165                         folder_unloaded_list = g_slist_append(folder_unloaded_list, xmlnode);
 166                         folder_destroy(folder);
 167                 }
 168         }
 169         g_list_free(folderlist);
 170 }
 171
 172 Folder *folder_new(FolderClass *klass, const gchar *name, const gchar *path)
 173 {
 174         Folder *folder = NULL;
 175         FolderItem *item;
 176
 177         g_return_val_if_fail(klass != NULL, NULL);
 178
 179         name = name ? name : path;
 180         folder = klass->new_folder(name, path);
 181
 182         /* Create root folder item */
 183         item = folder_item_new(folder, name, NULL);
 184         if (item == NULL) {
 185                 return NULL;
 186         }
 187         item->folder = folder;
 188         folder->node = item->node = g_node_new(item);
 189         folder->data = NULL;
 190
 191         return folder;
 192 }
 193
 194 void folder_init(Folder *folder, const gchar *name)
 195 {
 196         g_return_if_fail(folder != NULL);
 197
 198         folder_set_name(folder, name);
 199
 200         /* Init folder data */
 201         folder->account = NULL;
 202         folder->sort = 0;
 203         folder->inbox = NULL;
 204         folder->outbox = NULL;
 205         folder->draft = NULL;
 206         folder->queue = NULL;
 207         folder->trash = NULL;
 208 }
 209
 210 static void reset_parent_type(FolderItem *item, gpointer data) {
 211         item->parent_stype = -1;
 212 }
 213
 214 void folder_item_change_type(FolderItem *item, SpecialFolderItemType newtype)
 215 {
 216         Folder *folder = NULL;
 217         FolderUpdateData hookdata;
 218
 219         if (item == NULL)
 220                 return;
 221
 222         folder = item->folder;
 223         /* unset previous root of newtype */
 224         switch(newtype) {
 225         case F_INBOX:
 226                 folder_item_change_type(folder->inbox, F_NORMAL);
 227                 folder->inbox = item;
 228                 break;
 229         case F_OUTBOX:
 230                 folder_item_change_type(folder->outbox, F_NORMAL);
 231                 folder->outbox = item;
 232                 break;
 233         case F_QUEUE:
 234                 folder_item_change_type(folder->queue, F_NORMAL);
 235                 folder->queue = item;
 236                 break;
 237         case F_DRAFT:
 238                 folder_item_change_type(folder->draft, F_NORMAL);
 239                 folder->draft = item;
 240                 break;
 241         case F_TRASH:
 242                 folder_item_change_type(folder->trash, F_NORMAL);
 243                 folder->trash = item;
 244                 break;
 245         case F_NORMAL:
 246         default:
 247                 break;
 248         }
 249         /* set new type for current folder and sons */
 250         item->stype = newtype;
 251         folder_func_to_all_folders(reset_parent_type, NULL);
 252
 253         hookdata.folder = folder;
 254         hookdata.update_flags = FOLDER_TREE_CHANGED;
 255         hookdata.item = NULL;
 256         hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 257 }
 258
 259 void folder_destroy(Folder *folder)
 260 {
 261         g_return_if_fail(folder != NULL);
 262         g_return_if_fail(folder->klass->destroy_folder != NULL);
 263
 264         folder_remove(folder);
 265
 266         folder_tree_destroy(folder);
 267
 268         folder->klass->destroy_folder(folder);
 269
 270         g_free(folder->name);
 271         g_free(folder);
 272 }
 273
 274 void folder_set_xml(Folder *folder, XMLTag *tag)
 275 {
 276         GList *cur;
 277         FolderItem *rootitem = NULL;
 278
 279         if ((folder->node != NULL) && (folder->node->data != NULL))
 280                 rootitem = (FolderItem *) folder->node->data;
 281
 282         for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
 283                 XMLAttr *attr = (XMLAttr *) cur->data;
 284
 285                 if (!attr || !attr->name || !attr->value) continue;
 286                 if (!strcmp(attr->name, "name")) {
 287                         g_free(folder->name);
 288                         folder->name = g_strdup(attr->value);
 289                         if (rootitem != NULL) {
 290                                 g_free(rootitem->name);
 291                                 rootitem->name = g_strdup(attr->value);
 292                         }
 293                 } else if (!strcmp(attr->name, "account_id")) {
 294                         PrefsAccount *account;
 295
 296                         account = account_find_from_id(atoi(attr->value));
 297                         if (!account)
 298                                 g_warning("account_id: %s not found\n", attr->value);
 299                         else {
 300                                 folder->account = account;
 301                                 account->folder = folder;
 302                         }
 303                 } else if (!strcmp(attr->name, "collapsed")) {
 304                         if (rootitem != NULL)
 305                                 rootitem->collapsed = *attr->value == '1' ? TRUE : FALSE;
 306                 } else if (!strcmp(attr->name, "sort")) {
 307                         folder->sort = atoi(attr->value);
 308                 }
 309         }
 310 }
 311
 312 XMLTag *folder_get_xml(Folder *folder)
 313 {
 314         XMLTag *tag;
 315
 316         tag = xml_tag_new("folder");
 317
 318         if (folder->name)
 319                 xml_tag_add_attr(tag, xml_attr_new("name", folder->name));
 320         if (folder->account)
 321                 xml_tag_add_attr(tag, xml_attr_new_int("account_id", folder->account->account_id));
 322         if (folder->node && folder->node->data) {
 323                 FolderItem *rootitem = (FolderItem *) folder->node->data;
 324
 325                 xml_tag_add_attr(tag, xml_attr_new("collapsed", rootitem->collapsed ? "1" : "0"));
 326         }
 327         xml_tag_add_attr(tag, xml_attr_new_int("sort", folder->sort));
 328
 329         return tag;
 330 }
 331
 332 FolderItem *folder_item_new(Folder *folder, const gchar *name, const gchar *path)
 333 {
 334         FolderItem *item = NULL;
 335
 336         g_return_val_if_fail(folder != NULL, NULL);
 337
 338         if (folder->klass->item_new) {
 339                 item = folder->klass->item_new(folder);
 340         } else {
 341                 item = g_new0(FolderItem, 1);
 342         }
 343
 344         g_return_val_if_fail(item != NULL, NULL);
 345
 346         item->stype = F_NORMAL;
 347         item->name = g_strdup(name);
 348         item->path = g_strdup(path);
 349         item->mtime = 0;
 350         item->new_msgs = 0;
 351         item->unread_msgs = 0;
 352         item->unreadmarked_msgs = 0;
 353         item->marked_msgs = 0;
 354         item->total_msgs = 0;
 355         item->replied_msgs = 0;
 356         item->forwarded_msgs = 0;
 357         item->locked_msgs = 0;
 358         item->ignored_msgs = 0;
 359         item->watched_msgs = 0;
 360         item->order = 0;
 361         item->last_num = -1;
 362         item->cache = NULL;
 363         item->no_sub = FALSE;
 364         item->no_select = FALSE;
 365         item->collapsed = FALSE;
 366         item->thread_collapsed = FALSE;
 367         item->threaded  = TRUE;
 368         item->ret_rcpt  = FALSE;
 369         item->opened    = FALSE;
 370         item->node = g_node_new(item);
 371         item->folder = NULL;
 372         item->account = NULL;
 373         item->apply_sub = FALSE;
 374         item->mark_queue = NULL;
 375         item->data = NULL;
 376         item->parent_stype = -1;
 377
 378         item->sort_key = SORT_BY_DATE;
 379         item->sort_type = SORT_ASCENDING;
 380
 381         item->prefs = folder_item_prefs_new();
 382
 383         return item;
 384 }
 385
 386 void folder_item_append(FolderItem *parent, FolderItem *item)
 387 {
 388         g_return_if_fail(parent != NULL);
 389         g_return_if_fail(parent->folder != NULL);
 390         g_return_if_fail(parent->node != NULL);
 391         g_return_if_fail(item != NULL);
 392
 393         item->folder = parent->folder;
 394         g_node_append(parent->node, item->node);
 395 }
 396
 397 void folder_item_remove(FolderItem *item)
 398 {
 399         GNode *node, *start_node;
 400         FolderUpdateData hookdata;
 401         gchar *tags_file = NULL;
 402
 403         g_return_if_fail(item != NULL);
 404         g_return_if_fail(item->folder != NULL);
 405         g_return_if_fail(item->folder->node != NULL);
 406
 407         start_node = node = item->node;
 408
 409         node = item->folder->node;
 410
 411         node = g_node_find(node, G_PRE_ORDER, G_TRAVERSE_ALL, item);
 412         node = node->children;
 413
 414         /* remove my children */
 415         while (node != NULL) {
 416                 if (node && node->data) {
 417                         FolderItem *sub_item = (FolderItem*) node->data;
 418                         node = node->next;
 419                         folder_item_remove(sub_item);
 420                 }
 421         }
 422
 423         /* remove myself */
 424         if (item->cache != NULL) {
 425                 msgcache_destroy(item->cache);
 426                 item->cache = NULL;
 427         }
 428         tags_file = folder_item_get_tags_file(item);
 429         if (tags_file)
 430                 claws_unlink(tags_file);
 431         g_free(tags_file);
 432
 433         hookdata.folder = item->folder;
 434         hookdata.update_flags = FOLDER_TREE_CHANGED | FOLDER_REMOVE_FOLDERITEM;
 435         hookdata.item = item;
 436         hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 437
 438         node = start_node;
 439
 440         if (item->folder->node == node)
 441                 item->folder->node = NULL;
 442
 443         folder_item_destroy(item);
 444
 445         g_node_destroy(node);
 446 }
 447
 448 void folder_item_remove_children(FolderItem *item)
 449 {
 450         GNode *node, *next;
 451
 452         g_return_if_fail(item != NULL);
 453         g_return_if_fail(item->folder != NULL);
 454         g_return_if_fail(item->node != NULL);
 455
 456         node = item->node->children;
 457         while (node != NULL) {
 458                 next = node->next;
 459                 folder_item_remove(FOLDER_ITEM(node->data));
 460                 node = next;
 461         }
 462 }
 463
 464 void folder_item_destroy(FolderItem *item)
 465 {
 466         Folder *folder;
 467
 468         g_return_if_fail(item != NULL);
 469
 470         folder = item->folder;
 471         if (folder) {
 472                 if (folder->inbox == item)
 473                         folder->inbox = NULL;
 474                 else if (folder->outbox == item)
 475                         folder->outbox = NULL;
 476                 else if (folder->draft == item)
 477                         folder->draft = NULL;
 478                 else if (folder->queue == item)
 479                         folder->queue = NULL;
 480                 else if (folder->trash == item)
 481                         folder->trash = NULL;
 482         }
 483
 484         if (item->cache)
 485                 folder_item_free_cache(item, TRUE);
 486         if (item->prefs)
 487                 folder_item_prefs_free(item->prefs);
 488         g_free(item->name);
 489         g_free(item->path);
 490
 491         if (item->folder != NULL) {
 492                 if(item->folder->klass->item_destroy) {
 493                         item->folder->klass->item_destroy(item->folder, item);
 494                 } else {
 495                         g_free(item);
 496                 }
 497         }
 498 }
 499
 500 FolderItem *folder_item_parent(FolderItem *item)
 501 {
 502         g_return_val_if_fail(item != NULL, NULL);
 503         g_return_val_if_fail(item->node != NULL, NULL);
 504
 505         if (item->node->parent == NULL)
 506                 return NULL;
 507         return (FolderItem *) item->node->parent->data;
 508 }
 509
 510 void folder_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag)
 511 {
 512         GList *cur;
 513
 514         for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
 515                 XMLAttr *attr = (XMLAttr *) cur->data;
 516
 517                 if (!attr || !attr->name || !attr->value) continue;
 518                 if (!strcmp(attr->name, "type")) {
 519                         if (!g_ascii_strcasecmp(attr->value, "normal"))
 520                                 item->stype = F_NORMAL;
 521                         else if (!g_ascii_strcasecmp(attr->value, "inbox"))
 522                                 item->stype = F_INBOX;
 523                         else if (!g_ascii_strcasecmp(attr->value, "outbox"))
 524                                 item->stype = F_OUTBOX;
 525                         else if (!g_ascii_strcasecmp(attr->value, "draft"))
 526                                 item->stype = F_DRAFT;
 527                         else if (!g_ascii_strcasecmp(attr->value, "queue"))
 528                                 item->stype = F_QUEUE;
 529                         else if (!g_ascii_strcasecmp(attr->value, "trash"))
 530                                 item->stype = F_TRASH;
 531                 } else if (!strcmp(attr->name, "name")) {
 532                         g_free(item->name);
 533                         item->name = g_strdup(attr->value);
 534                 } else if (!strcmp(attr->name, "path")) {
 535                         g_free(item->path);
 536                         item->path = g_strdup(attr->value);
 537                 } else if (!strcmp(attr->name, "mtime"))
 538                         item->mtime = strtoul(attr->value, NULL, 10);
 539                 else if (!strcmp(attr->name, "new"))
 540                         item->new_msgs = atoi(attr->value);
 541                 else if (!strcmp(attr->name, "unread"))
 542                         item->unread_msgs = atoi(attr->value);
 543                 else if (!strcmp(attr->name, "unreadmarked"))
 544                         item->unreadmarked_msgs = atoi(attr->value);
 545                 else if (!strcmp(attr->name, "marked"))
 546                         item->marked_msgs = atoi(attr->value);
 547                 else if (!strcmp(attr->name, "replied"))
 548                         item->replied_msgs = atoi(attr->value);
 549                 else if (!strcmp(attr->name, "forwarded"))
 550                         item->forwarded_msgs = atoi(attr->value);
 551                 else if (!strcmp(attr->name, "locked"))
 552                         item->locked_msgs = atoi(attr->value);
 553                 else if (!strcmp(attr->name, "ignored"))
 554                         item->ignored_msgs = atoi(attr->value);
 555                 else if (!strcmp(attr->name, "watched"))
 556                         item->watched_msgs = atoi(attr->value);
 557                 else if (!strcmp(attr->name, "order"))
 558                         item->order = atoi(attr->value);
 559                 else if (!strcmp(attr->name, "total"))
 560                         item->total_msgs = atoi(attr->value);
 561                 else if (!strcmp(attr->name, "no_sub"))
 562                         item->no_sub = *attr->value == '1' ? TRUE : FALSE;
 563                 else if (!strcmp(attr->name, "no_select"))
 564                         item->no_select = *attr->value == '1' ? TRUE : FALSE;
 565                 else if (!strcmp(attr->name, "collapsed"))
 566                         item->collapsed = *attr->value == '1' ? TRUE : FALSE;
 567                 else if (!strcmp(attr->name, "thread_collapsed"))
 568                         item->thread_collapsed =  *attr->value == '1' ? TRUE : FALSE;
 569                 else if (!strcmp(attr->name, "threaded"))
 570                         item->threaded =  *attr->value == '1' ? TRUE : FALSE;
 571                 else if (!strcmp(attr->name, "hidereadmsgs"))
 572                         item->hide_read_msgs =  *attr->value == '1' ? TRUE : FALSE;
 573                 else if (!strcmp(attr->name, "reqretrcpt"))
 574                         item->ret_rcpt =  *attr->value == '1' ? TRUE : FALSE;
 575                 else if (!strcmp(attr->name, "sort_key")) {
 576                         if (!strcmp(attr->value, "none"))
 577                                 item->sort_key = SORT_BY_NONE;
 578                         else if (!strcmp(attr->value, "number"))
 579                                 item->sort_key = SORT_BY_NUMBER;
 580                         else if (!strcmp(attr->value, "size"))
 581                                 item->sort_key = SORT_BY_SIZE;
 582                         else if (!strcmp(attr->value, "date"))
 583                                 item->sort_key = SORT_BY_DATE;
 584                         else if (!strcmp(attr->value, "from"))
 585                                 item->sort_key = SORT_BY_FROM;
 586                         else if (!strcmp(attr->value, "subject"))
 587                                 item->sort_key = SORT_BY_SUBJECT;
 588                         else if (!strcmp(attr->value, "score"))
 589                                 item->sort_key = SORT_BY_SCORE;
 590                         else if (!strcmp(attr->value, "label"))
 591                                 item->sort_key = SORT_BY_LABEL;
 592                         else if (!strcmp(attr->value, "mark"))
 593                                 item->sort_key = SORT_BY_MARK;
 594                         else if (!strcmp(attr->value, "unread"))
 595                                 item->sort_key = SORT_BY_STATUS;
 596                         else if (!strcmp(attr->value, "mime"))
 597                                 item->sort_key = SORT_BY_MIME;
 598                         else if (!strcmp(attr->value, "to"))
 599                                 item->sort_key = SORT_BY_TO;
 600                         else if (!strcmp(attr->value, "locked"))
 601                                 item->sort_key = SORT_BY_LOCKED;
 602                         else if (!strcmp(attr->value, "tags"))
 603                                 item->sort_key = SORT_BY_TAGS;
 604                         else if (!strcmp(attr->value, "thread_date"))
 605                                 item->sort_key = SORT_BY_THREAD_DATE;
 606                 } else if (!strcmp(attr->name, "sort_type")) {
 607                         if (!strcmp(attr->value, "ascending"))
 608                                 item->sort_type = SORT_ASCENDING;
 609                         else
 610                                 item->sort_type = SORT_DESCENDING;
 611                 } else if (!strcmp(attr->name, "account_id")) {
 612                         PrefsAccount *account;
 613
 614                         account = account_find_from_id(atoi(attr->value));
 615                         if (!account)
 616                                 g_warning("account_id: %s not found\n", attr->value);
 617                         else
 618                                 item->account = account;
 619                 } else if (!strcmp(attr->name, "apply_sub")) {
 620                         item->apply_sub = *attr->value == '1' ? TRUE : FALSE;
 621                 } else if (!strcmp(attr->name, "last_seen")) {
 622                         if (!claws_crashed())
 623                                 item->last_seen = atoi(attr->value);
 624                         else
 625                                 item->last_seen = 0;
 626                 }
 627         }
 628 }
 629
 630 XMLTag *folder_item_get_xml(Folder *folder, FolderItem *item)
 631 {
 632         static gchar *folder_item_stype_str[] = {"normal", "inbox", "outbox",
 633                                                  "draft", "queue", "trash"};
 634         static gchar *sort_key_str[] = {"none", "number", "size", "date",
 635                                         "from", "subject", "score", "label",
 636                                         "mark", "unread", "mime", "to",
 637                                         "locked", "tags", "thread_date" };
 638         XMLTag *tag;
 639         gchar *value;
 640
 641         tag = xml_tag_new("folderitem");
 642
 643         xml_tag_add_attr(tag, xml_attr_new("type", folder_item_stype_str[item->stype]));
 644         if (item->name)
 645                 xml_tag_add_attr(tag, xml_attr_new("name", item->name));
 646         if (item->path)
 647                 xml_tag_add_attr(tag, xml_attr_new("path", item->path));
 648         if (item->no_sub)
 649                 xml_tag_add_attr(tag, xml_attr_new("no_sub", "1"));
 650         if (item->no_select)
 651                 xml_tag_add_attr(tag, xml_attr_new("no_select", "1"));
 652         xml_tag_add_attr(tag, xml_attr_new("collapsed", item->collapsed && item->node->children ? "1" : "0"));
 653         xml_tag_add_attr(tag, xml_attr_new("thread_collapsed", item->thread_collapsed ? "1" : "0"));
 654         xml_tag_add_attr(tag, xml_attr_new("threaded", item->threaded ? "1" : "0"));
 655         xml_tag_add_attr(tag, xml_attr_new("hidereadmsgs", item->hide_read_msgs ? "1" : "0"));
 656         if (item->ret_rcpt)
 657                 xml_tag_add_attr(tag, xml_attr_new("reqretrcpt", "1"));
 658
 659         if (item->sort_key != SORT_BY_NONE) {
 660                 xml_tag_add_attr(tag, xml_attr_new("sort_key", sort_key_str[item->sort_key]));
 661                 xml_tag_add_attr(tag, xml_attr_new("sort_type", item->sort_type == SORT_ASCENDING ? "ascending" : "descending"));
 662         }
 663
 664         value = g_strdup_printf("%ld", (unsigned long int) item->mtime);
 665         xml_tag_add_attr(tag, xml_attr_new("mtime", value));
 666         g_free(value);
 667         xml_tag_add_attr(tag, xml_attr_new_int("new", item->new_msgs));
 668         xml_tag_add_attr(tag, xml_attr_new_int("unread", item->unread_msgs));
 669         xml_tag_add_attr(tag, xml_attr_new_int("unreadmarked", item->unreadmarked_msgs));
 670         xml_tag_add_attr(tag, xml_attr_new_int("marked", item->marked_msgs));
 671         xml_tag_add_attr(tag, xml_attr_new_int("total", item->total_msgs));
 672         xml_tag_add_attr(tag, xml_attr_new_int("replied", item->replied_msgs));
 673         xml_tag_add_attr(tag, xml_attr_new_int("forwarded", item->forwarded_msgs));
 674         xml_tag_add_attr(tag, xml_attr_new_int("locked", item->locked_msgs));
 675         xml_tag_add_attr(tag, xml_attr_new_int("ignore", item->ignored_msgs));
 676         xml_tag_add_attr(tag, xml_attr_new_int("watched", item->watched_msgs));
 677         xml_tag_add_attr(tag, xml_attr_new_int("order", item->order));
 678
 679         if (item->account)
 680                 xml_tag_add_attr(tag, xml_attr_new_int("account_id", item->account->account_id));
 681         if (item->apply_sub)
 682                 xml_tag_add_attr(tag, xml_attr_new("apply_sub", "1"));
 683
 684         xml_tag_add_attr(tag, xml_attr_new_int("last_seen", item->last_seen));
 685
 686         return tag;
 687 }
 688
 689 void folder_set_ui_func(Folder *folder, FolderUIFunc func, gpointer data)
 690 {
 691         g_return_if_fail(folder != NULL);
 692
 693         folder->ui_func = func;
 694         folder->ui_func_data = data;
 695 }
 696
 697 void folder_set_name(Folder *folder, const gchar *name)
 698 {
 699         g_return_if_fail(folder != NULL);
 700
 701         g_free(folder->name);
 702         folder->name = name ? g_strdup(name) : NULL;
 703         if (folder->node && folder->node->data) {
 704                 FolderItem *item = (FolderItem *)folder->node->data;
 705
 706                 g_free(item->name);
 707                 item->name = name ? g_strdup(name) : NULL;
 708         }
 709 }
 710
 711 void folder_set_sort(Folder *folder, guint sort)
 712 {
 713         g_return_if_fail(folder != NULL);
 714
 715         if (folder->sort != sort) {
 716                 folder_remove(folder);
 717                 folder->sort = sort;
 718                 folder_add(folder);
 719         }
 720 }
 721
 722 static gboolean folder_tree_destroy_func(GNode *node, gpointer data) {
 723         FolderItem *item = (FolderItem *) node->data;
 724
 725         folder_item_destroy(item);
 726         return FALSE;
 727 }
 728
 729 void folder_tree_destroy(Folder *folder)
 730 {
 731         GNode *node;
 732
 733         g_return_if_fail(folder != NULL);
 734
 735         node = folder->node;
 736
 737         prefs_filtering_clear_folder(folder);
 738
 739         if (node != NULL) {
 740                 g_node_traverse(node, G_POST_ORDER, G_TRAVERSE_ALL, -1,
 741                                 folder_tree_destroy_func, NULL);
 742                 g_node_destroy(node);
 743                 folder->node = NULL;
 744         }
 745 }
 746
 747 void folder_add(Folder *folder)
 748 {
 749         Folder *cur_folder;
 750         GList *cur;
 751         gint i;
 752         FolderUpdateData hookdata;
 753
 754         g_return_if_fail(folder != NULL);
 755
 756         if ((FOLDER_TYPE(folder) == F_IMAP ||
 757              FOLDER_TYPE(folder) == F_NEWS) &&
 758             folder->account == NULL) {
 759                 return;
 760         }
 761
 762         for (i = 0, cur = folder_list; cur != NULL; cur = cur->next, i++) {
 763                 cur_folder = FOLDER(cur->data);
 764                 if (cur_folder->sort < folder->sort)
 765                         break;
 766         }
 767
 768         folder_list = g_list_insert(folder_list, folder, i);
 769
 770         hookdata.folder = folder;
 771         hookdata.update_flags = FOLDER_ADD_FOLDER;
 772         hookdata.item = NULL;
 773         hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 774 }
 775
 776 void folder_remove(Folder *folder)
 777 {
 778         FolderUpdateData hookdata;
 779
 780         g_return_if_fail(folder != NULL);
 781
 782         folder_list = g_list_remove(folder_list, folder);
 783
 784         hookdata.folder = folder;
 785         hookdata.update_flags = FOLDER_REMOVE_FOLDER;
 786         hookdata.item = NULL;
 787         hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 788 }
 789
 790 GList *folder_get_list(void)
 791 {
 792         return folder_list;
 793 }
 794
 795 gint folder_read_list(void)
 796 {
 797         GNode *node, *cur;
 798         XMLNode *xmlnode;
 799         gchar *path;
 800
 801         path = folder_get_list_path();
 802         if (!is_file_exist(path)) return -1;
 803         node = xml_parse_file(path);
 804         if (!node) return -1;
 805
 806         xmlnode = node->data;
 807         if (strcmp2(xmlnode->tag->tag, "folderlist") != 0) {
 808                 g_warning("wrong folder list\n");
 809                 xml_free_tree(node);
 810                 return -1;
 811         }
 812
 813         cur = node->children;
 814         while (cur != NULL) {
 815                 Folder *folder;
 816
 817                 folder = folder_get_from_xml(cur);
 818                 if (folder != NULL)
 819                         folder_add(folder);
 820                 else
 821                         folder_unloaded_list = g_slist_append(folder_unloaded_list,
 822                                 (gpointer) xml_copy_tree(cur));
 823                 cur = cur->next;
 824         }
 825
 826         xml_free_tree(node);
 827         if (folder_list || folder_unloaded_list)
 828                 return 0;
 829         else
 830                 return -1;
 831 }
 832
 833 void folder_write_list(void)
 834 {
 835         GList *list;
 836         GSList *slist;
 837         Folder *folder;
 838         gchar *path;
 839         PrefFile *pfile;
 840         GNode *rootnode;
 841         XMLNode *xmlnode;
 842         XMLTag *tag;
 843
 844         path = folder_get_list_path();
 845         if ((pfile = prefs_write_open(path)) == NULL) return;
 846
 847         if (xml_file_put_xml_decl(pfile->fp) < 0) {
 848                 prefs_file_close_revert(pfile);
 849                 g_warning("failed to start write folder list.\n");
 850                 return;
 851         }
 852         tag = xml_tag_new("folderlist");
 853
 854         xmlnode = xml_node_new(tag, NULL);
 855
 856         rootnode = g_node_new(xmlnode);
 857
 858         for (list = folder_list; list != NULL; list = list->next) {
 859                 GNode *node;
 860
 861                 folder = list->data;
 862                 node = folder_get_xml_node(folder);
 863                 if (node != NULL)
 864                         g_node_append(rootnode, node);
 865         }
 866
 867         for (slist = folder_unloaded_list; slist != NULL; slist = g_slist_next(slist)) {
 868                 GNode *node = (GNode *) slist->data;
 869
 870                 g_node_append(rootnode, (gpointer) xml_copy_tree(node));
 871         }
 872
 873         if (xml_write_tree(rootnode, pfile->fp) < 0) {
 874                 prefs_file_close_revert(pfile);
 875                 g_warning("failed to write folder list.\n");
 876         } else if (prefs_file_close(pfile) < 0) {
 877                 g_warning("failed to write folder list.\n");
 878         }
 879         xml_free_tree(rootnode);
 880 }
 881
 882 static gboolean folder_scan_tree_func(GNode *node, gpointer data)
 883 {
 884         GHashTable *pptable = (GHashTable *)data;
 885         FolderItem *item = (FolderItem *)node->data;
 886
 887         folder_item_restore_persist_prefs(item, pptable);
 888         folder_item_scan_full(item, FALSE);
 889
 890         return FALSE;
 891 }
 892
 893 void folder_scan_tree(Folder *folder, gboolean rebuild)
 894 {
 895         GHashTable *pptable;
 896         FolderUpdateData hookdata;
 897         Folder *old_folder = folder;
 898
 899         if (!folder->klass->scan_tree)
 900                 return;
 901
 902         pptable = folder_persist_prefs_new(folder);
 903
 904         if (rebuild)
 905                 folder_remove(folder);
 906
 907         if (folder->klass->scan_tree(folder) < 0) {
 908                 if (rebuild)
 909                         folder_add(old_folder);
 910                 return;
 911         } else if (rebuild)
 912                 folder_add(folder);
 913
 914         hookdata.folder = folder;
 915         hookdata.update_flags = FOLDER_TREE_CHANGED;
 916         hookdata.item = NULL;
 917         hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 918
 919         g_node_traverse(folder->node, G_POST_ORDER, G_TRAVERSE_ALL, -1, folder_scan_tree_func, pptable);
 920         folder_persist_prefs_free(pptable);
 921
 922         prefs_matcher_read_config();
 923
 924         folder_write_list();
 925 }
 926
 927 static gboolean folder_restore_prefs_func(GNode *node, gpointer data)
 928 {
 929         GHashTable *pptable = (GHashTable *)data;
 930         FolderItem *item = (FolderItem *)node->data;
 931
 932         folder_item_restore_persist_prefs(item, pptable);
 933
 934         return FALSE;
 935 }
 936
 937 void folder_fast_scan_tree(Folder *folder)
 938 {
 939         GHashTable *pptable;
 940         FolderUpdateData hookdata;
 941
 942         if (!folder->klass->scan_tree)
 943                 return;
 944
 945         pptable = folder_persist_prefs_new(folder);
 946
 947         if (folder->klass->scan_tree(folder) < 0) {
 948                 return;
 949         }
 950
 951         hookdata.folder = folder;
 952         hookdata.update_flags = FOLDER_TREE_CHANGED;
 953         hookdata.item = NULL;
 954         hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 955
 956         g_node_traverse(folder->node, G_POST_ORDER, G_TRAVERSE_ALL, -1, folder_restore_prefs_func, pptable);
 957         folder_persist_prefs_free(pptable);
 958
 959         prefs_matcher_read_config();
 960
 961         folder_write_list();
 962 }
 963
 964 FolderItem *folder_create_folder(FolderItem *parent, const gchar *name)
 965 {
 966         FolderItem *new_item;
 967
 968         new_item = parent->folder->klass->create_folder(parent->folder, parent, name);
 969         if (new_item) {
 970                 FolderUpdateData hookdata;
 971
 972                 new_item->cache = msgcache_new();
 973
 974                 hookdata.folder = new_item->folder;
 975                 hookdata.update_flags = FOLDER_TREE_CHANGED | FOLDER_ADD_FOLDERITEM;
 976                 hookdata.item = new_item;
 977                 hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata);
 978         }
 979
 980         return new_item;
 981 }
 982
 983 gint folder_item_rename(FolderItem *item, gchar *newname)
 984 {
 985         gint retval;
 986
 987         g_return_val_if_fail(item != NULL, -1);
 988         g_return_val_if_fail(newname != NULL, -1);
 989
 990         retval = item->folder->klass->rename_folder(item->folder, item, newname);
 991
 992         if (retval >= 0) {
 993                 FolderItemUpdateData hookdata;
 994                 FolderUpdateData hookdata2;
 995
 996                 hookdata.item = item;
 997                 hookdata.update_flags = F_ITEM_UPDATE_NAME;
 998                 hookdata.msg = NULL;
 999                 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &hookdata);
1000
1001                 hookdata2.folder = item->folder;
1002                 hookdata2.item = item;
1003                 hookdata2.update_flags = FOLDER_RENAME_FOLDERITEM;
1004                 hooks_invoke(FOLDER_UPDATE_HOOKLIST, &hookdata2);
1005         }
1006
1007         return retval;
1008 }
1009
1010 struct TotalMsgCount
1011 {
1012         guint new_msgs;
1013         guint unread_msgs;
1014         guint unreadmarked_msgs;
1015         guint marked_msgs;
1016         guint total_msgs;
1017         guint replied_msgs;
1018         guint forwarded_msgs;
1019         guint locked_msgs;
1020         guint ignored_msgs;
1021         guint watched_msgs;
1022 };
1023
1024 struct FuncToAllFoldersData
1025 {
1026         FolderItemFunc  function;
1027         gpointer        data;
1028 };
1029
1030 static gboolean folder_func_to_all_folders_func(GNode *node, gpointer data)
1031 {
1032         FolderItem *item;
1033         struct FuncToAllFoldersData *function_data = (struct FuncToAllFoldersData *) data;
1034
1035         g_return_val_if_fail(node->data != NULL, FALSE);
1036
1037         item = FOLDER_ITEM(node->data);
1038         g_return_val_if_fail(item != NULL, FALSE);
1039
1040         function_data->function(item, function_data->data);
1041
1042         return FALSE;
1043 }
1044
1045 void folder_func_to_all_folders(FolderItemFunc function, gpointer data)
1046 {
1047         GList *list;
1048         Folder *folder;
1049         struct FuncToAllFoldersData function_data;
1050
1051         function_data.function = function;
1052         function_data.data = data;
1053
1054         for (list = folder_list; list != NULL; list = list->next) {
1055                 folder = FOLDER(list->data);
1056                 if (folder->node)
1057                         g_node_traverse(folder->node, G_PRE_ORDER,
1058                                         G_TRAVERSE_ALL, -1,
1059                                         folder_func_to_all_folders_func,
1060                                         &function_data);
1061         }
1062 }
1063
1064 static void folder_count_total_msgs_func(FolderItem *item, gpointer data)
1065 {
1066         struct TotalMsgCount *count = (struct TotalMsgCount *)data;
1067
1068         count->new_msgs += item->new_msgs;
1069         count->unread_msgs += item->unread_msgs;
1070         count->unreadmarked_msgs += item->unreadmarked_msgs;
1071         count->marked_msgs += item->marked_msgs;
1072         count->total_msgs += item->total_msgs;
1073         count->replied_msgs += item->replied_msgs;
1074         count->forwarded_msgs += item->forwarded_msgs;
1075         count->locked_msgs += item->locked_msgs;
1076         count->ignored_msgs += item->ignored_msgs;
1077         count->watched_msgs += item->watched_msgs;
1078 }
1079
1080 struct TotalMsgStatus
1081 {
1082         guint new;
1083         guint unread;
1084         guint total;
1085         GString *str;
1086 };
1087
1088 static gboolean folder_get_status_full_all_func(GNode *node, gpointer data)
1089 {
1090         FolderItem *item;
1091         struct TotalMsgStatus *status = (struct TotalMsgStatus *)data;
1092         gchar *id;
1093
1094         g_return_val_if_fail(node->data != NULL, FALSE);
1095
1096         item = FOLDER_ITEM(node->data);
1097
1098         if (!item->path) return FALSE;
1099
1100         status->new += item->new_msgs;
1101         status->unread += item->unread_msgs;
1102         status->total += item->total_msgs;
1103
1104         if (status->str) {
1105                 id = folder_item_get_identifier(item);
1106                 g_string_append_printf(status->str, "%5d %5d %5d %s\n",
1107                                   item->new_msgs, item->unread_msgs,
1108                                   item->total_msgs, id);
1109                 g_free(id);
1110         }
1111
1112         return FALSE;
1113  }
1114
1115 static void folder_get_status_full_all(GString *str, guint *new, guint *unread,
1116                                        guint *total)
1117 {
1118         GList *list;
1119         Folder *folder;
1120         struct TotalMsgStatus status;
1121
1122         status.new = status.unread = status.total = 0;
1123         status.str = str;
1124
1125         debug_print("Counting total number of messages...\n");
1126
1127         for (list = folder_list; list != NULL; list = list->next) {
1128                 folder = FOLDER(list->data);
1129                 if (folder->node)
1130                         g_node_traverse(folder->node, G_PRE_ORDER,
1131                                         G_TRAVERSE_ALL, -1,
1132                                         folder_get_status_full_all_func,
1133                                         &status);
1134         }
1135
1136         *new = status.new;
1137         *unread = status.unread;
1138         *total = status.total;
1139 }
1140
1141 gchar *folder_get_status(GPtrArray *folders, gboolean full)
1142 {
1143         guint new, unread, total;
1144         GString *str;
1145         gint i;
1146         gchar *ret;
1147
1148         new = unread = total = 0;
1149
1150         str = g_string_new(NULL);
1151
1152         if (folders) {
1153                 for (i = 0; i < folders->len; i++) {
1154                         FolderItem *item;
1155
1156                         item = g_ptr_array_index(folders, i);
1157                         new += item->new_msgs;
1158                         unread += item->unread_msgs;
1159                         total += item->total_msgs;
1160
1161                         if (full) {
1162                                 gchar *id;
1163
1164                                 id = folder_item_get_identifier(item);
1165                                 g_string_append_printf(str, "%5d %5d %5d %s\n",
1166                                                   item->new_msgs, item->unread_msgs,
1167                                                   item->total_msgs, id);
1168                                 g_free(id);
1169                         }
1170                 }
1171         } else {
1172                 folder_get_status_full_all(full ? str : NULL,
1173                                            &new, &unread, &total);
1174         }
1175
1176         if (full)
1177                 g_string_append_printf(str, "%5d %5d %5d\n", new, unread, total);
1178         else
1179                 g_string_append_printf(str, "%d %d %d\n", new, unread, total);
1180
1181         ret = str->str;
1182         g_string_free(str, FALSE);
1183
1184         return ret;
1185 }
1186
1187 void folder_count_total_msgs(guint *new_msgs, guint *unread_msgs,
1188                              guint *unreadmarked_msgs, guint *marked_msgs,
1189                              guint *total_msgs, guint *replied_msgs,
1190                              guint *forwarded_msgs, guint *locked_msgs,
1191                              guint *ignored_msgs, guint *watched_msgs)
1192 {
1193         struct TotalMsgCount count;
1194
1195         count.new_msgs = count.unread_msgs = count.unreadmarked_msgs = 0;
1196         count.total_msgs = count.replied_msgs = count.forwarded_msgs = 0;
1197         count.locked_msgs = count.ignored_msgs = count.watched_msgs = 0;
1198         count.marked_msgs = 0;
1199
1200         debug_print("Counting total number of messages...\n");
1201
1202         folder_func_to_all_folders(folder_count_total_msgs_func, &count);
1203
1204         *new_msgs = count.new_msgs;
1205         *unread_msgs = count.unread_msgs;
1206         *unreadmarked_msgs = count.unreadmarked_msgs;
1207         *marked_msgs = count.marked_msgs;
1208         *total_msgs = count.total_msgs;
1209         *replied_msgs = count.replied_msgs;
1210         *forwarded_msgs = count.forwarded_msgs;
1211         *locked_msgs = count.locked_msgs;
1212         *ignored_msgs = count.ignored_msgs;
1213         *watched_msgs = count.watched_msgs;
1214 }
1215
1216 Folder *folder_find_from_path(const gchar *path)
1217 {
1218         GList *list;
1219         Folder *folder;
1220
1221         for (list = folder_list; list != NULL; list = list->next) {
1222                 folder = list->data;
1223                 if ((FOLDER_TYPE(folder) == F_MH ||
1224                      FOLDER_TYPE(folder) == F_MBOX) &&
1225                     !path_cmp(LOCAL_FOLDER(folder)->rootpath, path))
1226                         return folder;
1227         }
1228
1229         return NULL;
1230 }
1231
1232 Folder *folder_find_from_name(const gchar *name, FolderClass *klass)
1233 {
1234         GList *list;
1235         Folder *folder;
1236
1237         for (list = folder_list; list != NULL; list = list->next) {
1238                 folder = list->data;
1239                 if (folder->klass == klass &&
1240                     strcmp2(name, folder->name) == 0)
1241                         return folder;
1242         }
1243
1244         return NULL;
1245 }
1246
1247 static gboolean folder_item_find_func(GNode *node, gpointer data)
1248 {
1249         FolderItem *item = node->data;
1250         gpointer *d = data;
1251         const gchar *path = d[0];
1252
1253         if (path_cmp(path, item->path) != 0)
1254                 return FALSE;
1255
1256         d[1] = item;
1257
1258         return TRUE;
1259 }
1260
1261 FolderItem *folder_find_item_from_path(const gchar *path)
1262 {
1263         Folder *folder;
1264         gpointer d[2];
1265         GList *list = folder_get_list();
1266
1267         folder = list ? list->data:NULL;
1268
1269         g_return_val_if_fail(folder != NULL, NULL);
1270
1271         d[0] = (gpointer)path;
1272         d[1] = NULL;
1273         while (d[1] == NULL && list) {
1274                 folder = FOLDER(list->data);
1275                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1276                         folder_item_find_func, d);
1277                 list = list->next;
1278         }
1279         return d[1];
1280 }
1281
1282 static gboolean folder_item_find_func_real_path(GNode *node, gpointer data)
1283 {
1284         FolderItem *item = node->data;
1285         gpointer *d = data;
1286         const gchar *path = d[0];
1287         gchar *tmp = folder_item_get_path(item);
1288         if (path_cmp(path, tmp) != 0) {
1289                 g_free(tmp);
1290                 return FALSE;
1291         }
1292         g_free(tmp);
1293         d[1] = item;
1294
1295         return TRUE;
1296 }
1297
1298 FolderItem *folder_find_item_from_real_path(const gchar *path)
1299 {
1300         Folder *folder;
1301         gpointer d[2];
1302         GList *list = folder_get_list();
1303
1304         folder = list ? list->data:NULL;
1305
1306         g_return_val_if_fail(folder != NULL, NULL);
1307
1308         d[0] = (gpointer)path;
1309         d[1] = NULL;
1310         while (d[1] == NULL && list) {
1311                 folder = FOLDER(list->data);
1312                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1313                         folder_item_find_func_real_path, d);
1314                 list = list->next;
1315         }
1316         return d[1];
1317 }
1318
1319 FolderItem *folder_find_child_item_by_name(FolderItem *item, const gchar *name)
1320 {
1321         GNode *node;
1322         FolderItem *child;
1323
1324         for (node = item->node->children; node != NULL; node = node->next) {
1325                 gchar *base;
1326                 child = FOLDER_ITEM(node->data);
1327                 base = g_path_get_basename(child->path);
1328                 if (strcmp2(base, name) == 0) {
1329                         g_free(base);
1330                         return child;
1331                 }
1332                 g_free(base);
1333         }
1334
1335         return NULL;
1336 }
1337
1338 FolderClass *folder_get_class_from_string(const gchar *str)
1339 {
1340         GSList *classlist;
1341
1342         classlist = folder_get_class_list();
1343         for (; classlist != NULL; classlist = g_slist_next(classlist)) {
1344                 FolderClass *class = (FolderClass *) classlist->data;
1345                 if (g_ascii_strcasecmp(class->idstr, str) == 0)
1346                         return class;
1347         }
1348
1349         return NULL;
1350 }
1351
1352 gchar *folder_get_identifier(Folder *folder)
1353 {
1354         gchar *type_str;
1355
1356         g_return_val_if_fail(folder != NULL, NULL);
1357
1358         type_str = folder->klass->idstr;
1359         return g_strconcat("#", type_str, "/", folder->name, NULL);
1360 }
1361
1362 gchar *folder_item_get_identifier(FolderItem *item)
1363 {
1364         gchar *id = NULL;
1365         gchar *folder_id = NULL;
1366
1367         g_return_val_if_fail(item != NULL, NULL);
1368
1369         if (item->path == NULL)
1370                 return NULL;
1371
1372         folder_id = folder_get_identifier(item->folder);
1373         id = g_strconcat(folder_id, "/", item->path, NULL);
1374         g_free(folder_id);
1375
1376         return id;
1377 }
1378
1379 FolderItem *folder_find_item_from_identifier(const gchar *identifier)
1380 {
1381         Folder *folder;
1382         gpointer d[2];
1383         gchar *str;
1384         gchar *p;
1385         gchar *name;
1386         gchar *path;
1387         FolderClass *class;
1388
1389         g_return_val_if_fail(identifier != NULL, NULL);
1390
1391         if (*identifier != '#')
1392                 return folder_find_item_from_path(identifier);
1393
1394         Xstrdup_a(str, identifier, return NULL);
1395
1396         p = strchr(str, '/');
1397         if (!p)
1398                 return folder_find_item_from_path(identifier);
1399         *p = '\0';
1400         p++;
1401         class = folder_get_class_from_string(&str[1]);
1402         if (class == NULL)
1403                 return folder_find_item_from_path(identifier);
1404
1405         name = p;
1406         p = strchr(p, '/');
1407         if (!p)
1408                 return folder_find_item_from_path(identifier);
1409         *p = '\0';
1410         p++;
1411
1412         folder = folder_find_from_name(name, class);
1413         if (!folder)
1414                 return folder_find_item_from_path(identifier);
1415
1416         path = p;
1417
1418         d[0] = (gpointer)path;
1419         d[1] = NULL;
1420         g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1421                         folder_item_find_func, d);
1422         return d[1];
1423 }
1424
1425 /**
1426  * Get a displayable name for a FolderItem
1427  *
1428  * \param item FolderItem for that a name should be created
1429  * \return Displayable name for item, returned string has to
1430  *         be freed
1431  */
1432 gchar *folder_item_get_name(FolderItem *item)
1433 {
1434         gchar *name = NULL;
1435
1436         g_return_val_if_fail(item != NULL, g_strdup(""));
1437
1438         switch (item->stype) {
1439         case F_INBOX:
1440                 name = g_strdup(!strcmp2(item->name, INBOX_DIR) ? _("Inbox") :
1441                                 item->name);
1442                 break;
1443         case F_OUTBOX:
1444                 name = g_strdup(!strcmp2(item->name, OUTBOX_DIR) ? _("Sent") :
1445                                 item->name);
1446                 break;
1447         case F_QUEUE:
1448                 name = g_strdup(!strcmp2(item->name, QUEUE_DIR) ? _("Queue") :
1449                                 item->name);
1450                 break;
1451         case F_TRASH:
1452                 name = g_strdup(!strcmp2(item->name, TRASH_DIR) ? _("Trash") :
1453                                 item->name);
1454                 break;
1455         case F_DRAFT:
1456                 name = g_strdup(!strcmp2(item->name, DRAFT_DIR) ? _("Drafts") :
1457                                 item->name);
1458                 break;
1459         default:
1460                 break;
1461         }
1462
1463         if (name == NULL) {
1464                 /*
1465                  * should probably be done by a virtual function,
1466                  * the folder knows the ui string and how to abbrev
1467                 */
1468                 if (folder_item_parent(item) == NULL) {
1469                         name = g_strconcat(item->name, " (", item->folder->klass->uistr, ")", NULL);
1470                 } else {
1471                         if (FOLDER_CLASS(item->folder) == news_get_class() &&
1472                             item->path && !strcmp2(item->name, item->path))
1473                                 name = get_abbrev_newsgroup_name
1474                                         (item->path,
1475                                          prefs_common.ng_abbrev_len);
1476                         else
1477                                 name = g_strdup(item->name);
1478                 }
1479         }
1480
1481         if (name == NULL)
1482                 name = g_strdup("");
1483
1484         return name;
1485 }
1486
1487 gboolean folder_have_mailbox (void)
1488 {
1489         GList *cur;
1490         for (cur = folder_list; cur != NULL; cur = g_list_next(cur)) {
1491                 Folder *folder = FOLDER(cur->data);
1492                 if (folder->inbox && folder->outbox)
1493                         return TRUE;
1494         }
1495         return FALSE;
1496 }
1497
1498 FolderItem *folder_get_default_inbox(void)
1499 {
1500         GList *flist;
1501
1502         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1503                 Folder * folder = FOLDER(flist->data);
1504
1505                 if (folder == NULL)
1506                         continue;
1507                 if (folder->inbox == NULL)
1508                         continue;
1509                 if (folder->klass->type == F_UNKNOWN)
1510                         continue;
1511
1512                 return folder->inbox;
1513         }
1514
1515         return NULL;
1516 }
1517
1518 FolderItem *folder_get_default_inbox_for_class(FolderType type)
1519 {
1520         GList *flist;
1521
1522         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1523                 Folder * folder = FOLDER(flist->data);
1524
1525                 if (folder == NULL)
1526                         continue;
1527                 if (folder->inbox == NULL)
1528                         continue;
1529                 if (folder->klass->type != type)
1530                         continue;
1531
1532                 return folder->inbox;
1533         }
1534
1535         return NULL;
1536 }
1537
1538 FolderItem *folder_get_default_outbox(void)
1539 {
1540         GList *flist;
1541
1542         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1543                 Folder * folder = FOLDER(flist->data);
1544
1545                 if (folder == NULL)
1546                         continue;
1547                 if (folder->outbox == NULL)
1548                         continue;
1549                 if (folder->klass->type == F_UNKNOWN)
1550                         continue;
1551
1552                 return folder->outbox;
1553         }
1554
1555         return NULL;
1556 }
1557
1558 FolderItem *folder_get_default_outbox_for_class(FolderType type)
1559 {
1560         GList *flist;
1561
1562         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1563                 Folder * folder = FOLDER(flist->data);
1564
1565                 if (folder == NULL)
1566                         continue;
1567                 if (folder->outbox == NULL)
1568                         continue;
1569                 if (folder->klass->type != type)
1570                         continue;
1571
1572                 return folder->outbox;
1573         }
1574
1575         return NULL;
1576 }
1577
1578 FolderItem *folder_get_default_draft(void)
1579 {
1580         GList *flist;
1581
1582         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1583                 Folder * folder = FOLDER(flist->data);
1584
1585                 if (folder == NULL)
1586                         continue;
1587                 if (folder->draft == NULL)
1588                         continue;
1589                 if (folder->klass->type == F_UNKNOWN)
1590                         continue;
1591
1592                 return folder->draft;
1593         }
1594
1595         return NULL;
1596 }
1597
1598 FolderItem *folder_get_default_draft_for_class(FolderType type)
1599 {
1600         GList *flist;
1601
1602         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1603                 Folder * folder = FOLDER(flist->data);
1604
1605                 if (folder == NULL)
1606                         continue;
1607                 if (folder->draft == NULL)
1608                         continue;
1609                 if (folder->klass->type != type)
1610                         continue;
1611
1612                 return folder->draft;
1613         }
1614
1615         return NULL;
1616 }
1617
1618 FolderItem *folder_get_default_queue(void)
1619 {
1620         GList *flist;
1621
1622         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1623                 Folder * folder = FOLDER(flist->data);
1624
1625                 if (folder == NULL)
1626                         continue;
1627                 if (folder->queue == NULL)
1628                         continue;
1629                 if (folder->klass->type == F_UNKNOWN)
1630                         continue;
1631
1632                 return folder->queue;
1633         }
1634
1635         return NULL;
1636 }
1637
1638 FolderItem *folder_get_default_queue_for_class(FolderType type)
1639 {
1640         GList *flist;
1641
1642         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1643                 Folder * folder = FOLDER(flist->data);
1644
1645                 if (folder == NULL)
1646                         continue;
1647                 if (folder->queue == NULL)
1648                         continue;
1649                 if (folder->klass->type != type)
1650                         continue;
1651
1652                 return folder->queue;
1653         }
1654
1655         return NULL;
1656 }
1657
1658 FolderItem *folder_get_default_trash(void)
1659 {
1660         GList *flist;
1661
1662         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1663                 Folder * folder = FOLDER(flist->data);
1664
1665                 if (folder == NULL)
1666                         continue;
1667                 if (folder->trash == NULL)
1668                         continue;
1669                 if (folder->klass->type == F_UNKNOWN)
1670                         continue;
1671
1672                 return folder->trash;
1673         }
1674
1675         return NULL;
1676 }
1677
1678 FolderItem *folder_get_default_trash_for_class(FolderType type)
1679 {
1680         GList *flist;
1681
1682         for (flist = folder_list; flist != NULL; flist = g_list_next(flist)) {
1683                 Folder * folder = FOLDER(flist->data);
1684
1685                 if (folder == NULL)
1686                         continue;
1687                 if (folder->trash == NULL)
1688                         continue;
1689                 if (folder->klass->type != type)
1690                         continue;
1691
1692                 return folder->trash;
1693         }
1694
1695         return NULL;
1696 }
1697
1698 #define CREATE_FOLDER_IF_NOT_EXIST(member, dir, type)           \
1699 {                                                               \
1700         if (!folder->member) {                                  \
1701                 item = folder_item_new(folder, dir, dir);       \
1702                 item->stype = type;                             \
1703                 folder_item_append(rootitem, item);             \
1704                 folder->member = item;                          \
1705         }                                                       \
1706 }
1707
1708 void folder_set_missing_folders(void)
1709 {
1710         Folder *folder;
1711         FolderItem *rootitem;
1712         FolderItem *item;
1713         GList *list;
1714
1715         for (list = folder_list; list != NULL; list = list->next) {
1716                 folder = list->data;
1717                 if (FOLDER_TYPE(folder) != F_MH) continue;
1718                 rootitem = FOLDER_ITEM(folder->node->data);
1719                 g_return_if_fail(rootitem != NULL);
1720
1721                 if (folder->inbox && folder->outbox && folder->draft &&
1722                     folder->queue && folder->trash)
1723                         continue;
1724
1725                 if (folder->klass->create_tree(folder) < 0) {
1726                         g_warning("%s: can't create the folder tree.\n",
1727                                   LOCAL_FOLDER(folder)->rootpath);
1728                         continue;
1729                 }
1730
1731                 CREATE_FOLDER_IF_NOT_EXIST(inbox,  INBOX_DIR,  F_INBOX);
1732                 CREATE_FOLDER_IF_NOT_EXIST(outbox, OUTBOX_DIR, F_OUTBOX);
1733                 CREATE_FOLDER_IF_NOT_EXIST(draft,  DRAFT_DIR,  F_DRAFT);
1734                 CREATE_FOLDER_IF_NOT_EXIST(queue,  QUEUE_DIR,  F_QUEUE);
1735                 CREATE_FOLDER_IF_NOT_EXIST(trash,  TRASH_DIR,  F_TRASH);
1736         }
1737 }
1738
1739 static gboolean folder_unref_account_func(GNode *node, gpointer data)
1740 {
1741         FolderItem *item = node->data;
1742         PrefsAccount *account = data;
1743
1744         if (item->account == account)
1745                 item->account = NULL;
1746
1747         return FALSE;
1748 }
1749
1750 void folder_unref_account_all(PrefsAccount *account)
1751 {
1752         Folder *folder;
1753         GList *list;
1754
1755         if (!account) return;
1756
1757         for (list = folder_list; list != NULL; list = list->next) {
1758                 folder = list->data;
1759                 if (folder->account == account)
1760                         folder->account = NULL;
1761                 g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1762                                 folder_unref_account_func, account);
1763         }
1764 }
1765
1766 #undef CREATE_FOLDER_IF_NOT_EXIST
1767
1768 gchar *folder_item_get_path(FolderItem *item)
1769 {
1770         Folder *folder;
1771
1772         g_return_val_if_fail(item != NULL, NULL);
1773         folder = item->folder;
1774         g_return_val_if_fail(folder != NULL, NULL);
1775
1776         return folder->klass->item_get_path(folder, item);
1777 }
1778
1779 static gint folder_sort_cache_list_by_msgnum(gconstpointer a, gconstpointer b)
1780 {
1781         MsgInfo *msginfo_a = (MsgInfo *) a;
1782         MsgInfo *msginfo_b = (MsgInfo *) b;
1783
1784         return (msginfo_a->msgnum - msginfo_b->msgnum);
1785 }
1786
1787 static gint folder_sort_folder_list(gconstpointer a, gconstpointer b)
1788 {
1789         guint gint_a = GPOINTER_TO_INT(a);
1790         guint gint_b = GPOINTER_TO_INT(b);
1791
1792         return (gint_a - gint_b);
1793 }
1794
1795 static gint syncronize_flags(FolderItem *item, MsgInfoList *msglist)
1796 {
1797         GRelation *relation;
1798         gint ret = 0;
1799         GSList *cur;
1800
1801         if(msglist == NULL)
1802                 return 0;
1803         if(item->folder->klass->get_flags == NULL)
1804                 return 0;
1805         if (item->no_select)
1806                 return 0;
1807
1808         relation = g_relation_new(2);
1809         g_relation_index(relation, 0, g_direct_hash, g_direct_equal);
1810         if ((ret = item->folder->klass->get_flags(
1811             item->folder, item, msglist, relation)) == 0) {
1812                 GTuples *tuples;
1813                 MsgInfo *msginfo;
1814                 MsgPermFlags permflags = 0;
1815                 gboolean skip;
1816
1817                 folder_item_update_freeze();
1818                 folder_item_set_batch(item, TRUE);
1819                 for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
1820                         msginfo = (MsgInfo *) cur->data;
1821
1822                         tuples = g_relation_select(relation, msginfo, 0);
1823                         skip = tuples->len < 1;
1824                         if (!skip)
1825                                 permflags = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
1826                         g_tuples_destroy(tuples);
1827                         if (skip)
1828                                 continue;
1829
1830                         if (msginfo->flags.perm_flags != permflags) {
1831                                 procmsg_msginfo_change_flags(msginfo,
1832                                         permflags & ~msginfo->flags.perm_flags, 0,
1833                                         ~permflags & msginfo->flags.perm_flags, 0);
1834                         }
1835                 }
1836                 folder_item_set_batch(item, FALSE);
1837                 folder_item_update_thaw();
1838         }
1839         g_relation_destroy(relation);
1840
1841         return ret;
1842 }
1843
1844 static gint folder_item_syncronize_flags(FolderItem *item)
1845 {
1846         MsgInfoList *msglist = NULL;
1847         GSList *cur;
1848         gint ret = 0;
1849
1850         g_return_val_if_fail(item != NULL, -1);
1851         g_return_val_if_fail(item->folder != NULL, -1);
1852         g_return_val_if_fail(item->folder->klass != NULL, -1);
1853         if (item->no_select)
1854                 return -1;
1855
1856         item->scanning = ITEM_SCANNING_WITH_FLAGS;
1857
1858         if (item->cache == NULL)
1859                 folder_item_read_cache(item);
1860
1861         msglist = msgcache_get_msg_list(item->cache);
1862
1863         ret = syncronize_flags(item, msglist);
1864
1865         for (cur = msglist; cur != NULL; cur = g_slist_next(cur))
1866                 procmsg_msginfo_free((MsgInfo *) cur->data);
1867
1868         g_slist_free(msglist);
1869
1870         item->scanning = ITEM_NOT_SCANNING;
1871
1872         return ret;
1873 }
1874
1875 static void folder_item_process_open (FolderItem *item,
1876                                  void (*before_proc_func)(gpointer data),
1877                                  void (*after_proc_func)(gpointer data),
1878                                  gpointer data)
1879 {
1880         gchar *buf;
1881         if (item == NULL)
1882                 return;
1883         if((item->folder->klass->scan_required != NULL) &&
1884            (item->folder->klass->scan_required(item->folder, item))) {
1885                 folder_item_scan_full(item, TRUE);
1886         } else {
1887                 folder_item_syncronize_flags(item);
1888         }
1889
1890         /* Processing */
1891         if (item->prefs->enable_processing_when_opening) {
1892                 buf = g_strdup_printf(_("Processing (%s)...\n"),
1893                               item->path ? item->path : item->name);
1894                 g_free(buf);
1895
1896                 if (before_proc_func)
1897                         before_proc_func(data);
1898
1899                 folder_item_apply_processing(item);
1900
1901                 if (after_proc_func)
1902                         after_proc_func(data);
1903         }
1904         item->processing_pending = FALSE;
1905         return;
1906 }
1907
1908 gint folder_item_open(FolderItem *item)
1909 {
1910         START_TIMING("");
1911         if (item->no_select)
1912                 return -1;
1913
1914         if (item->scanning != ITEM_NOT_SCANNING) {
1915                 debug_print("%s is scanning... \n", item->path ? item->path : item->name);
1916                 return -2;
1917         }
1918
1919         item->processing_pending = TRUE;
1920         folder_item_process_open (item, NULL, NULL, NULL);
1921
1922         item->opened = TRUE;
1923         END_TIMING();
1924         return 0;
1925 }
1926
1927 gint folder_item_close(FolderItem *item)
1928 {
1929         GSList *mlist, *cur;
1930         Folder *folder;
1931
1932         g_return_val_if_fail(item != NULL, -1);
1933
1934         if (item->no_select)
1935                 return -1;
1936
1937         if (item->new_msgs) {
1938                 folder_item_update_freeze();
1939                 mlist = folder_item_get_msg_list(item);
1940                 for (cur = mlist ; cur != NULL ; cur = cur->next) {
1941                         MsgInfo * msginfo;
1942
1943                         msginfo = (MsgInfo *) cur->data;
1944                         if (MSG_IS_NEW(msginfo->flags))
1945                                 procmsg_msginfo_unset_flags(msginfo, MSG_NEW, 0);
1946                         procmsg_msginfo_free(msginfo);
1947                 }
1948                 g_slist_free(mlist);
1949                 folder_item_update_thaw();
1950         }
1951
1952         folder_item_write_cache(item);
1953
1954         folder_item_update(item, F_ITEM_UPDATE_MSGCNT);
1955
1956         item->opened = FALSE;
1957         folder = item->folder;
1958
1959         if (folder->klass->close == NULL)
1960                 return 0;
1961
1962         return folder->klass->close(folder, item);
1963 }
1964
1965 static MsgInfoList *get_msginfos(FolderItem *item, MsgNumberList *numlist)
1966 {
1967         MsgInfoList *msglist = NULL;
1968         Folder *folder = item->folder;
1969         if (item->no_select)
1970                 return NULL;
1971
1972         if (folder->klass->get_msginfos != NULL)
1973                 msglist = folder->klass->get_msginfos(folder, item, numlist);
1974         else {
1975                 MsgNumberList *elem;
1976
1977                 for (elem = numlist; elem != NULL; elem = g_slist_next(elem)) {
1978                         MsgInfo *msginfo;
1979                         guint num;
1980
1981                         num = GPOINTER_TO_INT(elem->data);
1982                         msginfo = folder->klass->get_msginfo(folder, item, num);
1983                         if (msginfo != NULL)
1984                                 msglist = g_slist_prepend(msglist, msginfo);
1985                 }
1986         }
1987
1988         return msglist;
1989 }
1990
1991 static MsgInfo *get_msginfo(FolderItem *item, guint num)
1992 {
1993         MsgNumberList numlist;
1994         MsgInfoList *msglist;
1995         MsgInfo *msginfo = NULL;
1996
1997         numlist.data = GINT_TO_POINTER(num);
1998         numlist.next = NULL;
1999         msglist = get_msginfos(item, &numlist);
2000         if (msglist != NULL)
2001                 msginfo = procmsg_msginfo_new_ref(msglist->data);
2002         procmsg_msg_list_free(msglist);
2003
2004         return msginfo;
2005 }
2006
2007 gint folder_item_scan_full(FolderItem *item, gboolean filtering)
2008 {
2009         Folder *folder;
2010         GSList *folder_list = NULL, *cache_list = NULL;
2011         GSList *folder_list_cur, *cache_list_cur, *new_list = NULL;
2012         GSList *exists_list = NULL, *elem;
2013         GSList *newmsg_list = NULL;
2014         guint newcnt = 0, unreadcnt = 0, totalcnt = 0;
2015         guint markedcnt = 0, unreadmarkedcnt = 0;
2016         guint repliedcnt = 0, forwardedcnt = 0;
2017         guint lockedcnt = 0, ignoredcnt = 0, watchedcnt = 0;
2018
2019         guint cache_max_num, folder_max_num, cache_cur_num, folder_cur_num;
2020         gboolean update_flags = 0, old_uids_valid = FALSE;
2021         GHashTable *subject_table = NULL;
2022
2023         g_return_val_if_fail(item != NULL, -1);
2024         if (item->path == NULL) return -1;
2025
2026         folder = item->folder;
2027
2028         g_return_val_if_fail(folder != NULL, -1);
2029         g_return_val_if_fail(folder->klass->get_num_list != NULL, -1);
2030
2031         item->scanning = ITEM_SCANNING_WITH_FLAGS;
2032
2033         debug_print("Scanning folder %s for cache changes.\n", item->path ? item->path : "(null)");
2034
2035         /* Get list of messages for folder and cache */
2036         if (folder->klass->get_num_list(item->folder, item, &folder_list, &old_uids_valid) < 0) {
2037                 debug_print("Error fetching list of message numbers\n");
2038                 item->scanning = ITEM_NOT_SCANNING;
2039                 return(-1);
2040         }
2041
2042         if(prefs_common.thread_by_subject) {
2043                 subject_table = g_hash_table_new(g_str_hash, g_str_equal);
2044         }
2045
2046         if (old_uids_valid) {
2047                 if (!item->cache)
2048                         folder_item_read_cache(item);
2049                 cache_list = msgcache_get_msg_list(item->cache);
2050         } else {
2051                 if (item->cache)
2052                         msgcache_destroy(item->cache);
2053                 item->cache = msgcache_new();
2054                 cache_list = NULL;
2055         }
2056
2057         /* Sort both lists */
2058         cache_list = g_slist_sort(cache_list, folder_sort_cache_list_by_msgnum);
2059         folder_list = g_slist_sort(folder_list, folder_sort_folder_list);
2060
2061         cache_list_cur = cache_list;
2062         folder_list_cur = folder_list;
2063
2064         if (cache_list_cur != NULL) {
2065                 GSList *cache_list_last;
2066
2067                 cache_cur_num = ((MsgInfo *)cache_list_cur->data)->msgnum;
2068                 cache_list_last = g_slist_last(cache_list);
2069                 cache_max_num = ((MsgInfo *)cache_list_last->data)->msgnum;
2070         } else {
2071                 cache_cur_num = G_MAXINT;
2072                 cache_max_num = 0;
2073         }
2074
2075         if (folder_list_cur != NULL) {
2076                 GSList *folder_list_last;
2077
2078                 folder_cur_num = GPOINTER_TO_INT(folder_list_cur->data);
2079                 folder_list_last = g_slist_last(folder_list);
2080                 folder_max_num = GPOINTER_TO_INT(folder_list_last->data);
2081         } else {
2082                 folder_cur_num = G_MAXINT;
2083                 folder_max_num = 0;
2084         }
2085
2086         while ((cache_cur_num != G_MAXINT) || (folder_cur_num != G_MAXINT)) {
2087                 /*
2088                  *  Message only exists in the folder
2089                  *  Remember message for fetching
2090                  */
2091                 if (folder_cur_num < cache_cur_num) {
2092                         gboolean add = FALSE;
2093
2094                         switch(FOLDER_TYPE(folder)) {
2095                                 case F_NEWS:
2096                                         if (folder_cur_num < cache_max_num)
2097                                                 break;
2098
2099                                         if (folder->account->max_articles == 0) {
2100                                                 add = TRUE;
2101                                         }
2102
2103                                         if (folder_max_num <= folder->account->max_articles) {
2104                                                 add = TRUE;
2105                                         } else if (folder_cur_num > (folder_max_num - folder->account->max_articles)) {
2106                                                 add = TRUE;
2107                                         }
2108                                         break;
2109                                 default:
2110                                         add = TRUE;
2111                                         break;
2112                         }
2113
2114                         if (add) {
2115                                 new_list = g_slist_prepend(new_list, GINT_TO_POINTER(folder_cur_num));
2116                                 debug_print("Remembered message %d for fetching\n", folder_cur_num);
2117                         }
2118
2119                         /* Move to next folder number */
2120                         if (folder_list_cur)
2121                                 folder_list_cur = folder_list_cur->next;
2122
2123                         if (folder_list_cur != NULL)
2124                                 folder_cur_num = GPOINTER_TO_INT(folder_list_cur->data);
2125                         else
2126                                 folder_cur_num = G_MAXINT;
2127
2128                         continue;
2129                 }
2130
2131                 /*
2132                  *  Message only exists in the cache
2133                  *  Remove the message from the cache
2134                  */
2135                 if (cache_cur_num < folder_cur_num) {
2136                         msgcache_remove_msg(item->cache, cache_cur_num);
2137                         debug_print("Removed message %d from cache.\n", cache_cur_num);
2138
2139                         /* Move to next cache number */
2140                         if (cache_list_cur)
2141                                 cache_list_cur = cache_list_cur->next;
2142
2143                         if (cache_list_cur != NULL)
2144                                 cache_cur_num = ((MsgInfo *)cache_list_cur->data)->msgnum;
2145                         else
2146                                 cache_cur_num = G_MAXINT;
2147
2148                         update_flags |= F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT;
2149
2150                         continue;
2151                 }
2152
2153                 /*
2154                  *  Message number exists in folder and cache!
2155                  *  Check if the message has been modified
2156                  */
2157                 if (cache_cur_num == folder_cur_num) {
2158                         MsgInfo *msginfo;
2159
2160                         msginfo = msgcache_get_msg(item->cache, folder_cur_num);
2161                         if (folder->klass->is_msg_changed && folder->klass->is_msg_changed(folder, item, msginfo)) {
2162                                 msgcache_remove_msg(item->cache, msginfo->msgnum);
2163                                 new_list = g_slist_prepend(new_list, GINT_TO_POINTER(msginfo->msgnum));
2164                                 procmsg_msginfo_free(msginfo);
2165
2166                                 debug_print("Remembering message %d to update...\n", folder_cur_num);
2167                         } else {
2168                                 exists_list = g_slist_prepend(exists_list, msginfo);
2169
2170                                 if(prefs_common.thread_by_subject &&
2171                                         MSG_IS_IGNORE_THREAD(msginfo->flags) &&
2172                                         !subject_table_lookup(subject_table, msginfo->subject)) {
2173                                         subject_table_insert(subject_table, msginfo->subject, msginfo);
2174                                 }
2175                         }
2176
2177                         /* Move to next folder and cache number */
2178                         if (cache_list_cur)
2179                                 cache_list_cur = cache_list_cur->next;
2180
2181                         if (folder_list_cur)
2182                                 folder_list_cur = folder_list_cur->next;
2183
2184                         if (cache_list_cur != NULL)
2185                                 cache_cur_num = ((MsgInfo *)cache_list_cur->data)->msgnum;
2186                         else
2187                                 cache_cur_num = G_MAXINT;
2188
2189                         if (folder_list_cur != NULL)
2190                                 folder_cur_num = GPOINTER_TO_INT(folder_list_cur->data);
2191                         else
2192                                 folder_cur_num = G_MAXINT;
2193
2194                         continue;
2195                 }
2196         }
2197
2198         for(cache_list_cur = cache_list; cache_list_cur != NULL; cache_list_cur = g_slist_next(cache_list_cur))
2199                 procmsg_msginfo_free((MsgInfo *) cache_list_cur->data);
2200
2201         g_slist_free(cache_list);
2202         g_slist_free(folder_list);
2203
2204         if (new_list != NULL) {
2205                 GSList *tmp_list = NULL;
2206                 newmsg_list = get_msginfos(item, new_list);
2207                 g_slist_free(new_list);
2208                 tmp_list = g_slist_concat(g_slist_copy(exists_list), g_slist_copy(newmsg_list));
2209                 syncronize_flags(item, tmp_list);
2210                 g_slist_free(tmp_list);
2211         } else {
2212                 syncronize_flags(item, exists_list);
2213         }
2214
2215         folder_item_update_freeze();
2216
2217         item->scanning = ITEM_SCANNING;
2218
2219         if (newmsg_list != NULL) {
2220                 GSList *elem, *to_filter = NULL;
2221                 gboolean do_filter = (filtering == TRUE) &&
2222                                         (item->stype == F_INBOX) &&
2223                                         (item->folder->account != NULL) &&
2224                                         (item->folder->account->filter_on_recv);
2225
2226                 for (elem = newmsg_list; elem != NULL; elem = g_slist_next(elem)) {
2227                         MsgInfo *msginfo = (MsgInfo *) elem->data;
2228
2229                         msgcache_add_msg(item->cache, msginfo);
2230                         if (!do_filter) {
2231                                 exists_list = g_slist_prepend(exists_list, msginfo);
2232
2233                                 if(prefs_common.thread_by_subject &&
2234                                         MSG_IS_IGNORE_THREAD(msginfo->flags) &&
2235                                         !subject_table_lookup(subject_table, msginfo->subject)) {
2236                                         subject_table_insert(subject_table, msginfo->subject, msginfo);
2237                                 }
2238                         }
2239                 }
2240
2241                 if (do_filter) {
2242                         GSList *unfiltered;
2243
2244                         folder_item_set_batch(item, TRUE);
2245                         procmsg_msglist_filter(newmsg_list, item->folder->account,
2246                                         &to_filter, &unfiltered,
2247                                         TRUE);
2248                         folder_item_set_batch(item, FALSE);
2249
2250                         filtering_move_and_copy_msgs(newmsg_list);
2251                         if (to_filter != NULL) {
2252                                 for (elem = to_filter; elem; elem = g_slist_next(elem)) {
2253                                         MsgInfo *msginfo = (MsgInfo *)elem->data;
2254                                         procmsg_msginfo_free(msginfo);
2255                                 }
2256                                 g_slist_free(to_filter);
2257                         }
2258                         if (unfiltered != NULL) {
2259                                 for (elem = unfiltered; elem; elem = g_slist_next(elem)) {
2260                                         MsgInfo *msginfo = (MsgInfo *)elem->data;
2261                                         exists_list = g_slist_prepend(exists_list, msginfo);
2262
2263                                         if(prefs_common.thread_by_subject &&
2264                                                 MSG_IS_IGNORE_THREAD(msginfo->flags) &&
2265                                                 !subject_table_lookup(subject_table, msginfo->subject)) {
2266                                                 subject_table_insert(subject_table, msginfo->subject, msginfo);
2267                                         }
2268                                 }
2269                                 g_slist_free(unfiltered);
2270                         }
2271                         if (prefs_common.real_time_sync)
2272                                 folder_item_synchronise(item);
2273                 } else {
2274                         if (prefs_common.real_time_sync)
2275                                 folder_item_synchronise(item);
2276                 }
2277
2278                 g_slist_free(newmsg_list);
2279
2280                 update_flags |= F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT;
2281         }
2282
2283         folder_item_set_batch(item, TRUE);
2284         for (elem = exists_list; elem != NULL; elem = g_slist_next(elem)) {
2285                 MsgInfo *msginfo, *parent_msginfo;
2286
2287                 msginfo = elem->data;
2288                 if (MSG_IS_IGNORE_THREAD(msginfo->flags) && (MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags)))
2289                         procmsg_msginfo_unset_flags(msginfo, MSG_NEW | MSG_UNREAD, 0);
2290                 if (!MSG_IS_IGNORE_THREAD(msginfo->flags) && procmsg_msg_has_flagged_parent(msginfo, MSG_IGNORE_THREAD)) {
2291                         procmsg_msginfo_change_flags(msginfo, MSG_IGNORE_THREAD, 0, MSG_NEW | MSG_UNREAD, 0);
2292                 }
2293                 if (!MSG_IS_WATCH_THREAD(msginfo->flags) && procmsg_msg_has_flagged_parent(msginfo, MSG_WATCH_THREAD)) {
2294                         procmsg_msginfo_set_flags(msginfo, MSG_WATCH_THREAD, 0);
2295                 }
2296                 if(prefs_common.thread_by_subject && !msginfo->inreplyto &&
2297                         !msginfo->references && !MSG_IS_IGNORE_THREAD(msginfo->flags) &&
2298                         (parent_msginfo = subject_table_lookup(subject_table, msginfo->subject)))
2299                 {
2300                         if(MSG_IS_IGNORE_THREAD(parent_msginfo->flags)) {
2301                                 procmsg_msginfo_change_flags(msginfo, MSG_IGNORE_THREAD, 0,
2302                                                 MSG_NEW | MSG_UNREAD, 0);
2303                         }
2304                 }
2305                 if ((folder_has_parent_of_type(item, F_OUTBOX) ||
2306                      folder_has_parent_of_type(item, F_QUEUE)  ||
2307                      folder_has_parent_of_type(item, F_DRAFT)  ||
2308                      folder_has_parent_of_type(item, F_TRASH)) &&
2309                     (MSG_IS_NEW(msginfo->flags) || MSG_IS_UNREAD(msginfo->flags)))
2310                         procmsg_msginfo_unset_flags(msginfo, MSG_NEW | MSG_UNREAD, 0);
2311                 if (MSG_IS_NEW(msginfo->flags))
2312                         newcnt++;
2313                 if (MSG_IS_UNREAD(msginfo->flags))
2314                         unreadcnt++;
2315                 if (MSG_IS_UNREAD(msginfo->flags) && procmsg_msg_has_marked_parent(msginfo))
2316                         unreadmarkedcnt++;
2317                 if (MSG_IS_MARKED(msginfo->flags))
2318                         markedcnt++;
2319                 if (MSG_IS_REPLIED(msginfo->flags))
2320                         repliedcnt++;
2321                 if (MSG_IS_FORWARDED(msginfo->flags))
2322                         forwardedcnt++;
2323                 if (MSG_IS_LOCKED(msginfo->flags))
2324                         lockedcnt++;
2325                 if (MSG_IS_IGNORE_THREAD(msginfo->flags))
2326                         ignoredcnt++;
2327                 if (MSG_IS_WATCH_THREAD(msginfo->flags))
2328                         watchedcnt++;
2329
2330                 totalcnt++;
2331
2332                 procmsg_msginfo_free(msginfo);
2333         }
2334         folder_item_set_batch(item, FALSE);
2335         g_slist_free(exists_list);
2336
2337         if(prefs_common.thread_by_subject) {
2338                 g_hash_table_destroy(subject_table);
2339         }
2340
2341         if (item->new_msgs != newcnt || item->unread_msgs != unreadcnt
2342         ||  item->total_msgs != totalcnt || item->marked_msgs != markedcnt
2343         ||  item->unreadmarked_msgs != unreadmarkedcnt
2344         ||  item->replied_msgs != repliedcnt || item->forwarded_msgs != forwardedcnt
2345         ||  item->locked_msgs != lockedcnt || item->ignored_msgs != ignoredcnt
2346         ||  item->watched_msgs != watchedcnt) {
2347                 update_flags |= F_ITEM_UPDATE_CONTENT;
2348         }
2349
2350         item->new_msgs = newcnt;
2351         item->unread_msgs = unreadcnt;
2352         item->total_msgs = totalcnt;
2353         item->unreadmarked_msgs = unreadmarkedcnt;
2354         item->marked_msgs = markedcnt;
2355         item->replied_msgs = repliedcnt;
2356         item->forwarded_msgs = forwardedcnt;
2357         item->locked_msgs = lockedcnt;
2358         item->ignored_msgs = ignoredcnt;
2359         item->watched_msgs = watchedcnt;
2360
2361         update_flags |= F_ITEM_UPDATE_MSGCNT;
2362
2363         folder_item_update(item, update_flags);
2364         folder_item_update_thaw();
2365
2366         item->scanning = ITEM_NOT_SCANNING;
2367
2368         return 0;
2369 }
2370
2371 gint folder_item_scan(FolderItem *item)
2372 {
2373         return folder_item_scan_full(item, TRUE);
2374 }
2375
2376 static void folder_count_total_cache_memusage(FolderItem *item, gpointer data)
2377 {
2378         gint *memusage = (gint *)data;
2379
2380         if (item->cache == NULL)
2381                 return;
2382
2383         *memusage += msgcache_get_memory_usage(item->cache);
2384 }
2385
2386 static gint folder_cache_time_compare_func(gconstpointer a, gconstpointer b)
2387 {
2388         FolderItem *fa = (FolderItem *)a;
2389         FolderItem *fb = (FolderItem *)b;
2390
2391         return (gint) (msgcache_get_last_access_time(fa->cache) - msgcache_get_last_access_time(fb->cache));
2392 }
2393
2394 static void folder_find_expired_caches(FolderItem *item, gpointer data)
2395 {
2396         GSList **folder_item_list = (GSList **)data;
2397         gint difftime, expiretime;
2398
2399         if (item->cache == NULL)
2400                 return;
2401
2402         if (item->opened > 0)
2403                 return;
2404
2405         difftime = (gint) (time(NULL) - msgcache_get_last_access_time(item->cache));
2406         expiretime = prefs_common.cache_min_keep_time * 60;
2407         debug_print("Cache unused time: %d (Expire time: %d)\n", difftime, expiretime);
2408
2409         if (difftime > expiretime && !item->opened && !item->processing_pending) {
2410                 *folder_item_list = g_slist_insert_sorted(*folder_item_list, item, folder_cache_time_compare_func);
2411         }
2412 }
2413
2414 gboolean folder_item_free_cache(FolderItem *item, gboolean force)
2415 {
2416         g_return_val_if_fail(item != NULL, TRUE);
2417
2418         if (item->cache == NULL)
2419                 return TRUE;
2420
2421         if (item->opened > 0 && !force)
2422                 return FALSE;
2423
2424         folder_item_write_cache(item);
2425         msgcache_destroy(item->cache);
2426         item->cache = NULL;
2427         return TRUE;
2428 }
2429
2430 void folder_clean_cache_memory_force(void)
2431 {
2432         int old_cache_max_mem_usage = prefs_common.cache_max_mem_usage;
2433         int old_cache_min_keep_time = prefs_common.cache_min_keep_time;
2434
2435         prefs_common.cache_max_mem_usage = 0;
2436         prefs_common.cache_min_keep_time = 0;
2437
2438         folder_clean_cache_memory(NULL);
2439
2440         prefs_common.cache_max_mem_usage = old_cache_max_mem_usage;
2441         prefs_common.cache_min_keep_time = old_cache_min_keep_time;
2442 }
2443
2444 void folder_clean_cache_memory(FolderItem *protected_item)
2445 {
2446         gint memusage = 0;
2447
2448         folder_func_to_all_folders(folder_count_total_cache_memusage, &memusage);
2449         debug_print("Total cache memory usage: %d\n", memusage);
2450
2451         if (memusage > (prefs_common.cache_max_mem_usage * 1024)) {
2452                 GSList *folder_item_list = NULL, *listitem;
2453
2454                 debug_print("Trying to free cache memory\n");
2455
2456                 folder_func_to_all_folders(folder_find_expired_caches, &folder_item_list);
2457                 listitem = folder_item_list;
2458                 while((listitem != NULL) && (memusage > (prefs_common.cache_max_mem_usage * 1024))) {
2459                         FolderItem *item = (FolderItem *)(listitem->data);
2460                         gint cache_size = 0;
2461                         if (item == protected_item) {
2462                                 listitem = listitem->next;
2463                                 continue;
2464                         }
2465                         debug_print("Freeing cache memory for %s\n", item->path ? item->path : item->name);
2466                         cache_size = msgcache_get_memory_usage(item->cache);
2467                         if (folder_item_free_cache(item, FALSE))
2468                                 memusage -= cache_size;
2469
2470                         listitem = listitem->next;
2471                 }
2472                 g_slist_free(folder_item_list);
2473         }
2474 }
2475
2476 static void folder_item_remove_cached_msg(FolderItem *item, MsgInfo *msginfo)
2477 {
2478         Folder *folder = item->folder;
2479
2480         g_return_if_fail(folder != NULL);
2481
2482         if (folder->klass->remove_cached_msg == NULL)
2483                 return;
2484
2485         folder->klass->remove_cached_msg(folder, item, msginfo);
2486 }
2487
2488 static void folder_item_clean_local_files(FolderItem *item, gint days)
2489 {
2490         g_return_if_fail(item != NULL);
2491         g_return_if_fail(item->folder != NULL);
2492
2493         if (FOLDER_TYPE(item->folder) == F_IMAP ||
2494             FOLDER_TYPE(item->folder) == F_NEWS) {
2495                 GSList *msglist = folder_item_get_msg_list(item);
2496                 GSList *cur;
2497                 time_t t = time(NULL);
2498                 for (cur = msglist; cur; cur = cur->next) {
2499                         MsgInfo *msginfo = (MsgInfo *)cur->data;
2500                         gint age = (t - msginfo->date_t) / (60*60*24);
2501                         if (age > days)
2502                                 folder_item_remove_cached_msg(item, msginfo);
2503                 }
2504                 procmsg_msg_list_free(msglist);
2505         }
2506 }
2507
2508 static void folder_item_read_cache(FolderItem *item)
2509 {
2510         gchar *cache_file, *mark_file, *tags_file;
2511         START_TIMING("");
2512         g_return_if_fail(item != NULL);
2513
2514         if (item->path != NULL) {
2515                 cache_file = folder_item_get_cache_file(item);
2516                 mark_file = folder_item_get_mark_file(item);
2517                 tags_file = folder_item_get_tags_file(item);
2518                 item->cache = msgcache_read_cache(item, cache_file);
2519                 if (!item->cache) {
2520                         MsgInfoList *list, *cur;
2521                         guint newcnt = 0, unreadcnt = 0;
2522                         guint markedcnt = 0, unreadmarkedcnt = 0;
2523                         guint repliedcnt = 0, forwardedcnt = 0;
2524                         guint lockedcnt = 0, ignoredcnt = 0;
2525                         guint watchedcnt = 0;
2526                         MsgInfo *msginfo;
2527
2528                         item->cache = msgcache_new();
2529                         folder_item_scan_full(item, TRUE);
2530
2531                         msgcache_read_mark(item->cache, mark_file);
2532
2533                         list = msgcache_get_msg_list(item->cache);
2534                         for (cur = list; cur != NULL; cur = g_slist_next(cur)) {
2535                                 msginfo = cur->data;
2536
2537                                 if (MSG_IS_NEW(msginfo->flags))
2538                                         newcnt++;
2539                                 if (MSG_IS_UNREAD(msginfo->flags))
2540                                         unreadcnt++;
2541                                 if (MSG_IS_UNREAD(msginfo->flags) && procmsg_msg_has_marked_parent(msginfo))
2542                                         unreadmarkedcnt++;
2543                                 if (MSG_IS_MARKED(msginfo->flags))
2544                                         markedcnt++;
2545                                 if (MSG_IS_REPLIED(msginfo->flags))
2546                                         repliedcnt++;
2547                                 if (MSG_IS_FORWARDED(msginfo->flags))
2548                                         forwardedcnt++;
2549                                 if (MSG_IS_LOCKED(msginfo->flags))
2550                                         lockedcnt++;
2551                                 if (MSG_IS_IGNORE_THREAD(msginfo->flags))
2552                                         ignoredcnt++;
2553                                 if (MSG_IS_WATCH_THREAD(msginfo->flags))
2554                                         watchedcnt++;
2555                                 procmsg_msginfo_unset_flags(msginfo, MSG_FULLY_CACHED, 0);
2556                         }
2557                         item->new_msgs = newcnt;
2558                         item->unread_msgs = unreadcnt;
2559                         item->unreadmarked_msgs = unreadmarkedcnt;
2560                         item->marked_msgs = markedcnt;
2561                         item->replied_msgs = repliedcnt;
2562                         item->forwarded_msgs = forwardedcnt;
2563                         item->locked_msgs = lockedcnt;
2564                         item->ignored_msgs = ignoredcnt;
2565                         item->watched_msgs = watchedcnt;
2566                         procmsg_msg_list_free(list);
2567                 } else
2568                         msgcache_read_mark(item->cache, mark_file);
2569
2570                 msgcache_read_tags(item->cache, tags_file);
2571
2572                 g_free(cache_file);
2573                 g_free(mark_file);
2574                 g_free(tags_file);
2575         } else {
2576                 item->cache = msgcache_new();
2577         }
2578         END_TIMING();
2579         folder_clean_cache_memory(item);
2580 }
2581
2582 void folder_item_write_cache(FolderItem *item)
2583 {
2584         gchar *cache_file, *mark_file, *tags_file;
2585         FolderItemPrefs *prefs;
2586         gint filemode = 0;
2587         gchar *id;
2588         time_t last_mtime = (time_t)0;
2589         gboolean need_scan = FALSE;
2590
2591         if (!item || !item->path || !item->cache)
2592                 return;
2593
2594         last_mtime = item->mtime;
2595         if (item->folder->klass->scan_required)
2596                 need_scan = item->folder->klass->scan_required(item->folder, item);
2597         else
2598                 need_scan = TRUE;
2599
2600         id = folder_item_get_identifier(item);
2601         debug_print("Save cache for folder %s\n", id);
2602         g_free(id);
2603
2604         cache_file = folder_item_get_cache_file(item);
2605         mark_file = folder_item_get_mark_file(item);
2606         tags_file = folder_item_get_tags_file(item);
2607         if (msgcache_write(cache_file, mark_file, tags_file, item->cache) < 0) {
2608                 prefs = item->prefs;
2609                 if (prefs && prefs->enable_folder_chmod && prefs->folder_chmod) {
2610                         /* for cache file */
2611                         filemode = prefs->folder_chmod;
2612                         if (filemode & S_IRGRP) filemode |= S_IWGRP;
2613                         if (filemode & S_IROTH) filemode |= S_IWOTH;
2614                         chmod(cache_file, filemode);
2615                 }
2616         }
2617
2618         if (!need_scan && item->folder->klass->set_mtime) {
2619                 if (item->mtime == last_mtime) {
2620                         item->folder->klass->set_mtime(item->folder, item);
2621                 }
2622         }
2623
2624         g_free(cache_file);
2625         g_free(mark_file);
2626         g_free(tags_file);
2627 }
2628
2629 MsgInfo *folder_item_get_msginfo(FolderItem *item, gint num)
2630 {
2631         Folder *folder;
2632         MsgInfo *msginfo = NULL;
2633
2634         g_return_val_if_fail(item != NULL, NULL);
2635         if (item->no_select)
2636                 return NULL;
2637         folder = item->folder;
2638         if (!item->cache)
2639                 folder_item_read_cache(item);
2640
2641         if ((msginfo = msgcache_get_msg(item->cache, num)) != NULL)
2642                 return msginfo;
2643
2644         msginfo = get_msginfo(item, num);
2645         if (msginfo != NULL) {
2646                 msgcache_add_msg(item->cache, msginfo);
2647                 return msginfo;
2648         }
2649
2650         return NULL;
2651 }
2652
2653 MsgInfo *folder_item_get_msginfo_by_msgid(FolderItem *item, const gchar *msgid)
2654 {
2655         Folder *folder;
2656         MsgInfo *msginfo;
2657
2658         g_return_val_if_fail(item != NULL, NULL);
2659         g_return_val_if_fail(msgid != NULL, NULL);
2660         if (item->no_select)
2661                 return FALSE;
2662
2663         folder = item->folder;
2664         if (!item->cache)
2665                 folder_item_read_cache(item);
2666
2667         if ((msginfo = msgcache_get_msg_by_id(item->cache, msgid)) != NULL)
2668                 return msginfo;
2669
2670         return NULL;
2671 }
2672
2673 GSList *folder_item_get_msg_list(FolderItem *item)
2674 {
2675         g_return_val_if_fail(item != NULL, NULL);
2676         if (item->no_select)
2677                 return FALSE;
2678
2679         if (item->cache == 0)
2680                 folder_item_read_cache(item);
2681
2682         g_return_val_if_fail(item->cache != NULL, NULL);
2683
2684         return msgcache_get_msg_list(item->cache);
2685 }
2686
2687 static void msginfo_set_mime_flags(GNode *node, gpointer data)
2688 {
2689         MsgInfo *msginfo = data;
2690         MimeInfo *mimeinfo = node->data;
2691
2692         if (mimeinfo->disposition == DISPOSITIONTYPE_ATTACHMENT
2693          && (!mimeinfo->subtype ||  strcmp(mimeinfo->subtype, "pgp-signature"))) {
2694                 procmsg_msginfo_set_flags(msginfo, 0, MSG_HAS_ATTACHMENT);
2695         } else if (mimeinfo->disposition == DISPOSITIONTYPE_UNKNOWN &&
2696                  mimeinfo->type != MIMETYPE_TEXT &&
2697                  mimeinfo->type != MIMETYPE_MULTIPART) {
2698                 if (!mimeinfo->subtype
2699                 ||  strcmp(mimeinfo->subtype, "pgp-signature"))
2700                         procmsg_msginfo_set_flags(msginfo, 0, MSG_HAS_ATTACHMENT);
2701         } else if (mimeinfo->disposition == DISPOSITIONTYPE_INLINE &&
2702                 strcmp(mimeinfo->subtype, "pgp-signature") &&
2703                 (procmime_mimeinfo_get_parameter(mimeinfo, "name") != NULL ||
2704                  procmime_mimeinfo_get_parameter(mimeinfo, "filename") != NULL)) {
2705                 procmsg_msginfo_set_flags(msginfo, 0, MSG_HAS_ATTACHMENT);
2706         }
2707
2708         /* don't descend below top level message for signed and encrypted info */
2709         if (mimeinfo->type == MIMETYPE_MESSAGE)
2710                 return;
2711
2712         if (privacy_mimeinfo_is_signed(mimeinfo)) {
2713                 procmsg_msginfo_set_flags(msginfo, 0, MSG_SIGNED);
2714         }
2715
2716         if (privacy_mimeinfo_is_encrypted(mimeinfo)) {
2717                 procmsg_msginfo_set_flags(msginfo, 0, MSG_ENCRYPTED);
2718         } else {
2719                 /* searching inside encrypted parts doesn't really make sense */
2720                 g_node_children_foreach(mimeinfo->node, G_TRAVERSE_ALL, msginfo_set_mime_flags, msginfo);
2721         }
2722 }
2723
2724 gchar *folder_item_fetch_msg(FolderItem *item, gint num)
2725 {
2726         Folder *folder;
2727         gchar *msgfile;
2728         MsgInfo *msginfo;
2729
2730         g_return_val_if_fail(item != NULL, NULL);
2731
2732         folder = item->folder;
2733
2734         g_return_val_if_fail(folder->klass->fetch_msg != NULL, NULL);
2735         if (item->no_select)
2736                 return NULL;
2737
2738         msgfile = folder->klass->fetch_msg(folder, item, num);
2739
2740         if (msgfile != NULL) {
2741                 msginfo = folder_item_get_msginfo(item, num);
2742                 if ((msginfo != NULL) && !MSG_IS_SCANNED(msginfo->flags)) {
2743                         MimeInfo *mimeinfo;
2744
2745                         if (!folder_has_parent_of_type(msginfo->folder, F_QUEUE) &&
2746                             !folder_has_parent_of_type(msginfo->folder, F_DRAFT))
2747                                 mimeinfo = procmime_scan_file(msgfile);
2748                         else
2749                                 mimeinfo = procmime_scan_queue_file(msgfile);
2750                         /* check for attachments */
2751                         if (mimeinfo != NULL) {
2752                                 g_node_children_foreach(mimeinfo->node, G_TRAVERSE_ALL, msginfo_set_mime_flags, msginfo);
2753                                 procmime_mimeinfo_free_all(mimeinfo);
2754
2755                                 procmsg_msginfo_set_flags(msginfo, 0, MSG_SCANNED);
2756                         }
2757                 }
2758                 procmsg_msginfo_free(msginfo);
2759         }
2760
2761         return msgfile;
2762 }
2763
2764 gchar *folder_item_fetch_msg_full(FolderItem *item, gint num, gboolean headers,
2765                                   gboolean body)
2766 {
2767         Folder *folder;
2768         gchar *msgfile;
2769         MsgInfo *msginfo;
2770
2771         g_return_val_if_fail(item != NULL, NULL);
2772         if (item->no_select)
2773                 return NULL;
2774
2775         folder = item->folder;
2776
2777         if (folder->klass->fetch_msg_full == NULL)
2778                 return folder_item_fetch_msg(item, num);
2779
2780         if (item->prefs->offlinesync && prefs_common.real_time_sync)
2781                 msgfile = folder->klass->fetch_msg_full(folder, item, num,
2782                                                 TRUE, TRUE);
2783         else
2784                 msgfile = folder->klass->fetch_msg_full(folder, item, num,
2785                                                 headers, body);
2786
2787         if (msgfile != NULL) {
2788                 msginfo = folder_item_get_msginfo(item, num);
2789                 if ((msginfo != NULL) && !MSG_IS_SCANNED(msginfo->flags)) {
2790                         MimeInfo *mimeinfo;
2791
2792                         if (!folder_has_parent_of_type(msginfo->folder, F_QUEUE) &&
2793                             !folder_has_parent_of_type(msginfo->folder, F_DRAFT))
2794                                 mimeinfo = procmime_scan_file(msgfile);
2795                         else
2796                                 mimeinfo = procmime_scan_queue_file(msgfile);
2797                         /* check for attachments */
2798                         if (mimeinfo != NULL) {
2799                                 g_node_children_foreach(mimeinfo->node, G_TRAVERSE_ALL, msginfo_set_mime_flags, msginfo);
2800                                 procmime_mimeinfo_free_all(mimeinfo);
2801
2802                                 procmsg_msginfo_set_flags(msginfo, 0, MSG_SCANNED);
2803                         }
2804                 }
2805                 procmsg_msginfo_free(msginfo);
2806         }
2807
2808         return msgfile;
2809 }
2810
2811
2812 static gint folder_item_get_msg_num_by_file(FolderItem *dest, const gchar *file)
2813 {
2814         static HeaderEntry hentry[] = {{"Message-ID:",  NULL, TRUE},
2815                                        {NULL,           NULL, FALSE}};
2816         FILE *fp;
2817         MsgInfo *msginfo;
2818         gint msgnum = 0;
2819         gchar buf[BUFFSIZE];
2820
2821         if ((fp = g_fopen(file, "rb")) == NULL)
2822                 return 0;
2823
2824         if ((folder_has_parent_of_type(dest, F_QUEUE)) ||
2825             (folder_has_parent_of_type(dest, F_DRAFT)))
2826                 while (fgets(buf, sizeof(buf), fp) != NULL) {
2827                         /* new way */
2828                         if ((!strncmp(buf, "X-Claws-End-Special-Headers: 1",
2829                                 strlen("X-Claws-End-Special-Headers:"))) ||
2830                             (!strncmp(buf, "X-Sylpheed-End-Special-Headers: 1",
2831                                 strlen("X-Sylpheed-End-Special-Headers:"))))
2832                                 break;
2833                         /* old way */
2834                         if (buf[0] == '\r' || buf[0] == '\n') break;
2835                         /* from other mailers */
2836                         if (!strncmp(buf, "Date: ", 6)
2837                         ||  !strncmp(buf, "To: ", 4)
2838                         ||  !strncmp(buf, "From: ", 6)
2839                         ||  !strncmp(buf, "Subject: ", 9)) {
2840                                 rewind(fp);
2841                                 break;
2842                         }
2843                 }
2844
2845         procheader_get_header_fields(fp, hentry);
2846         debug_print("looking for %s\n", hentry[0].body);
2847         if (hentry[0].body) {
2848                 extract_parenthesis(hentry[0].body, '<', '>');
2849                 remove_space(hentry[0].body);
2850                 if ((msginfo = msgcache_get_msg_by_id(dest->cache, hentry[0].body)) != NULL) {
2851                         msgnum = msginfo->msgnum;
2852                         procmsg_msginfo_free(msginfo);
2853
2854                         debug_print("found message as uid %d\n", msgnum);
2855                 }
2856         }
2857
2858         g_free(hentry[0].body);
2859         hentry[0].body = NULL;
2860         fclose(fp);
2861
2862         return msgnum;
2863 }
2864
2865 static void copy_msginfo_flags(MsgInfo *source, MsgInfo *dest)
2866 {
2867         MsgPermFlags perm_flags = 0;
2868         MsgTmpFlags tmp_flags = 0;
2869
2870         /* create new flags */
2871         if (source != NULL) {
2872                 /* copy original flags */
2873                 perm_flags = source->flags.perm_flags;
2874                 tmp_flags = source->flags.tmp_flags;
2875         } else {
2876                 perm_flags = dest->flags.perm_flags;
2877                 tmp_flags = dest->flags.tmp_flags;
2878         }
2879
2880         /* remove new, unread and deleted in special folders */
2881         if (folder_has_parent_of_type(dest->folder, F_OUTBOX) ||
2882             folder_has_parent_of_type(dest->folder, F_QUEUE) ||
2883             folder_has_parent_of_type(dest->folder, F_DRAFT) ||
2884             folder_has_parent_of_type(dest->folder, F_TRASH))
2885                 perm_flags &= ~(MSG_NEW | MSG_UNREAD | MSG_DELETED);
2886
2887         /* set ignore flag of ignored parent exists */
2888         if (procmsg_msg_has_flagged_parent(dest, MSG_IGNORE_THREAD))
2889                 perm_flags |= MSG_IGNORE_THREAD;
2890
2891         /* unset FULLY_CACHED flags */
2892         perm_flags &= ~MSG_FULLY_CACHED;
2893
2894         if (procmsg_msg_has_flagged_parent(dest, MSG_WATCH_THREAD))
2895                 perm_flags |= MSG_WATCH_THREAD;
2896
2897         /* Unset tmp flags that should not be copied */
2898         tmp_flags &= ~(MSG_MOVE | MSG_COPY | MSG_MOVE_DONE);
2899
2900         /* unset flags that are set but should not */
2901         /* and set new flags */
2902         procmsg_msginfo_change_flags(dest,
2903                                   ~dest->flags.perm_flags & perm_flags,
2904                                   ~dest->flags.tmp_flags  & tmp_flags,
2905                                    dest->flags.perm_flags & ~perm_flags,
2906                                    dest->flags.tmp_flags  & ~tmp_flags);
2907
2908         if (source && source->tags) {
2909                 g_slist_free(dest->tags);
2910                 dest->tags = g_slist_copy(source->tags);
2911                 folder_item_commit_tags(dest->folder, dest, dest->tags, NULL);
2912         }
2913 }
2914
2915 static void add_msginfo_to_cache(FolderItem *item, MsgInfo *newmsginfo, MsgInfo *flagsource)
2916 {
2917         /* update folder stats */
2918         if (MSG_IS_NEW(newmsginfo->flags))
2919                 item->new_msgs++;
2920         if (MSG_IS_UNREAD(newmsginfo->flags))
2921                 item->unread_msgs++;
2922         if (MSG_IS_UNREAD(newmsginfo->flags) && procmsg_msg_has_marked_parent(newmsginfo))
2923                 item->unreadmarked_msgs++;
2924         if (MSG_IS_MARKED(newmsginfo->flags))
2925                 item->marked_msgs++;
2926         if (MSG_IS_REPLIED(newmsginfo->flags))
2927                 item->replied_msgs++;
2928         if (MSG_IS_FORWARDED(newmsginfo->flags))
2929                 item->forwarded_msgs++;
2930         if (MSG_IS_LOCKED(newmsginfo->flags))
2931                 item->locked_msgs++;
2932         if (MSG_IS_IGNORE_THREAD(newmsginfo->flags))
2933                 item->ignored_msgs++;
2934         if (MSG_IS_WATCH_THREAD(newmsginfo->flags))
2935                 item->watched_msgs++;
2936         item->total_msgs++;
2937
2938         folder_item_update_freeze();
2939
2940         if (!item->cache)
2941                 folder_item_read_cache(item);
2942
2943         msgcache_add_msg(item->cache, newmsginfo);
2944         copy_msginfo_flags(flagsource, newmsginfo);
2945         folder_item_update_with_msg(item,  F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT | F_ITEM_UPDATE_ADDMSG, newmsginfo);
2946         folder_item_update_thaw();
2947 }
2948
2949 static void remove_msginfo_from_cache(FolderItem *item, MsgInfo *msginfo)
2950 {
2951         MsgInfoUpdate msginfo_update;
2952
2953         if (!item->cache)
2954                 folder_item_read_cache(item);
2955
2956         if (MSG_IS_NEW(msginfo->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags))
2957                 msginfo->folder->new_msgs--;
2958         if (MSG_IS_UNREAD(msginfo->flags) && !MSG_IS_IGNORE_THREAD(msginfo->flags))
2959                 msginfo->folder->unread_msgs--;
2960         if (MSG_IS_UNREAD(msginfo->flags) && procmsg_msg_has_marked_parent(msginfo))
2961                 msginfo->folder->unreadmarked_msgs--;
2962         if (MSG_IS_MARKED(msginfo->flags))
2963                 item->marked_msgs--;
2964         if (MSG_IS_REPLIED(msginfo->flags))
2965                 item->replied_msgs--;
2966         if (MSG_IS_FORWARDED(msginfo->flags))
2967                 item->forwarded_msgs--;
2968         if (MSG_IS_LOCKED(msginfo->flags))
2969                 item->locked_msgs--;
2970         if (MSG_IS_IGNORE_THREAD(msginfo->flags))
2971                 item->ignored_msgs--;
2972         if (MSG_IS_WATCH_THREAD(msginfo->flags))
2973                 item->watched_msgs--;
2974
2975         msginfo->folder->total_msgs--;
2976
2977         msginfo_update.msginfo = msginfo;
2978         msginfo_update.flags = MSGINFO_UPDATE_DELETED;
2979         hooks_invoke(MSGINFO_UPDATE_HOOKLIST, &msginfo_update);
2980
2981         msgcache_remove_msg(item->cache, msginfo->msgnum);
2982         folder_item_update_with_msg(msginfo->folder, F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT | F_ITEM_UPDATE_REMOVEMSG, msginfo);
2983 }
2984
2985 gint folder_item_add_msg(FolderItem *dest, const gchar *file,
2986                          MsgFlags *flags, gboolean remove_source)
2987 {
2988         GSList file_list;
2989         MsgFileInfo fileinfo;
2990
2991         g_return_val_if_fail(dest != NULL, -1);
2992         g_return_val_if_fail(file != NULL, -1);
2993
2994         fileinfo.msginfo = NULL;
2995         fileinfo.file = (gchar *)file;
2996         fileinfo.flags = flags;
2997         file_list.data = &fileinfo;
2998         file_list.next = NULL;
2999
3000         return folder_item_add_msgs(dest, &file_list, remove_source);
3001 }
3002
3003 gint folder_item_add_msgs(FolderItem *dest, GSList *file_list,
3004                           gboolean remove_source)
3005 {
3006         Folder *folder;
3007         gint ret, num, lastnum = -1;
3008         GSList *file_cur;
3009         GRelation *relation;
3010         MsgFileInfo *fileinfo = NULL;
3011         gboolean folderscan = FALSE;
3012
3013         g_return_val_if_fail(dest != NULL, -1);
3014         g_return_val_if_fail(file_list != NULL, -1);
3015         g_return_val_if_fail(dest->folder != NULL, -1);
3016         if (dest->no_select)
3017                 return -1;
3018
3019         folder = dest->folder;
3020
3021         relation = g_relation_new(2);
3022         g_relation_index(relation, 0, g_direct_hash, g_direct_equal);
3023
3024         if (folder->klass->add_msgs != NULL) {
3025                 ret = folder->klass->add_msgs(folder, dest, file_list, relation);
3026                 if (ret < 0) {
3027                         g_relation_destroy(relation);
3028                         return ret;
3029                 }
3030         } else {
3031                 for (file_cur = file_list; file_cur != NULL; file_cur = g_slist_next(file_cur)) {
3032                         fileinfo = (MsgFileInfo *) file_cur->data;
3033
3034                         ret = folder->klass->add_msg(folder, dest, fileinfo->file, fileinfo->flags);
3035                         if (ret < 0) {
3036                                 g_relation_destroy(relation);
3037                                 return ret;
3038                         }
3039                         g_relation_insert(relation, fileinfo, GINT_TO_POINTER(ret));
3040                 }
3041         }
3042
3043         for (file_cur = file_list; file_cur != NULL; file_cur = g_slist_next(file_cur)) {
3044                 GTuples *tuples;
3045
3046                 fileinfo = (MsgFileInfo *) file_cur->data;
3047                 tuples = g_relation_select(relation, fileinfo, 0);
3048                 num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
3049                 g_tuples_destroy(tuples);
3050
3051                 if (num >= 0) {
3052                         MsgInfo *newmsginfo;
3053
3054                         if (num == 0) {
3055                                 if (!folderscan) {
3056                                         folder_item_scan_full(dest, FALSE);
3057                                         folderscan = TRUE;
3058                                 }
3059                                 num = folder_item_get_msg_num_by_file(dest, fileinfo->file);
3060                                 debug_print("got num %d\n", num);
3061                         }
3062
3063                         if (num > lastnum)
3064                                 lastnum = num;
3065
3066                         if (num >= 0 && remove_source) {
3067                                 if (claws_unlink(fileinfo->file) < 0)
3068                                         FILE_OP_ERROR(fileinfo->file, "unlink");
3069                         }
3070
3071                         if (num == 0)
3072                                 continue;
3073
3074                         if (!folderscan &&
3075                             ((newmsginfo = get_msginfo(dest, num)) != NULL)) {
3076                                 add_msginfo_to_cache(dest, newmsginfo, NULL);
3077                                 procmsg_msginfo_free(newmsginfo);
3078                         } else if ((newmsginfo = msgcache_get_msg(dest->cache, num)) != NULL) {
3079                                 /* TODO: set default flags */
3080                                 procmsg_msginfo_free(newmsginfo);
3081                         }
3082                 }
3083         }
3084
3085         g_relation_destroy(relation);
3086
3087         return lastnum;
3088 }
3089
3090 static FolderItem *folder_item_move_recursive(FolderItem *src, FolderItem *dest, gboolean copy)
3091 {
3092         GSList *mlist;
3093         FolderItem *new_item;
3094         FolderItem *next_item;
3095         GNode *srcnode;
3096         gchar *old_id, *new_id;
3097
3098         /* move messages */
3099         debug_print("%s %s to %s\n", copy?"Copying":"Moving", src->path, dest->path);
3100         new_item = folder_create_folder(dest, src->name);
3101         if (new_item == NULL) {
3102                 g_print("Can't create folder\n");
3103                 return NULL;
3104         }
3105
3106         if (new_item->folder == NULL)
3107                 new_item->folder = dest->folder;
3108
3109         /* move messages */
3110         log_message(LOG_PROTOCOL, copy ?_("Copying %s to %s...\n"):_("Moving %s to %s...\n"),
3111                         src->name, new_item->path);
3112
3113         mlist = folder_item_get_msg_list(src);
3114
3115         if (mlist != NULL) {
3116                 if (copy)
3117                         folder_item_copy_msgs(new_item, mlist);
3118                 else
3119                         folder_item_move_msgs(new_item, mlist);
3120                 procmsg_msg_list_free(mlist);
3121         }
3122
3123         /*copy prefs*/
3124         folder_item_prefs_copy_prefs(src, new_item);
3125
3126         /* copy internal data */
3127         if (src->folder->klass == new_item->folder->klass &&
3128             src->folder->klass->copy_private_data != NULL)
3129                 src->folder->klass->copy_private_data(src->folder,
3130                                         src, new_item);
3131         new_item->collapsed = src->collapsed;
3132         new_item->thread_collapsed = src->thread_collapsed;
3133         new_item->threaded  = src->threaded;
3134         new_item->ret_rcpt  = src->ret_rcpt;
3135         new_item->hide_read_msgs = src->hide_read_msgs;
3136         new_item->sort_key  = src->sort_key;
3137         new_item->sort_type = src->sort_type;
3138
3139         prefs_matcher_write_config();
3140
3141         /* recurse */
3142         srcnode = src->folder->node;
3143         srcnode = g_node_find(srcnode, G_PRE_ORDER, G_TRAVERSE_ALL, src);
3144         srcnode = srcnode->children;
3145         while (srcnode != NULL) {
3146                 if (srcnode && srcnode->data) {
3147                         next_item = (FolderItem*) srcnode->data;
3148                         srcnode = srcnode->next;
3149                         if (folder_item_move_recursive(next_item, new_item, copy) == NULL) {
3150                                 return NULL;
3151                         }
3152                 }
3153         }
3154         old_id = folder_item_get_identifier(src);
3155         new_id = folder_item_get_identifier(new_item);
3156
3157         /* if src supports removing, otherwise only copy folder */
3158         if (src->folder->klass->remove_folder != NULL && !copy)
3159                 src->folder->klass->remove_folder(src->folder, src);
3160         folder_write_list();
3161
3162         if (!copy) {
3163                 debug_print("updating rules : %s => %s\n", old_id, new_id);
3164                 if (old_id != NULL && new_id != NULL) {
3165                         prefs_filtering_rename_path(old_id, new_id);
3166                         account_rename_path(old_id, new_id);
3167                 }
3168         }
3169         g_free(old_id);
3170         g_free(new_id);
3171
3172         return new_item;
3173 }
3174
3175 gint folder_item_move_to(FolderItem *src, FolderItem *dest, FolderItem **new_item, gboolean copy)
3176 {
3177         FolderItem *tmp = folder_item_parent(dest);
3178         gchar * src_identifier, * dst_identifier;
3179         gchar * phys_srcpath, * phys_dstpath, *tmppath;
3180
3181         while (tmp) {
3182                 if (tmp == src) {
3183                         return F_MOVE_FAILED_DEST_IS_CHILD;
3184                 }
3185                 tmp = folder_item_parent(tmp);
3186         }
3187
3188         tmp = folder_item_parent(src);
3189
3190         src_identifier = folder_item_get_identifier(src);
3191         dst_identifier = folder_item_get_identifier(dest);
3192
3193         if(dst_identifier == NULL && dest->folder && folder_item_parent(dest) == NULL) {
3194                 /* dest can be a root folder */
3195                 dst_identifier = folder_get_identifier(dest->folder);
3196         }
3197         if (src_identifier == NULL || dst_identifier == NULL) {
3198                 debug_print("Can't get identifiers\n");
3199                 return F_MOVE_FAILED;
3200         }
3201
3202         if (src->folder != dest->folder && !copy) {
3203                 return F_MOVE_FAILED_DEST_OUTSIDE_MAILBOX;
3204         }
3205
3206         phys_srcpath = folder_item_get_path(src);
3207         tmppath = folder_item_get_path(dest);
3208         phys_dstpath = g_strconcat(tmppath,
3209                        G_DIR_SEPARATOR_S,
3210                        g_path_get_basename(phys_srcpath),
3211                        NULL);
3212         g_free(tmppath);
3213
3214         if (folder_item_parent(src) == dest || src == dest) {
3215                 g_free(src_identifier);
3216                 g_free(dst_identifier);
3217                 g_free(phys_srcpath);
3218                 g_free(phys_dstpath);
3219                 return F_MOVE_FAILED_DEST_IS_PARENT;
3220         }
3221         debug_print("moving \"%s\" to \"%s\"\n", phys_srcpath, phys_dstpath);
3222         if ((tmp = folder_item_move_recursive(src, dest, copy)) == NULL) {
3223                 return F_MOVE_FAILED;
3224         }
3225
3226         g_free(src_identifier);
3227         g_free(dst_identifier);
3228         g_free(phys_srcpath);
3229         g_free(phys_dstpath);
3230
3231         *new_item = tmp;
3232
3233         return F_MOVE_OK;
3234 }
3235
3236 /**
3237  * Copy a list of message to a new folder and remove
3238  * source messages if wanted
3239  */
3240 static gint do_copy_msgs(FolderItem *dest, GSList *msglist, gboolean remove_source)
3241 {
3242         Folder *folder;
3243         GSList *l;
3244         gint num, lastnum = -1;
3245         gboolean folderscan = FALSE;
3246         GRelation *relation;
3247         GSList *not_moved = NULL;
3248         gint total = 0, curmsg = 0;
3249         MsgInfo *msginfo = NULL;
3250
3251         g_return_val_if_fail(dest != NULL, -1);
3252         g_return_val_if_fail(msglist != NULL, -1);
3253
3254         folder = dest->folder;
3255
3256         g_return_val_if_fail(folder->klass->copy_msg != NULL, -1);
3257         if (dest->no_select)
3258                 return -1;
3259
3260         msginfo = (MsgInfo *)msglist->data;
3261
3262         if (!msginfo)
3263                 return -1;
3264
3265         if (!MSG_IS_QUEUED(msginfo->flags) &&
3266             MSG_IS_DRAFT(msginfo->flags) &&
3267             folder_has_parent_of_type(dest, F_QUEUE)) {
3268                 GSList *cur = msglist;
3269                 gboolean queue_err = FALSE;
3270                 for (; cur; cur = cur->next) {
3271                         Compose *compose = NULL;
3272                         FolderItem *queue = dest;
3273                         int val = 0;
3274
3275                         msginfo = (MsgInfo *)cur->data;
3276                         compose = compose_reedit(msginfo, TRUE);
3277                         if (compose == NULL) {
3278                                 queue_err = TRUE;
3279                                 continue;
3280                         }
3281                         val = compose_queue(compose, NULL, &queue, NULL,
3282                                         FALSE);
3283                         if (val < 0) {
3284                                 queue_err = TRUE;
3285                         } else if (remove_source) {
3286                                 folder_item_remove_msg(msginfo->folder, msginfo->msgnum);
3287                         }
3288                         if (val == 0)
3289                                 compose_close(compose);
3290                 }
3291                 return queue_err ? -1:0;
3292         }
3293
3294         relation = g_relation_new(2);
3295         g_relation_index(relation, 0, g_direct_hash, g_direct_equal);
3296         g_relation_index(relation, 1, g_direct_hash, g_direct_equal);
3297
3298         for (l = msglist ; l != NULL ; l = g_slist_next(l)) {
3299                 MsgInfo * msginfo = (MsgInfo *) l->data;
3300
3301                 if (msginfo->planned_download != 0) {
3302                         int old_planned = msginfo->planned_download;
3303                         partial_unmark(msginfo);
3304                         /* little hack to reenable after */
3305                         msginfo->planned_download = old_planned;
3306                 }
3307         }
3308
3309         /*
3310          * Copy messages to destination folder and
3311          * store new message numbers in newmsgnums
3312          */
3313         if (folder->klass->copy_msgs != NULL) {
3314                 if (folder->klass->copy_msgs(folder, dest, msglist, relation) < 0) {
3315                         g_relation_destroy(relation);
3316                         return -1;
3317                 }
3318         } else {
3319                 MsgInfo * msginfo;
3320                 l = msglist;
3321
3322                 /* immediately stop if src and dest folders are identical */
3323                 if (l != NULL) {
3324                         msginfo = (MsgInfo *) l->data;
3325                         if (msginfo != NULL && msginfo->folder == dest) {
3326                                 g_relation_destroy(relation);
3327                                 return -1;
3328                         }
3329                 }
3330
3331                 for (; l != NULL ; l = g_slist_next(l)) {
3332                         msginfo = (MsgInfo *) l->data;
3333
3334                         num = folder->klass->copy_msg(folder, dest, msginfo);
3335                         if (num > 0)
3336                                 g_relation_insert(relation, msginfo, GINT_TO_POINTER(num));
3337                         else
3338                                 not_moved = g_slist_prepend(not_moved, msginfo);
3339                 }
3340         }
3341
3342         if (remove_source) {
3343                 MsgInfo *msginfo = (MsgInfo *) msglist->data;
3344                 FolderItem *item = msginfo->folder;
3345                 /*
3346                  * Remove source messages from their folders if
3347                  * copying was successfull and update folder
3348                  * message counts
3349                  */
3350                 if (not_moved == NULL && item->folder->klass->remove_msgs) {
3351                         item->folder->klass->remove_msgs(item->folder,
3352                                                                 msginfo->folder,
3353                                                                 msglist,
3354                                                                 relation);
3355                 }
3356                 for (l = msglist; l != NULL; l = g_slist_next(l)) {
3357                         GTuples *tuples;
3358                         msginfo = (MsgInfo *) l->data;
3359                         item = msginfo->folder;
3360
3361                         tuples = g_relation_select(relation, msginfo, 0);
3362                         if (tuples) {
3363                                 if (tuples->len)
3364                                         num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
3365                                 else
3366                                         num = 0;
3367                                 g_tuples_destroy(tuples);
3368                         } else {
3369                                 num = -1;
3370                         }
3371
3372                         if (g_slist_find(not_moved, msginfo))
3373                                 continue;
3374
3375                         if ((num >= 0) && (item->folder->klass->remove_msg != NULL)) {
3376                                 if (!item->folder->klass->remove_msgs)
3377                                         item->folder->klass->remove_msg(item->folder,
3378                                                                 msginfo->folder,
3379                                                                 msginfo->msgnum);
3380                                 remove_msginfo_from_cache(item, msginfo);
3381                         }
3382                 }
3383         }
3384
3385         /* Read cache for dest folder */
3386         if (!dest->cache) folder_item_read_cache(dest);
3387
3388         /*
3389          * Fetch new MsgInfos for new messages in dest folder,
3390          * add them to the msgcache and update folder message counts
3391          */
3392         if (g_relation_count(relation, GINT_TO_POINTER(0), 1) > 0) {
3393                 folder_item_scan_full(dest, FALSE);
3394                 folderscan = TRUE;
3395         }
3396
3397         statusbar_print_all(_("Updating cache for %s..."), dest->path ? dest->path : "(null)");
3398         total = g_slist_length(msglist);
3399
3400         if (FOLDER_TYPE(dest->folder) == F_IMAP && total > 1) {
3401                 folder_item_scan_full(dest, FALSE);
3402                 folderscan = TRUE;
3403         }
3404         folder_item_set_batch(dest, TRUE);
3405         for (l = msglist; l != NULL; l = g_slist_next(l)) {
3406                 MsgInfo *msginfo = (MsgInfo *) l->data;
3407                 GTuples *tuples;
3408
3409                 tuples = g_relation_select(relation, msginfo, 0);
3410                 if (tuples->len > 0) {
3411                         num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
3412                         g_tuples_destroy(tuples);
3413                 } else {
3414                         num = 0;
3415                         if (tuples)
3416                                 g_tuples_destroy(tuples);
3417                 }
3418                 statusbar_progress_all(curmsg++,total, 100);
3419                 if (curmsg % 100 == 0)
3420                         GTK_EVENTS_FLUSH();
3421
3422                 if (num >= 0) {
3423                         MsgInfo *newmsginfo = NULL;
3424
3425                         if (!folderscan && num > 0) {
3426                                 newmsginfo = get_msginfo(dest, num);
3427                                 if (newmsginfo != NULL) {
3428                                         add_msginfo_to_cache(dest, newmsginfo, msginfo);
3429                                 }
3430                         }
3431                         if (newmsginfo == NULL) {
3432                                 if (!folderscan) {
3433                                         folder_item_scan_full(dest, FALSE);
3434                                         folderscan = TRUE;
3435                                 }
3436                                 if (msginfo->msgid != NULL) {
3437                                         newmsginfo = folder_item_get_msginfo_by_msgid(dest, msginfo->msgid);
3438                                         if (newmsginfo != NULL) {
3439                                                 copy_msginfo_flags(msginfo, newmsginfo);
3440                                                 num = newmsginfo->msgnum;
3441                                         }
3442                                 }
3443                         }
3444
3445                         if (msginfo->planned_download
3446                             == POP3_PARTIAL_DLOAD_DELE) {
3447                                 partial_mark_for_delete(newmsginfo);
3448                         }
3449                         if (msginfo->planned_download
3450                             == POP3_PARTIAL_DLOAD_DLOAD) {
3451                                 partial_mark_for_download(newmsginfo);
3452                         }
3453                         if (!MSG_IS_POSTFILTERED (msginfo->flags)) {
3454                             procmsg_msginfo_set_flags (   msginfo, MSG_POSTFILTERED, 0);
3455                             procmsg_msginfo_set_flags (newmsginfo, MSG_POSTFILTERED, 0);
3456                             hooks_invoke (MAIL_POSTFILTERING_HOOKLIST, newmsginfo);
3457                         }
3458                         procmsg_msginfo_free(newmsginfo);
3459
3460
3461                         if (num > lastnum)
3462                                 lastnum = num;
3463                 }
3464         }
3465         folder_item_set_batch(dest, FALSE);
3466         statusbar_progress_all(0,0,0);
3467         statusbar_pop_all();
3468
3469         g_relation_destroy(relation);
3470         if (not_moved != NULL) {
3471                 g_slist_free(not_moved);
3472                 return -1;
3473         } else
3474                 return lastnum;
3475 }
3476
3477 /**
3478  * Move a message to a new folder.
3479  *
3480  * \param dest Destination folder
3481  * \param msginfo The message
3482  */
3483 gint folder_item_move_msg(FolderItem *dest, MsgInfo *msginfo)
3484 {
3485         GSList list;
3486
3487         g_return_val_if_fail(dest != NULL, -1);
3488         g_return_val_if_fail(msginfo != NULL, -1);
3489
3490         list.data = msginfo;
3491         list.next = NULL;
3492
3493         return do_copy_msgs(dest, &list, TRUE);
3494 }
3495
3496 /**
3497  * Move a list of messages to a new folder.
3498  *
3499  * \param dest Destination folder
3500  * \param msglist List of messages
3501  */
3502 gint folder_item_move_msgs(FolderItem *dest, GSList *msglist)
3503 {
3504         gint result = -1;
3505         g_return_val_if_fail(dest != NULL, -1);
3506         g_return_val_if_fail(msglist != NULL, -1);
3507         inc_lock();
3508         result = do_copy_msgs(dest, msglist, TRUE);
3509         inc_unlock();
3510         return result;
3511 }
3512
3513 /**
3514  * Copy a message to a new folder.
3515  *
3516  * \param dest Destination folder
3517  * \param msginfo The message
3518  */
3519 gint folder_item_copy_msg(FolderItem *dest, MsgInfo *msginfo)
3520 {
3521         GSList list;
3522
3523         g_return_val_if_fail(dest != NULL, -1);
3524         g_return_val_if_fail(msginfo != NULL, -1);
3525
3526         list.data = msginfo;
3527         list.next = NULL;
3528
3529         return do_copy_msgs(dest, &list, FALSE);
3530 }
3531
3532 /**
3533  * Copy a list of messages to a new folder.
3534  *
3535  * \param dest Destination folder
3536  * \param msglist List of messages
3537  */
3538 gint folder_item_copy_msgs(FolderItem *dest, GSList *msglist)
3539 {
3540         gint result;
3541         g_return_val_if_fail(dest != NULL, -1);
3542         g_return_val_if_fail(msglist != NULL, -1);
3543
3544         inc_lock();
3545         result = do_copy_msgs(dest, msglist, FALSE);
3546         inc_unlock();
3547
3548         return result;
3549 }
3550
3551 gint folder_item_remove_msg(FolderItem *item, gint num)
3552 {
3553         Folder *folder;
3554         gint ret;
3555         MsgInfo *msginfo;
3556
3557         g_return_val_if_fail(item != NULL, -1);
3558         folder = item->folder;
3559         g_return_val_if_fail(folder->klass->remove_msg != NULL, -1);
3560         if (item->no_select)
3561                 return -1;
3562
3563         if (!item->cache) folder_item_read_cache(item);
3564
3565         msginfo = msgcache_get_msg(item->cache, num);
3566         if (msginfo && MSG_IS_LOCKED(msginfo->flags)) {
3567                 procmsg_msginfo_free(msginfo);
3568                 return -1;
3569         }
3570         ret = folder->klass->remove_msg(folder, item, num);
3571
3572         if (msginfo != NULL) {
3573                 remove_msginfo_from_cache(item, msginfo);
3574                 procmsg_msginfo_free(msginfo);
3575         }
3576
3577         return ret;
3578 }
3579
3580 gint folder_item_remove_msgs(FolderItem *item, GSList *msglist)
3581 {
3582         Folder *folder;
3583         gint ret = 0;
3584         GSList *real_list = NULL, *cur = NULL;
3585
3586         g_return_val_if_fail(item != NULL, -1);
3587         folder = item->folder;
3588         g_return_val_if_fail(folder != NULL, -1);
3589         if (item->no_select)
3590                 return -1;
3591         inc_lock();
3592         if (!item->cache) folder_item_read_cache(item);
3593
3594         folder_item_update_freeze();
3595
3596         /* filter out locked mails */
3597         for (cur = msglist; cur; cur = cur->next) {
3598                 MsgInfo *info = (MsgInfo *)cur->data;
3599                 if (!MSG_IS_LOCKED(info->flags))
3600                         real_list = g_slist_prepend(real_list, info);
3601         }
3602
3603         real_list = g_slist_reverse(real_list);
3604
3605         if (item->folder->klass->remove_msgs) {
3606                 ret = item->folder->klass->remove_msgs(item->folder,
3607                                                         item,
3608                                                         real_list,
3609                                                         NULL);
3610         }
3611         while (ret == 0 && real_list != NULL) {
3612                 MsgInfo *msginfo = (MsgInfo *)real_list->data;
3613                 if (msginfo && MSG_IS_LOCKED(msginfo->flags)) {
3614                         real_list = real_list->next;
3615                         continue;
3616                 }
3617                 if (!item->folder->klass->remove_msgs)
3618                         ret = folder_item_remove_msg(item, msginfo->msgnum);
3619                 if (ret != 0) break;
3620                 msgcache_remove_msg(item->cache, msginfo->msgnum);
3621                 real_list = real_list->next;
3622         }
3623         g_slist_free(real_list);
3624         folder_item_scan_full(item, FALSE);
3625         folder_item_update_thaw();
3626         inc_unlock();
3627         return ret;
3628 }
3629
3630 gint folder_item_remove_all_msg(FolderItem *item)
3631 {
3632         Folder *folder;
3633         gint result;
3634
3635         g_return_val_if_fail(item != NULL, -1);
3636         if (item->no_select)
3637                 return -1;
3638
3639         folder = item->folder;
3640
3641         inc_lock();
3642         if (folder->klass->remove_all_msg != NULL) {
3643                 result = folder->klass->remove_all_msg(folder, item);
3644
3645                 if (result == 0) {
3646                         folder_item_free_cache(item, TRUE);
3647                         item->cache = msgcache_new();
3648                 }
3649         } else {
3650                 MsgInfoList *msglist;
3651
3652                 msglist = folder_item_get_msg_list(item);
3653                 result = folder_item_remove_msgs(item, msglist);
3654                 procmsg_msg_list_free(msglist);
3655         }
3656
3657         if (result == 0) {
3658                 item->new_msgs = 0;
3659                 item->unread_msgs = 0;
3660                 item->unreadmarked_msgs = 0;
3661                 item->marked_msgs = 0;
3662                 item->total_msgs = 0;
3663                 item->replied_msgs = 0;
3664                 item->forwarded_msgs = 0;
3665                 item->locked_msgs = 0;
3666                 item->ignored_msgs = 0;
3667                 item->watched_msgs = 0;
3668                 folder_item_update(item, F_ITEM_UPDATE_MSGCNT | F_ITEM_UPDATE_CONTENT);
3669         }
3670
3671         inc_unlock();
3672         return result;
3673 }
3674
3675 void folder_item_change_msg_flags(FolderItem *item, MsgInfo *msginfo, MsgPermFlags newflags)
3676 {
3677         g_return_if_fail(item != NULL);
3678         g_return_if_fail(msginfo != NULL);
3679         if (item->no_select)
3680                 return;
3681
3682         if (item->folder->klass->change_flags != NULL && item->scanning != ITEM_SCANNING_WITH_FLAGS) {
3683                 item->folder->klass->change_flags(item->folder, item, msginfo, newflags);
3684         } else {
3685                 msginfo->flags.perm_flags = newflags;
3686         }
3687 }
3688
3689 void folder_item_commit_tags(FolderItem *item, MsgInfo *msginfo, GSList *tags_set, GSList *tags_unset)
3690 {
3691         Folder *folder = NULL;
3692
3693         if (!msginfo)
3694                 return;
3695         if (!item)
3696                 return;
3697         if (!tags_set && !tags_unset)
3698                 return;
3699
3700         folder = item->folder;
3701         if (!folder)
3702                 return;
3703
3704         if (folder->klass->commit_tags == NULL)
3705                 return;
3706
3707         folder->klass->commit_tags(item, msginfo, tags_set, tags_unset);
3708 }
3709
3710 gboolean folder_item_is_msg_changed(FolderItem *item, MsgInfo *msginfo)
3711 {
3712         Folder *folder;
3713
3714         g_return_val_if_fail(item != NULL, FALSE);
3715         if (item->no_select)
3716                 return FALSE;
3717
3718         folder = item->folder;
3719
3720         g_return_val_if_fail(folder->klass->is_msg_changed != NULL, -1);
3721
3722         return folder->klass->is_msg_changed(folder, item, msginfo);
3723 }
3724
3725 void folder_item_discard_cache(FolderItem *item)
3726 {
3727         gchar *dir;
3728         gchar *cache;
3729
3730         if (!item)
3731                 return;
3732
3733         if (item->cache) {
3734                 msgcache_destroy(item->cache);
3735                 item->cache = NULL;
3736         }
3737         dir = folder_item_get_path(item);
3738         if (is_dir_exist(dir))
3739                 remove_all_numbered_files(dir);
3740         g_free(dir);
3741
3742         cache = folder_item_get_cache_file(item);
3743         if (is_file_exist(cache))
3744                 claws_unlink(cache);
3745         g_free(cache);
3746
3747 }
3748
3749 static gchar *folder_item_get_cache_file(FolderItem *item)
3750 {
3751         gchar *path;
3752         gchar *file;
3753         gchar *old_file;
3754
3755         g_return_val_if_fail(item != NULL, NULL);
3756         g_return_val_if_fail(item->path != NULL, NULL);
3757
3758         path = folder_item_get_path(item);
3759         g_return_val_if_fail(path != NULL, NULL);
3760         if (!is_dir_exist(path))
3761                 make_dir_hier(path);
3762         file = g_strconcat(path, G_DIR_SEPARATOR_S, CACHE_FILE, NULL);
3763         old_file = g_strconcat(path, G_DIR_SEPARATOR_S, OLD_CACHE_FILE, NULL);
3764
3765         if (!is_file_exist(file) && is_file_exist(old_file))
3766                 move_file(old_file, file, FALSE);
3767         g_free(old_file);
3768         g_free(path);
3769
3770         return file;
3771 }
3772
3773 static gchar *folder_item_get_mark_file(FolderItem *item)
3774 {
3775         gchar *path;
3776         gchar *file;
3777         gchar *old_file;
3778
3779         g_return_val_if_fail(item != NULL, NULL);
3780         g_return_val_if_fail(item->path != NULL, NULL);
3781
3782         path = folder_item_get_path(item);
3783         g_return_val_if_fail(path != NULL, NULL);
3784         if (!is_dir_exist(path))
3785                 make_dir_hier(path);
3786         file = g_strconcat(path, G_DIR_SEPARATOR_S, MARK_FILE, NULL);
3787         old_file = g_strconcat(path, G_DIR_SEPARATOR_S, OLD_MARK_FILE, NULL);
3788
3789         if (!is_file_exist(file) && is_file_exist(old_file))
3790                 move_file(old_file, file, FALSE);
3791         g_free(old_file);
3792         g_free(path);
3793
3794         return file;
3795 }
3796
3797 static gchar *folder_item_get_tags_file(FolderItem *item)
3798 {
3799         gchar *path;
3800         gchar *identifier;
3801         gchar *file;
3802
3803         /* we save tags files in rc_dir, because tagsrc is there too,
3804          * and storing tags directly in the mailboxes would give strange
3805          * result when using another Claws mailbox from another install
3806          * with different tags. */
3807
3808         g_return_val_if_fail(item != NULL, NULL);
3809
3810         identifier = folder_item_get_identifier(item);
3811         g_return_val_if_fail(identifier != NULL, NULL);
3812
3813 #ifdef G_OS_WIN32
3814         while (strchr(identifier, '/'))
3815                 *strchr(identifier, '/') = '\\';
3816 #endif
3817
3818         path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
3819                            "tagsdb", G_DIR_SEPARATOR_S,
3820                            identifier, NULL);
3821
3822         g_free(identifier);
3823
3824         if (!is_dir_exist(path))
3825                 make_dir_hier(path);
3826
3827         file = g_strconcat(path, G_DIR_SEPARATOR_S, TAGS_FILE, NULL);
3828
3829         g_free(path);
3830
3831         return file;
3832 }
3833
3834 static gpointer xml_to_folder_item(gpointer nodedata, gpointer data)
3835 {
3836         XMLNode *xmlnode = (XMLNode *) nodedata;
3837         Folder *folder = (Folder *) data;
3838         FolderItem *item;
3839
3840         g_return_val_if_fail(xmlnode != NULL, NULL);
3841         g_return_val_if_fail(folder != NULL, NULL);
3842
3843         if (strcmp2(xmlnode->tag->tag, "folderitem") != 0) {
3844                 g_warning("tag name != \"folderitem\"\n");
3845                 return NULL;
3846         }
3847
3848         item = folder_item_new(folder, "", "");
3849         if (folder->klass->item_set_xml != NULL)
3850                 folder->klass->item_set_xml(folder, item, xmlnode->tag);
3851         else
3852                 folder_item_set_xml(folder, item, xmlnode->tag);
3853
3854         item->folder = folder;
3855
3856         switch (item->stype) {
3857         case F_INBOX:  folder->inbox  = item; break;
3858         case F_OUTBOX: folder->outbox = item; break;
3859         case F_DRAFT:  folder->draft  = item; break;
3860         case F_QUEUE:  folder->queue  = item; break;
3861         case F_TRASH:  folder->trash  = item; break;
3862         default:       break;
3863         }
3864         folder_item_prefs_read_config(item);
3865
3866         return item;
3867 }
3868
3869 static gboolean folder_item_set_node(GNode *node, gpointer data)
3870 {
3871         FolderItem *item = (FolderItem *) node->data;
3872         item->node = node;
3873
3874         return FALSE;
3875 }
3876
3877 static Folder *folder_get_from_xml(GNode *node)
3878 {
3879         Folder *folder;
3880         XMLNode *xmlnode;
3881         GList *list;
3882         FolderClass *klass = NULL;
3883         GNode *cur;
3884
3885         g_return_val_if_fail(node->data != NULL, NULL);
3886
3887         xmlnode = node->data;
3888         if (strcmp2(xmlnode->tag->tag, "folder") != 0) {
3889                 g_warning("tag name != \"folder\"\n");
3890                 return NULL;
3891         }
3892         list = xmlnode->tag->attr;
3893         for (; list != NULL; list = list->next) {
3894                 XMLAttr *attr = list->data;
3895
3896                 if (!attr || !attr->name || !attr->value) continue;
3897                 if (!strcmp(attr->name, "type"))
3898                         klass = folder_get_class_from_string(attr->value);
3899         }
3900         if (klass == NULL)
3901                 return NULL;
3902
3903         folder = folder_new(klass, "", "");
3904         g_return_val_if_fail(folder != NULL, NULL);
3905
3906         if (klass->set_xml)
3907                 klass->set_xml(folder, xmlnode->tag);
3908         else
3909                 folder_set_xml(folder, xmlnode->tag);
3910
3911         cur = node->children;
3912         while (cur != NULL) {
3913                 GNode *itemnode;
3914
3915                 itemnode = g_node_map(cur, xml_to_folder_item, (gpointer) folder);
3916                 g_node_append(folder->node, itemnode);
3917                 cur = cur->next;
3918         }
3919         g_node_traverse(folder->node, G_IN_ORDER, G_TRAVERSE_ALL, -1, folder_item_set_node, NULL);
3920
3921         return folder;
3922 }
3923
3924 static gchar *folder_get_list_path(void)
3925 {
3926         static gchar *filename = NULL;
3927
3928         if (!filename)
3929                 filename =  g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
3930                                         FOLDER_LIST, NULL);
3931
3932         return filename;
3933 }
3934
3935 static gpointer folder_item_to_xml(gpointer nodedata, gpointer data)
3936 {
3937         FolderItem *item = (FolderItem *) nodedata;
3938         XMLTag *tag;
3939
3940         g_return_val_if_fail(item != NULL, NULL);
3941
3942         if (item->folder->klass->item_get_xml != NULL)
3943                 tag = item->folder->klass->item_get_xml(item->folder, item);
3944         else
3945                 tag = folder_item_get_xml(item->folder, item);
3946
3947         return xml_node_new(tag, NULL);
3948 }
3949
3950 static GNode *folder_get_xml_node(Folder *folder)
3951 {
3952         GNode *node;
3953         XMLNode *xmlnode;
3954         XMLTag *tag;
3955
3956         g_return_val_if_fail(folder != NULL, NULL);
3957
3958         if (folder->klass->get_xml != NULL)
3959                 tag = folder->klass->get_xml(folder);
3960         else
3961                 tag = folder_get_xml(folder);
3962
3963         xml_tag_add_attr(tag, xml_attr_new("type", folder->klass->idstr));
3964
3965         xmlnode = xml_node_new(tag, NULL);
3966
3967         node = g_node_new(xmlnode);
3968
3969         g_return_val_if_fail (folder->node != NULL, NULL);
3970
3971         if (folder->node->children) {
3972                 GNode *cur;
3973
3974                 cur = folder->node->children;
3975                 while (cur) {
3976                         GNode *xmlnode;
3977
3978                         xmlnode = g_node_map(cur, folder_item_to_xml, (gpointer) folder);
3979                         g_node_append(node, xmlnode);
3980                         cur = cur->next;
3981                 }
3982         }
3983
3984         return node;
3985 }
3986
3987 static void folder_update_op_count_rec(GNode *node)
3988 {
3989         FolderItem *fitem = FOLDER_ITEM(node->data);
3990
3991         if (g_node_depth(node) > 0) {
3992                 if (fitem->op_count > 0) {
3993                         fitem->op_count = 0;
3994                         folder_item_update(fitem, F_ITEM_UPDATE_MSGCNT);
3995                 }
3996                 if (node->children) {
3997                         GNode *child;
3998
3999                         child = node->children;
4000                         while (child) {
4001                                 GNode *cur;
4002
4003                                 cur = child;
4004                                 child = cur->next;
4005                                 folder_update_op_count_rec(cur);
4006                         }
4007                 }
4008         }
4009 }
4010
4011 void folder_update_op_count(void)
4012 {
4013         GList *cur;
4014         Folder *folder;
4015
4016         for (cur = folder_list; cur != NULL; cur = cur->next) {
4017                 folder = cur->data;
4018                 folder_update_op_count_rec(folder->node);
4019         }
4020 }
4021
4022 typedef struct _type_str {
4023         gchar * str;
4024         gint type;
4025 } type_str;
4026
4027
4028 /*
4029 static gchar * folder_item_get_tree_identifier(FolderItem * item)
4030 {
4031         if (item->parent != NULL) {
4032                 gchar * path;
4033                 gchar * id;
4034
4035                 path = folder_item_get_tree_identifier(item->parent);
4036                 if (path == NULL)
4037                         return NULL;
4038
4039                 id = g_strconcat(path, "/", item->name, NULL);
4040                 g_free(path);
4041
4042                 return id;
4043         }
4044         else {
4045                 return g_strconcat("/", item->name, NULL);
4046         }
4047 }
4048 */
4049
4050 /* CLAWS: temporary local folder for filtering */
4051 #define TEMP_FOLDER "TEMP_FOLDER"
4052 #define PROCESSING_FOLDER_ITEM "processing"
4053
4054 static FolderItem *processing_folder_item;
4055
4056 static void folder_create_processing_folder(void)
4057 {
4058         Folder *processing_folder;
4059         gchar      *tmpname;
4060
4061         if ((processing_folder = folder_find_from_name(TEMP_FOLDER, mh_get_class())) == NULL) {
4062                 gchar *tmppath;
4063
4064                 tmppath =
4065                     g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
4066                                 "tempfolder", NULL);
4067                 processing_folder =
4068                     folder_new(mh_get_class(), TEMP_FOLDER, tmppath);
4069                 g_free(tmppath);
4070         }
4071         g_assert(processing_folder != NULL);
4072
4073         debug_print("tmpparentroot %s\n", LOCAL_FOLDER(processing_folder)->rootpath);
4074         /* FIXME: [W32] The code below does not correctly merge
4075            relative filenames; there should be a function to handle
4076            this.  */
4077         if (!is_relative_filename(LOCAL_FOLDER(processing_folder)->rootpath))
4078                 tmpname = g_strconcat(LOCAL_FOLDER(processing_folder)->rootpath,
4079                                       G_DIR_SEPARATOR_S, PROCESSING_FOLDER_ITEM,
4080                                       NULL);
4081         else
4082                 tmpname = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
4083                                       LOCAL_FOLDER(processing_folder)->rootpath,
4084                                       G_DIR_SEPARATOR_S, PROCESSING_FOLDER_ITEM,
4085                                       NULL);
4086
4087         if (!is_dir_exist(tmpname)) {
4088                 debug_print("*TMP* creating %s\n", tmpname);
4089                 processing_folder_item = processing_folder->klass->create_folder(processing_folder,
4090                                                                                  processing_folder->node->data,
4091                                                                                  PROCESSING_FOLDER_ITEM);
4092         } else {
4093                 debug_print("*TMP* already created\n");
4094                 processing_folder_item = folder_item_new(processing_folder, PROCESSING_FOLDER_ITEM, PROCESSING_FOLDER_ITEM);
4095                 g_assert(processing_folder_item);
4096                 folder_item_append(processing_folder->node->data, processing_folder_item);
4097         }
4098         g_assert(processing_folder_item != NULL);
4099         g_free(tmpname);
4100 }
4101
4102 FolderItem *folder_get_default_processing(void)
4103 {
4104         if (!processing_folder_item) {
4105                 folder_create_processing_folder();
4106         }
4107         return processing_folder_item;
4108 }
4109
4110 /* folder_persist_prefs_new() - return hash table with persistent
4111  * settings (and folder name as key).
4112  * (note that in claws other options are in the folder_item_prefs_RC
4113  * file, so those don't need to be included in PersistPref yet)
4114  */
4115 static GHashTable *folder_persist_prefs_new(Folder *folder)
4116 {
4117         GHashTable *pptable;
4118
4119         g_return_val_if_fail(folder, NULL);
4120         pptable = g_hash_table_new(g_str_hash, g_str_equal);
4121         folder_get_persist_prefs_recursive(folder->node, pptable);
4122         return pptable;
4123 }
4124
4125 static void folder_persist_prefs_free(GHashTable *pptable)
4126 {
4127         g_return_if_fail(pptable);
4128         g_hash_table_foreach_remove(pptable, persist_prefs_free, NULL);
4129         g_hash_table_destroy(pptable);
4130 }
4131
4132 static const PersistPrefs *folder_get_persist_prefs(GHashTable *pptable, const char *name)
4133 {
4134         if (pptable == NULL || name == NULL) return NULL;
4135         return g_hash_table_lookup(pptable, name);
4136 }
4137
4138 static void folder_item_restore_persist_prefs(FolderItem *item, GHashTable *pptable)
4139 {
4140         const PersistPrefs *pp;
4141         gchar *id = folder_item_get_identifier(item);
4142
4143         pp = folder_get_persist_prefs(pptable, id);
4144         g_free(id);
4145
4146         if (!pp) return;
4147
4148         /* CLAWS: since not all folder properties have been migrated to
4149          * folderlist.xml, we need to call the old stuff first before
4150          * setting things that apply both to Main and Claws. */
4151         folder_item_prefs_read_config(item);
4152
4153         item->collapsed = pp->collapsed;
4154         item->thread_collapsed = pp->thread_collapsed;
4155         item->threaded  = pp->threaded;
4156         item->ret_rcpt  = pp->ret_rcpt;
4157         item->hide_read_msgs = pp->hide_read_msgs;
4158         item->sort_key  = pp->sort_key;
4159         item->sort_type = pp->sort_type;
4160 }
4161
4162 static void folder_get_persist_prefs_recursive(GNode *node, GHashTable *pptable)
4163 {
4164         FolderItem *item = FOLDER_ITEM(node->data);
4165         PersistPrefs *pp;
4166         GNode *child, *cur;
4167         gchar *id;
4168
4169         g_return_if_fail(node != NULL);
4170         g_return_if_fail(item != NULL);
4171
4172         /* NOTE: item->path == NULL means top level folder; not interesting
4173          * to store preferences of that one.  */
4174         if (item->path) {
4175                 id = folder_item_get_identifier(item);
4176                 pp = g_new0(PersistPrefs, 1);
4177                 g_return_if_fail(pp != NULL);
4178                 pp->collapsed = item->collapsed;
4179                 pp->thread_collapsed = item->thread_collapsed;
4180                 pp->threaded  = item->threaded;
4181                 pp->ret_rcpt  = item->ret_rcpt;
4182                 pp->hide_read_msgs = item->hide_read_msgs;
4183                 pp->sort_key  = item->sort_key;
4184                 pp->sort_type = item->sort_type;
4185                 g_hash_table_insert(pptable, id, pp);
4186         }
4187
4188         if (node->children) {
4189                 child = node->children;
4190                 while (child) {
4191                         cur = child;
4192                         child = cur->next;
4193                         folder_get_persist_prefs_recursive(cur, pptable);
4194                 }
4195         }
4196 }
4197
4198 static gboolean persist_prefs_free(gpointer key, gpointer val, gpointer data)
4199 {
4200         g_free(key);
4201         g_free(val);
4202         return TRUE;
4203 }
4204
4205 void folder_item_apply_processing(FolderItem *item)
4206 {
4207         GSList *processing_list;
4208         GSList *mlist, *cur;
4209         guint total = 0, curmsg = 0;
4210         gint last_apply_per_account;
4211
4212         g_return_if_fail(item != NULL);
4213
4214         if (item->no_select)
4215                return;
4216
4217         processing_list = item->prefs->processing;
4218
4219         if (!pre_global_processing && !processing_list
4220         &&  !post_global_processing)
4221                 return;
4222
4223         debug_print("processing %s\n", item->name);
4224         folder_item_update_freeze();
4225
4226         inc_lock();
4227
4228         mlist = folder_item_get_msg_list(item);
4229         total = g_slist_length(mlist);
4230         statusbar_print_all(_("Processing messages..."));
4231
4232         last_apply_per_account = prefs_common.apply_per_account_filtering_rules;
4233         prefs_common.apply_per_account_filtering_rules = FILTERING_ACCOUNT_RULES_SKIP;
4234
4235         folder_item_set_batch(item, TRUE);
4236         for (cur = mlist ; cur != NULL ; cur = cur->next) {
4237                 MsgInfo * msginfo;
4238
4239                 msginfo = (MsgInfo *) cur->data;
4240
4241                 /* reset parameters that can be modified by processing */
4242                 msginfo->hidden = 0;
4243                 msginfo->score = 0;
4244
4245                 statusbar_progress_all(curmsg++,total, 10);
4246
4247                 /* apply pre global rules */
4248                 filter_message_by_msginfo(pre_global_processing, msginfo, NULL,
4249                                 FILTERING_PRE_PROCESSING, NULL);
4250
4251                 /* apply rules of the folder */
4252                 filter_message_by_msginfo(processing_list, msginfo, NULL,
4253                                 FILTERING_FOLDER_PROCESSING, item->name);
4254
4255                 /* apply post global rules */
4256                 filter_message_by_msginfo(post_global_processing, msginfo, NULL,
4257                                 FILTERING_POST_PROCESSING, NULL);
4258                 if (curmsg % 1000 == 0)
4259                         GTK_EVENTS_FLUSH();
4260         }
4261         folder_item_set_batch(item, FALSE);
4262
4263         prefs_common.apply_per_account_filtering_rules = last_apply_per_account;
4264
4265         if (pre_global_processing || processing_list
4266             || post_global_processing)
4267                 filtering_move_and_copy_msgs(mlist);
4268         for (cur = mlist ; cur != NULL ; cur = cur->next) {
4269                 MsgInfo * msginfo = (MsgInfo *)cur->data;
4270                 procmsg_msginfo_free(msginfo);
4271         }
4272         g_slist_free(mlist);
4273
4274         statusbar_progress_all(0,0,0);
4275         statusbar_pop_all();
4276
4277         inc_unlock();
4278
4279         folder_item_update_thaw();
4280 }
4281
4282 /*
4283  *  functions for handling FolderItem content changes
4284  */
4285 static gint folder_item_update_freeze_cnt = 0;
4286
4287 static void folder_item_update_with_msg(FolderItem *item, FolderItemUpdateFlags update_flags, MsgInfo *msg)
4288 {
4289         if (folder_item_update_freeze_cnt == 0 /* || (msg != NULL && item->opened) */) {
4290                 FolderItemUpdateData source;
4291
4292                 source.item = item;
4293                 source.update_flags = update_flags;
4294                 source.msg = msg;
4295                 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
4296         } else {
4297                 item->update_flags |= update_flags & ~(F_ITEM_UPDATE_ADDMSG | F_ITEM_UPDATE_REMOVEMSG);
4298         }
4299 }
4300
4301 /**
4302  * Notify the folder system about changes to a folder. If the
4303  * update system is not frozen the FOLDER_ITEM_UPDATE_HOOKLIST will
4304  * be invoked, otherwise the changes will be remebered until
4305  * the folder system is thawed.
4306  *
4307  * \param item The FolderItem that was changed
4308  * \param update_flags Type of changed that was made
4309  */
4310 void folder_item_update(FolderItem *item, FolderItemUpdateFlags update_flags)
4311 {
4312         folder_item_update_with_msg(item, update_flags, NULL);
4313 }
4314
4315 void folder_item_update_recursive(FolderItem *item, FolderItemUpdateFlags update_flags)
4316 {
4317         GNode *node = item->folder->node;
4318
4319         node = g_node_find(node, G_PRE_ORDER, G_TRAVERSE_ALL, item);
4320         node = node->children;
4321
4322         folder_item_update(item, update_flags);
4323         while (node != NULL) {
4324                 if (node && node->data) {
4325                         FolderItem *next_item = (FolderItem*) node->data;
4326
4327                         folder_item_update(next_item, update_flags);
4328                 }
4329                 node = node->next;
4330         }
4331 }
4332
4333 void folder_item_update_freeze(void)
4334 {
4335         folder_item_update_freeze_cnt++;
4336 }
4337
4338 static void folder_item_update_func(FolderItem *item, gpointer data)
4339 {
4340         FolderItemUpdateData source;
4341
4342         if (item->update_flags) {
4343                 source.item = item;
4344                 source.update_flags = item->update_flags;
4345                 source.msg = NULL;
4346                 hooks_invoke(FOLDER_ITEM_UPDATE_HOOKLIST, &source);
4347                 item->update_flags = 0;
4348         }
4349 }
4350
4351 void folder_item_update_thaw(void)
4352 {
4353         if (folder_item_update_freeze_cnt > 0)
4354                 folder_item_update_freeze_cnt--;
4355         if (folder_item_update_freeze_cnt == 0) {
4356                 /* Update all folders */
4357                 folder_func_to_all_folders(folder_item_update_func, NULL);
4358         }
4359 }
4360
4361 void folder_item_synchronise(FolderItem *item)
4362 {
4363         if (!item)
4364                 return;
4365         if (item->prefs->offlinesync && item->folder->klass->synchronise) {
4366                 statuswindow_print_all(_("Synchronising %s for offline use...\n"), item->path ? item->path : "(null)");
4367                 item->folder->klass->synchronise(item,
4368                         item->prefs->offlinesync_days);
4369                 if (item->prefs->offlinesync_days > 0 &&
4370                     item->prefs->remove_old_bodies)
4371                         folder_item_clean_local_files(item, item->prefs->offlinesync_days);
4372                 statuswindow_pop_all();
4373         }
4374 }
4375
4376 static void folder_item_synchronise_func(FolderItem *item, gpointer data)
4377 {
4378         Folder *folder = (Folder *)data;
4379         if (folder == NULL || item->folder == folder) {
4380                 folder_item_synchronise(item);
4381         }
4382 }
4383
4384 void folder_synchronise(Folder *folder)
4385 {
4386         folder_func_to_all_folders(folder_item_synchronise_func, folder);
4387 }
4388
4389 typedef struct _WantSyncData {
4390         Folder *folder;
4391         gboolean want_sync;
4392 } WantSyncData;
4393
4394 static void folder_item_want_synchronise_func(FolderItem *item, gpointer data)
4395 {
4396         WantSyncData *want_sync_data = (WantSyncData *)data;
4397
4398         if (want_sync_data->folder == NULL || item->folder == want_sync_data->folder) {
4399                 if (item->prefs->offlinesync && item->folder->klass->synchronise)
4400                         want_sync_data->want_sync |= TRUE;
4401         }
4402 }
4403
4404 gboolean folder_want_synchronise(Folder *folder)
4405 {
4406         WantSyncData *want_sync_data = g_new0(WantSyncData, 1);
4407         gboolean result;
4408         want_sync_data->folder = folder;
4409         want_sync_data->want_sync = FALSE;
4410
4411         folder_func_to_all_folders(folder_item_want_synchronise_func, want_sync_data);
4412         result = want_sync_data->want_sync;
4413         g_free(want_sync_data);
4414         if (result > 0)
4415                 debug_print("Folder %s wants sync\n", folder->name);
4416         return result;
4417 }
4418
4419 void folder_item_set_batch (FolderItem *item, gboolean batch)
4420 {
4421         if (!item || !item->folder)
4422                 return;
4423         if (item->folder->klass->set_batch) {
4424                 item->folder->klass->set_batch(item->folder, item, batch);
4425         }
4426 }
4427
4428 gboolean folder_has_parent_of_type(FolderItem *item,
4429                                           SpecialFolderItemType type)
4430 {
4431         FolderItem *cur = item;
4432
4433         /* if we already know it, make it short */
4434         if (item->parent_stype != -1) {
4435                 return (item->parent_stype == type);
4436         }
4437
4438         /* if we don't, find the type from the first possible parent,
4439          * and set our parent type to be faster next time */
4440         while (cur) {
4441                 if (cur->stype == type || cur->parent_stype == type) {
4442                         item->parent_stype = type;
4443                         return TRUE;
4444                 }
4445                 cur = folder_item_parent(cur);
4446         }
4447
4448         /* if we didn't match what was asked, we didn't return. If our
4449          * parent type is unknown, we may as well find it now to be faster
4450          * later. */
4451         if (item->parent_stype == -1) {
4452                 cur = item;
4453                 while (cur) {
4454                         /* here's an exception: Inbox subfolders are normal. */
4455                         if (item->parent_stype == -1 && cur->stype == F_INBOX
4456                         && item != cur) {
4457                                 item->parent_stype = F_NORMAL;
4458                                 break;
4459                         }
4460                         /* ah, we know this parent's parent's type, we may as
4461                          * well copy it instead of going up the full way */
4462                         if (cur->parent_stype != -1) {
4463                                 item->parent_stype = cur->parent_stype;
4464                                 break;
4465                         }
4466                         /* we found a parent that has a special type. That's
4467                          * our parent type. */
4468                         if (cur->stype != F_NORMAL) {
4469                                 cur->parent_stype = cur->stype;
4470                                 item->parent_stype = cur->stype;
4471                                 break;
4472                         }
4473                         /* if we didn't find anything, go up once more */
4474                         cur = folder_item_parent(cur);
4475                 }
4476                 /* as we still didn't find anything, our parents must all be
4477                  * normal. */
4478                 if (item->parent_stype == -1) {
4479                         item->parent_stype = F_NORMAL;
4480                 }
4481         }
4482         return FALSE;
4483 }
4484
4485 gboolean folder_subscribe (const gchar *uri)
4486 {
4487         GList *cur;
4488         for (cur = folder_get_list(); cur != NULL; cur = g_list_next(cur)) {
4489                 Folder *folder = (Folder *) cur->data;
4490
4491                 if (folder->klass->subscribe
4492                 &&  folder->klass->subscribe(folder, uri)) {
4493                         return TRUE;
4494                 }
4495         }
4496         return FALSE;
4497
4498 }
4499
4500 gboolean folder_get_sort_type           (Folder         *folder,
4501                                          FolderSortKey  *sort_key,
4502                                          FolderSortType *sort_type)
4503 {
4504         if (!folder || !sort_key || !sort_type)
4505                 return FALSE;
4506         if (folder->klass->get_sort_type == NULL)
4507                 return FALSE;
4508         folder->klass->get_sort_type(folder, sort_key, sort_type);
4509         return TRUE;
4510 }