src/folder.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2002 Hiroyuki Yamamoto
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #endif
  23
  24 #include "defs.h"
  25
  26 #include <glib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #include "intl.h"
  31 #include "folder.h"
  32 #include "folderview.h"
  33 #include "session.h"
  34 #include "imap.h"
  35 #include "news.h"
  36 #include "mh.h"
  37 #include "mbox_folder.h"
  38 #include "utils.h"
  39 #include "xml.h"
  40 #include "codeconv.h"
  41 #include "prefs.h"
  42 #include "account.h"
  43 #include "prefs_account.h"
  44 #include "prefs_folder_item.h"
  45
  46 static GList *folder_list = NULL;
  47
  48 static void folder_init         (Folder         *folder,
  49                                  const gchar    *name);
  50
  51 static gboolean folder_read_folder_func (GNode          *node,
  52                                          gpointer        data);
  53 static gchar *folder_get_list_path      (void);
  54 static void folder_write_list_recursive (GNode          *node,
  55                                          gpointer        data);
  56 static void folder_update_op_count_rec  (GNode          *node);
  57
  58
  59 static void folder_get_persist_prefs_recursive
  60                                         (GNode *node, GHashTable *pptable);
  61 static gboolean persist_prefs_free      (gpointer key, gpointer val, gpointer data);
  62
  63
  64 Folder *folder_new(FolderType type, const gchar *name, const gchar *path)
  65 {
  66         Folder *folder = NULL;
  67
  68         name = name ? name : path;
  69         switch (type) {
  70         case F_MBOX:
  71                 folder = mbox_folder_new(name, path);
  72                 break;
  73         case F_MH:
  74                 folder = mh_folder_new(name, path);
  75                 break;
  76         case F_IMAP:
  77                 folder = imap_folder_new(name, path);
  78                 break;
  79         case F_NEWS:
  80                 folder = news_folder_new(name, path);
  81                 break;
  82         default:
  83                 return NULL;
  84         }
  85
  86         return folder;
  87 }
  88
  89 static void folder_init(Folder *folder, const gchar *name)
  90 {
  91         FolderItem *item;
  92
  93         g_return_if_fail(folder != NULL);
  94
  95         folder_set_name(folder, name);
  96         folder->type = F_UNKNOWN;
  97         folder->account = NULL;
  98         folder->inbox = NULL;
  99         folder->outbox = NULL;
 100         folder->draft = NULL;
 101         folder->queue = NULL;
 102         folder->trash = NULL;
 103         folder->ui_func = NULL;
 104         folder->ui_func_data = NULL;
 105         item = folder_item_new(name, NULL);
 106         item->folder = folder;
 107         folder->node = g_node_new(item);
 108         folder->data = NULL;
 109 }
 110
 111 void folder_local_folder_init(Folder *folder, const gchar *name,
 112                               const gchar *path)
 113 {
 114         folder_init(folder, name);
 115         LOCAL_FOLDER(folder)->rootpath = g_strdup(path);
 116 }
 117
 118 void folder_remote_folder_init(Folder *folder, const gchar *name,
 119                                const gchar *path)
 120 {
 121         folder_init(folder, name);
 122         REMOTE_FOLDER(folder)->session = NULL;
 123 }
 124
 125 void folder_destroy(Folder *folder)
 126 {
 127         g_return_if_fail(folder != NULL);
 128
 129         switch (folder->type) {
 130         case F_MBOX:
 131                 mbox_folder_destroy(MBOX_FOLDER(folder));
 132         case F_MH:
 133                 mh_folder_destroy(MH_FOLDER(folder));
 134                 break;
 135         case F_IMAP:
 136                 imap_folder_destroy(IMAP_FOLDER(folder));
 137                 break;
 138         case F_NEWS:
 139                 news_folder_destroy(NEWS_FOLDER(folder));
 140                 break;
 141         default:
 142                 break;
 143         }
 144
 145         folder_list = g_list_remove(folder_list, folder);
 146
 147         folder_tree_destroy(folder);
 148         g_free(folder->name);
 149         g_free(folder);
 150 }
 151
 152 void folder_local_folder_destroy(LocalFolder *lfolder)
 153 {
 154         g_return_if_fail(lfolder != NULL);
 155
 156         g_free(lfolder->rootpath);
 157 }
 158
 159 void folder_remote_folder_destroy(RemoteFolder *rfolder)
 160 {
 161         g_return_if_fail(rfolder != NULL);
 162
 163         if (rfolder->session)
 164                 session_destroy(rfolder->session);
 165 }
 166
 167 #if 0
 168 Folder *mbox_folder_new(const gchar *name, const gchar *path)
 169 {
 170         /* not yet implemented */
 171         return NULL;
 172 }
 173
 174 Folder *maildir_folder_new(const gchar *name, const gchar *path)
 175 {
 176         /* not yet implemented */
 177         return NULL;
 178 }
 179 #endif
 180
 181 FolderItem *folder_item_new(const gchar *name, const gchar *path)
 182 {
 183         FolderItem *item;
 184
 185         item = g_new0(FolderItem, 1);
 186
 187         item->stype = F_NORMAL;
 188         item->name = g_strdup(name);
 189         item->path = g_strdup(path);
 190         item->account = NULL;
 191         item->mtime = 0;
 192         item->new = 0;
 193         item->unread = 0;
 194         item->total = 0;
 195         item->last_num = -1;
 196         item->no_sub = FALSE;
 197         item->no_select = FALSE;
 198         item->collapsed = FALSE;
 199         item->threaded  = TRUE;
 200         item->ret_rcpt  = FALSE;
 201         item->parent = NULL;
 202         item->folder = NULL;
 203         item->data = NULL;
 204
 205         item->prefs = prefs_folder_item_new();
 206
 207         return item;
 208 }
 209
 210 void folder_item_append(FolderItem *parent, FolderItem *item)
 211 {
 212         GNode *node;
 213
 214         g_return_if_fail(parent != NULL);
 215         g_return_if_fail(parent->folder != NULL);
 216         g_return_if_fail(item != NULL);
 217
 218         node = parent->folder->node;
 219         node = g_node_find(node, G_PRE_ORDER, G_TRAVERSE_ALL, parent);
 220         g_return_if_fail(node != NULL);
 221
 222         item->parent = parent;
 223         item->folder = parent->folder;
 224         g_node_append_data(node, item);
 225 }
 226
 227 void folder_item_remove(FolderItem *item)
 228 {
 229         GNode *node;
 230
 231         g_return_if_fail(item != NULL);
 232         g_return_if_fail(item->folder != NULL);
 233
 234         node = item->folder->node;
 235         node = g_node_find(node, G_PRE_ORDER, G_TRAVERSE_ALL, item);
 236         g_return_if_fail(node != NULL);
 237
 238         /* TODO: free all FolderItem's first */
 239         if (item->folder->node == node)
 240                 item->folder->node = NULL;
 241         g_node_destroy(node);
 242 }
 243
 244 void folder_item_destroy(FolderItem *item)
 245 {
 246         g_return_if_fail(item != NULL);
 247
 248         g_free(item->name);
 249         g_free(item->path);
 250         g_free(item);
 251 }
 252
 253 void folder_set_ui_func(Folder *folder, FolderUIFunc func, gpointer data)
 254 {
 255         g_return_if_fail(folder != NULL);
 256
 257         folder->ui_func = func;
 258         folder->ui_func_data = data;
 259 }
 260
 261 void folder_set_name(Folder *folder, const gchar *name)
 262 {
 263         g_return_if_fail(folder != NULL);
 264
 265         g_free(folder->name);
 266         folder->name = name ? g_strdup(name) : NULL;
 267         if (folder->node && folder->node->data) {
 268                 FolderItem *item = (FolderItem *)folder->node->data;
 269
 270                 g_free(item->name);
 271                 item->name = name ? g_strdup(name) : NULL;
 272         }
 273 }
 274
 275 void folder_tree_destroy(Folder *folder)
 276 {
 277         /* TODO: destroy all FolderItem before */
 278         g_node_destroy(folder->node);
 279
 280         folder->inbox = NULL;
 281         folder->outbox = NULL;
 282         folder->draft = NULL;
 283         folder->queue = NULL;
 284         folder->trash = NULL;
 285         folder->node = NULL;
 286 }
 287
 288 void folder_add(Folder *folder)
 289 {
 290         Folder *cur_folder;
 291         GList *cur;
 292         gint i;
 293
 294         g_return_if_fail(folder != NULL);
 295
 296         for (i = 0, cur = folder_list; cur != NULL; cur = cur->next, i++) {
 297                 cur_folder = FOLDER(cur->data);
 298                 if (folder->type == F_MH) {
 299                         if (cur_folder->type != F_MH) break;
 300                 } else if (folder->type == F_MBOX) {
 301                         if (cur_folder->type != F_MH &&
 302                             cur_folder->type != F_MBOX) break;
 303                 } else if (folder->type == F_IMAP) {
 304                         if (cur_folder->type != F_MH &&
 305                             cur_folder->type != F_MBOX &&
 306                             cur_folder->type != F_IMAP) break;
 307                 } else if (folder->type == F_NEWS) {
 308                         if (cur_folder->type != F_MH &&
 309                             cur_folder->type != F_MBOX &&
 310                             cur_folder->type != F_IMAP &&
 311                             cur_folder->type != F_NEWS) break;
 312                 }
 313         }
 314
 315         folder_list = g_list_insert(folder_list, folder, i);
 316 }
 317
 318 GList *folder_get_list(void)
 319 {
 320         return folder_list;
 321 }
 322
 323 gint folder_read_list(void)
 324 {
 325         GNode *node;
 326         XMLNode *xmlnode;
 327         gchar *path;
 328
 329         path = folder_get_list_path();
 330         if (!is_file_exist(path)) return -1;
 331         node = xml_parse_file(path);
 332         if (!node) return -1;
 333
 334         xmlnode = node->data;
 335         if (strcmp2(xmlnode->tag->tag, "folderlist") != 0) {
 336                 g_warning("wrong folder list\n");
 337                 xml_free_tree(node);
 338                 return -1;
 339         }
 340
 341         g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, 2,
 342                         folder_read_folder_func, NULL);
 343
 344         xml_free_tree(node);
 345         if (folder_list)
 346                 return 0;
 347         else
 348                 return -1;
 349 }
 350
 351 void folder_write_list(void)
 352 {
 353         GList *list;
 354         Folder *folder;
 355         gchar *path;
 356         PrefFile *pfile;
 357
 358         path = folder_get_list_path();
 359         if ((pfile = prefs_write_open(path)) == NULL) return;
 360
 361         fprintf(pfile->fp, "<?xml version=\"1.0\" encoding=\"%s\"?>\n",
 362                 conv_get_current_charset_str());
 363         fputs("\n<folderlist>\n", pfile->fp);
 364
 365         for (list = folder_list; list != NULL; list = list->next) {
 366                 folder = list->data;
 367                 folder_write_list_recursive(folder->node, pfile->fp);
 368         }
 369
 370         fputs("</folderlist>\n", pfile->fp);
 371
 372         if (prefs_write_close(pfile) < 0)
 373                 g_warning("failed to write folder list.\n");
 374 }
 375
 376 struct TotalMsgCount
 377 {
 378         guint new;
 379         guint unread;
 380         guint total;
 381 };
 382
 383 static gboolean folder_count_total_msgs_func(GNode *node, gpointer data)
 384 {
 385         FolderItem *item;
 386         struct TotalMsgCount *count = (struct TotalMsgCount *)data;
 387
 388         g_return_val_if_fail(node->data != NULL, FALSE);
 389
 390         item = FOLDER_ITEM(node->data);
 391         count->new += item->new;
 392         count->unread += item->unread;
 393         count->total += item->total;
 394
 395         return FALSE;
 396 }
 397
 398 void folder_count_total_msgs(guint *new, guint *unread, guint *total)
 399 {
 400         GList *list;
 401         Folder *folder;
 402         struct TotalMsgCount count;
 403
 404         count.new = count.unread = count.total = 0;
 405
 406         debug_print(_("Counting total number of messages...\n"));
 407
 408         for (list = folder_list; list != NULL; list = list->next) {
 409                 folder = FOLDER(list->data);
 410                 if (folder->node)
 411                         g_node_traverse(folder->node, G_PRE_ORDER,
 412                                         G_TRAVERSE_ALL, -1,
 413                                         folder_count_total_msgs_func,
 414                                         &count);
 415         }
 416
 417         *new = count.new;
 418         *unread = count.unread;
 419         *total = count.total;
 420
 421         return;
 422 }
 423
 424 Folder *folder_find_from_path(const gchar *path)
 425 {
 426         GList *list;
 427         Folder *folder;
 428
 429         for (list = folder_list; list != NULL; list = list->next) {
 430                 folder = list->data;
 431                 if ((folder->type == F_MH || folder->type == F_MBOX) &&
 432                     !path_cmp(LOCAL_FOLDER(folder)->rootpath, path))
 433                         return folder;
 434         }
 435
 436         return NULL;
 437 }
 438
 439 static gboolean folder_item_find_func(GNode *node, gpointer data)
 440 {
 441         FolderItem *item = node->data;
 442         gpointer *d = data;
 443         const gchar *path = d[0];
 444
 445         if (path_cmp(path, item->path) != 0)
 446                 return FALSE;
 447
 448         d[1] = item;
 449
 450         return TRUE;
 451 }
 452
 453 FolderItem *folder_find_item_from_path(const gchar *path)
 454 {
 455         Folder *folder;
 456         gpointer d[2];
 457
 458         folder = folder_get_default_folder();
 459         g_return_val_if_fail(folder != NULL, NULL);
 460
 461         d[0] = (gpointer)path;
 462         d[1] = NULL;
 463         g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
 464                         folder_item_find_func, d);
 465         return d[1];
 466 }
 467
 468 Folder *folder_get_default_folder(void)
 469 {
 470         return folder_list ? FOLDER(folder_list->data) : NULL;
 471 }
 472
 473 FolderItem *folder_get_default_inbox(void)
 474 {
 475         Folder *folder;
 476
 477         if (!folder_list) return NULL;
 478         folder = FOLDER(folder_list->data);
 479         g_return_val_if_fail(folder != NULL, NULL);
 480         return folder->inbox;
 481 }
 482
 483 FolderItem *folder_get_default_outbox(void)
 484 {
 485         Folder *folder;
 486
 487         if (!folder_list) return NULL;
 488         folder = FOLDER(folder_list->data);
 489         g_return_val_if_fail(folder != NULL, NULL);
 490         return folder->outbox;
 491 }
 492
 493 FolderItem *folder_get_default_draft(void)
 494 {
 495         Folder *folder;
 496
 497         if (!folder_list) return NULL;
 498         folder = FOLDER(folder_list->data);
 499         g_return_val_if_fail(folder != NULL, NULL);
 500         return folder->draft;
 501 }
 502
 503 FolderItem *folder_get_default_queue(void)
 504 {
 505         Folder *folder;
 506
 507         if (!folder_list) return NULL;
 508         folder = FOLDER(folder_list->data);
 509         g_return_val_if_fail(folder != NULL, NULL);
 510         return folder->queue;
 511 }
 512
 513 FolderItem *folder_get_default_trash(void)
 514 {
 515         Folder *folder;
 516
 517         if (!folder_list) return NULL;
 518         folder = FOLDER(folder_list->data);
 519         g_return_val_if_fail(folder != NULL, NULL);
 520         return folder->trash;
 521 }
 522
 523 gchar *folder_item_get_path(FolderItem *item)
 524 {
 525         gchar *folder_path;
 526         gchar *path;
 527
 528         g_return_val_if_fail(item != NULL, NULL);
 529
 530         if (FOLDER_TYPE(item->folder) == F_MH)
 531                 folder_path = g_strdup(LOCAL_FOLDER(item->folder)->rootpath);
 532         else if (FOLDER_TYPE(item->folder) == F_MBOX) {
 533                 path = mbox_get_virtual_path(item);
 534                 if (path == NULL)
 535                         return NULL;
 536                 folder_path = g_strconcat(get_mbox_cache_dir(),
 537                                           G_DIR_SEPARATOR_S, path, NULL);
 538                 g_free(path);
 539
 540                 return folder_path;
 541         }
 542         else if (FOLDER_TYPE(item->folder) == F_IMAP) {
 543                 g_return_val_if_fail(item->folder->account != NULL, NULL);
 544                 folder_path = g_strconcat(get_imap_cache_dir(),
 545                                           G_DIR_SEPARATOR_S,
 546                                           item->folder->account->recv_server,
 547                                           G_DIR_SEPARATOR_S,
 548                                           item->folder->account->userid,
 549                                           NULL);
 550         } else if (FOLDER_TYPE(item->folder) == F_NEWS) {
 551                 g_return_val_if_fail(item->folder->account != NULL, NULL);
 552                 folder_path = g_strconcat(get_news_cache_dir(),
 553                                           G_DIR_SEPARATOR_S,
 554                                           item->folder->account->nntp_server,
 555                                           NULL);
 556         } else
 557                 return NULL;
 558
 559         g_return_val_if_fail(folder_path != NULL, NULL);
 560
 561         if (folder_path[0] == G_DIR_SEPARATOR) {
 562                 if (item->path)
 563                         path = g_strconcat(folder_path, G_DIR_SEPARATOR_S,
 564                                            item->path, NULL);
 565                 else
 566                         path = g_strdup(folder_path);
 567         } else {
 568                 if (item->path)
 569                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
 570                                            folder_path, G_DIR_SEPARATOR_S,
 571                                            item->path, NULL);
 572                 else
 573                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
 574                                            folder_path, NULL);
 575         }
 576
 577         g_free(folder_path);
 578         return path;
 579 }
 580
 581 void folder_item_scan(FolderItem *item)
 582 {
 583         Folder *folder;
 584
 585         g_return_if_fail(item != NULL);
 586
 587         folder = item->folder;
 588
 589         g_return_if_fail(folder->scan != NULL);
 590
 591         folder->scan(folder, item);
 592 }
 593
 594 static void folder_item_scan_foreach_func(gpointer key, gpointer val,
 595                                           gpointer data)
 596 {
 597         folder_item_scan(FOLDER_ITEM(key));
 598 }
 599
 600 void folder_item_scan_foreach(GHashTable *table)
 601 {
 602         g_hash_table_foreach(table, folder_item_scan_foreach_func, NULL);
 603 }
 604
 605 gchar *folder_item_fetch_msg(FolderItem *item, gint num)
 606 {
 607         Folder *folder;
 608
 609         g_return_val_if_fail(item != NULL, NULL);
 610
 611         folder = item->folder;
 612
 613         g_return_val_if_fail(folder->scan != NULL, NULL);
 614         g_return_val_if_fail(folder->fetch_msg != NULL, NULL);
 615
 616         if (item->last_num < 0) folder->scan(folder, item);
 617
 618         return folder->fetch_msg(folder, item, num);
 619 }
 620
 621 gint folder_item_add_msg(FolderItem *dest, const gchar *file,
 622                          gboolean remove_source)
 623 {
 624         Folder *folder;
 625         gint num;
 626
 627         g_return_val_if_fail(dest != NULL, -1);
 628         g_return_val_if_fail(file != NULL, -1);
 629
 630         folder = dest->folder;
 631
 632         g_return_val_if_fail(folder->scan != NULL, -1);
 633         g_return_val_if_fail(folder->add_msg != NULL, -1);
 634
 635         if (dest->last_num < 0) folder->scan(folder, dest);
 636
 637         num = folder->add_msg(folder, dest, file, remove_source);
 638         if (num > 0) dest->last_num = num;
 639
 640         return num;
 641 }
 642
 643 /*
 644 gint folder_item_move_msg(FolderItem *dest, MsgInfo *msginfo)
 645 {
 646         Folder *folder;
 647         gint num;
 648
 649         g_return_val_if_fail(dest != NULL, -1);
 650         g_return_val_if_fail(msginfo != NULL, -1);
 651
 652         folder = dest->folder;
 653         if (dest->last_num < 0) folder->scan(folder, dest);
 654
 655         num = folder->move_msg(folder, dest, msginfo);
 656         if (num > 0) dest->last_num = num;
 657
 658         return num;
 659 }
 660 */
 661
 662 gint folder_item_move_msg(FolderItem *dest, MsgInfo *msginfo)
 663 {
 664         Folder *folder;
 665         gint num;
 666         gchar * filename;
 667         Folder * src_folder;
 668
 669         g_return_val_if_fail(dest != NULL, -1);
 670         g_return_val_if_fail(msginfo != NULL, -1);
 671
 672         folder = dest->folder;
 673
 674         g_return_val_if_fail(folder->scan != NULL, -1);
 675         g_return_val_if_fail(folder->remove_msg != NULL, -1);
 676         g_return_val_if_fail(folder->copy_msg != NULL, -1);
 677
 678         if (dest->last_num < 0) folder->scan(folder, dest);
 679
 680         src_folder = msginfo->folder->folder;
 681
 682         num = folder->copy_msg(folder, dest, msginfo);
 683
 684         if (num != -1) {
 685                 /* CLAWS */
 686                 g_assert(src_folder);
 687                 g_assert(src_folder->remove_msg);
 688                 src_folder->remove_msg(src_folder,
 689                                        msginfo->folder,
 690                                        msginfo->msgnum);
 691         }
 692
 693         if (folder->finished_copy)
 694                 folder->finished_copy(folder, dest);
 695
 696         src_folder = msginfo->folder->folder;
 697
 698         if (msginfo->folder && src_folder->scan)
 699                 src_folder->scan(src_folder, msginfo->folder);
 700         folder->scan(folder, dest);
 701
 702         return num;
 703 }
 704
 705 /*
 706 gint folder_item_move_msgs_with_dest(FolderItem *dest, GSList *msglist)
 707 {
 708         Folder *folder;
 709         gint num;
 710
 711         g_return_val_if_fail(dest != NULL, -1);
 712         g_return_val_if_fail(msglist != NULL, -1);
 713
 714         folder = dest->folder;
 715         if (dest->last_num < 0) folder->scan(folder, dest);
 716
 717         num = folder->move_msgs_with_dest(folder, dest, msglist);
 718         if (num > 0) dest->last_num = num;
 719         else dest->op_count = 0;
 720
 721         return num;
 722 }
 723 */
 724
 725 gint folder_item_move_msgs_with_dest(FolderItem *dest, GSList *msglist)
 726 {
 727         Folder *folder;
 728         FolderItem * item;
 729         GSList * l;
 730         gchar * filename;
 731
 732         g_return_val_if_fail(dest != NULL, -1);
 733         g_return_val_if_fail(msglist != NULL, -1);
 734
 735         folder = dest->folder;
 736
 737         g_return_val_if_fail(folder->scan != NULL, -1);
 738         g_return_val_if_fail(folder->copy_msg != NULL, -1);
 739         g_return_val_if_fail(folder->remove_msg != NULL, -1);
 740
 741         if (dest->last_num < 0) folder->scan(folder, dest);
 742
 743         item = NULL;
 744         for(l = msglist ; l != NULL ; l = g_slist_next(l)) {
 745                 MsgInfo * msginfo = (MsgInfo *) l->data;
 746
 747                 if (!item && msginfo->folder != NULL)
 748                         item = msginfo->folder;
 749
 750                 if (folder->copy_msg(folder, dest, msginfo) != -1)
 751                         item->folder->remove_msg(item->folder,
 752                                                  msginfo->folder,
 753                                                  msginfo->msgnum);
 754         }
 755
 756         if (folder->finished_copy)
 757                 folder->finished_copy(folder, dest);
 758
 759         if (item && item->folder->scan)
 760                 item->folder->scan(item->folder, item);
 761         folder->scan(folder, dest);
 762
 763         return dest->last_num;
 764 }
 765
 766 /*
 767 gint folder_item_copy_msg(FolderItem *dest, MsgInfo *msginfo)
 768 {
 769         Folder *folder;
 770         gint num;
 771
 772         g_return_val_if_fail(dest != NULL, -1);
 773         g_return_val_if_fail(msginfo != NULL, -1);
 774
 775         folder = dest->folder;
 776         if (dest->last_num < 0) folder->scan(folder, dest);
 777
 778         num = folder->copy_msg(folder, dest, msginfo);
 779         if (num > 0) dest->last_num = num;
 780
 781         return num;
 782 }
 783 */
 784
 785 gint folder_item_copy_msg(FolderItem *dest, MsgInfo *msginfo)
 786 {
 787         Folder *folder;
 788         gint num;
 789         gchar * filename;
 790         Folder * src_folder;
 791
 792         g_return_val_if_fail(dest != NULL, -1);
 793         g_return_val_if_fail(msginfo != NULL, -1);
 794
 795         folder = dest->folder;
 796
 797         g_return_val_if_fail(folder->scan != NULL, -1);
 798         g_return_val_if_fail(folder->copy_msg != NULL, -1);
 799
 800         if (dest->last_num < 0) folder->scan(folder, dest);
 801
 802         num = folder->copy_msg(folder, dest, msginfo);
 803
 804         if (folder->finished_copy)
 805                 folder->finished_copy(folder, dest);
 806
 807         folder->scan(folder, dest);
 808
 809         return num;
 810 }
 811
 812 /*
 813 gint folder_item_copy_msgs_with_dest(FolderItem *dest, GSList *msglist)
 814 {
 815         Folder *folder;
 816         gint num;
 817
 818         g_return_val_if_fail(dest != NULL, -1);
 819         g_return_val_if_fail(msglist != NULL, -1);
 820
 821         folder = dest->folder;
 822         if (dest->last_num < 0) folder->scan(folder, dest);
 823
 824         num = folder->copy_msgs_with_dest(folder, dest, msglist);
 825         if (num > 0) dest->last_num = num;
 826         else dest->op_count = 0;
 827
 828         return num;
 829 }
 830 */
 831
 832 gint folder_item_copy_msgs_with_dest(FolderItem *dest, GSList *msglist)
 833 {
 834         Folder *folder;
 835         gint num;
 836         GSList * l;
 837         gchar * filename;
 838
 839         g_return_val_if_fail(dest != NULL, -1);
 840         g_return_val_if_fail(msglist != NULL, -1);
 841
 842         folder = dest->folder;
 843
 844         g_return_val_if_fail(folder->scan != NULL, -1);
 845         g_return_val_if_fail(folder->copy_msg != NULL, -1);
 846
 847         if (dest->last_num < 0) folder->scan(folder, dest);
 848
 849         for(l = msglist ; l != NULL ; l = g_slist_next(l)) {
 850                 MsgInfo * msginfo = (MsgInfo *) l->data;
 851
 852                 folder->copy_msg(folder, dest, msginfo);
 853         }
 854
 855         if (folder->finished_copy)
 856                 folder->finished_copy(folder, dest);
 857
 858         folder->scan(folder, dest);
 859
 860         return dest->last_num;
 861 }
 862
 863 gint folder_item_remove_msg(FolderItem *item, gint num)
 864 {
 865         Folder *folder;
 866         gint ret;
 867
 868         g_return_val_if_fail(item != NULL, -1);
 869
 870         folder = item->folder;
 871         if (item->last_num < 0) folder->scan(folder, item);
 872
 873         ret = folder->remove_msg(folder, item, num);
 874         if (ret == 0 && num == item->last_num)
 875                 folder->scan(folder, item);
 876
 877         return ret;
 878 }
 879
 880 gint folder_item_remove_msgs(FolderItem *item, GSList *msglist)
 881 {
 882         gint ret = 0;
 883
 884         g_return_val_if_fail(item != NULL, -1);
 885
 886         while (msglist != NULL) {
 887                 MsgInfo *msginfo = (MsgInfo *)msglist->data;
 888
 889                 ret = folder_item_remove_msg(item, msginfo->msgnum);
 890                 if (ret != 0) break;
 891                 msglist = msglist->next;
 892         }
 893
 894         return ret;
 895 }
 896
 897 gint folder_item_remove_all_msg(FolderItem *item)
 898 {
 899         Folder *folder;
 900         gint result;
 901
 902         g_return_val_if_fail(item != NULL, -1);
 903
 904         folder = item->folder;
 905
 906         g_return_val_if_fail(folder->scan != NULL, -1);
 907         g_return_val_if_fail(folder->remove_all_msg != NULL, -1);
 908
 909         if (item->last_num < 0) folder->scan(folder, item);
 910
 911         result = folder->remove_all_msg(folder, item);
 912
 913         if (result == 0){
 914                 if (folder->finished_remove)
 915                         folder->finished_remove(folder, item);
 916         }
 917
 918         return result;
 919 }
 920
 921 gboolean folder_item_is_msg_changed(FolderItem *item, MsgInfo *msginfo)
 922 {
 923         Folder *folder;
 924
 925         g_return_val_if_fail(item != NULL, FALSE);
 926
 927         folder = item->folder;
 928
 929         g_return_val_if_fail(folder->is_msg_changed != NULL, -1);
 930
 931         return folder->is_msg_changed(folder, item, msginfo);
 932 }
 933
 934 gchar *folder_item_get_cache_file(FolderItem *item)
 935 {
 936         gchar *path;
 937         gchar *file;
 938
 939         g_return_val_if_fail(item != NULL, NULL);
 940         g_return_val_if_fail(item->path != NULL, NULL);
 941
 942         path = folder_item_get_path(item);
 943         g_return_val_if_fail(path != NULL, NULL);
 944         if (!is_dir_exist(path))
 945                 make_dir_hier(path);
 946         file = g_strconcat(path, G_DIR_SEPARATOR_S, CACHE_FILE, NULL);
 947         g_free(path);
 948
 949         return file;
 950 }
 951
 952 gchar *folder_item_get_mark_file(FolderItem *item)
 953 {
 954         gchar *path;
 955         gchar *file;
 956
 957         g_return_val_if_fail(item != NULL, NULL);
 958         g_return_val_if_fail(item->path != NULL, NULL);
 959
 960         path = folder_item_get_path(item);
 961         g_return_val_if_fail(path != NULL, NULL);
 962         if (!is_dir_exist(path))
 963                 make_dir_hier(path);
 964         file = g_strconcat(path, G_DIR_SEPARATOR_S, MARK_FILE, NULL);
 965         g_free(path);
 966
 967         return file;
 968 }
 969
 970 static gboolean folder_build_tree(GNode *node, gpointer data)
 971 {
 972         Folder *folder = FOLDER(data);
 973         FolderItem *item;
 974         XMLNode *xmlnode;
 975         GList *list;
 976         SpecialFolderItemType stype = F_NORMAL;
 977         const gchar *name = NULL;
 978         const gchar *path = NULL;
 979         PrefsAccount *account = NULL;
 980         gboolean no_sub = FALSE, no_select = FALSE, collapsed = FALSE,
 981                  threaded = TRUE, ret_rcpt = FALSE, hidereadmsgs = FALSE;
 982         gint mtime = 0, new = 0, unread = 0, total = 0;
 983
 984         g_return_val_if_fail(node->data != NULL, FALSE);
 985         if (!node->parent) return FALSE;
 986
 987         xmlnode = node->data;
 988         if (strcmp2(xmlnode->tag->tag, "folderitem") != 0) {
 989                 g_warning("tag name != \"folderitem\"\n");
 990                 return FALSE;
 991         }
 992
 993         list = xmlnode->tag->attr;
 994         for (; list != NULL; list = list->next) {
 995                 XMLAttr *attr = list->data;
 996
 997                 if (!attr || !attr->name || !attr->value) continue;
 998                 if (!strcmp(attr->name, "type")) {
 999                         if (!strcasecmp(attr->value, "normal"))
1000                                 stype = F_NORMAL;
1001                         else if (!strcasecmp(attr->value, "inbox"))
1002                                 stype = F_INBOX;
1003                         else if (!strcasecmp(attr->value, "outbox"))
1004                                 stype = F_OUTBOX;
1005                         else if (!strcasecmp(attr->value, "draft"))
1006                                 stype = F_DRAFT;
1007                         else if (!strcasecmp(attr->value, "queue"))
1008                                 stype = F_QUEUE;
1009                         else if (!strcasecmp(attr->value, "trash"))
1010                                 stype = F_TRASH;
1011                 } else if (!strcmp(attr->name, "name"))
1012                         name = attr->value;
1013                 else if (!strcmp(attr->name, "path"))
1014                         path = attr->value;
1015                 else if (!strcmp(attr->name, "account_id")) {
1016                         account = account_find_from_id(atoi(attr->value));
1017                         if (!account) g_warning("account_id: %s not found\n",
1018                                                 attr->value);
1019                 } else if (!strcmp(attr->name, "mtime"))
1020                         mtime = atoi(attr->value);
1021                 else if (!strcmp(attr->name, "new"))
1022                         new = atoi(attr->value);
1023                 else if (!strcmp(attr->name, "unread"))
1024                         unread = atoi(attr->value);
1025                 else if (!strcmp(attr->name, "total"))
1026                         total = atoi(attr->value);
1027                 else if (!strcmp(attr->name, "no_sub"))
1028                         no_sub = *attr->value == '1' ? TRUE : FALSE;
1029                 else if (!strcmp(attr->name, "no_select"))
1030                         no_select = *attr->value == '1' ? TRUE : FALSE;
1031                 else if (!strcmp(attr->name, "collapsed"))
1032                         collapsed = *attr->value == '1' ? TRUE : FALSE;
1033                 else if (!strcmp(attr->name, "threaded"))
1034                         threaded =  *attr->value == '1' ? TRUE : FALSE;
1035                 else if (!strcmp(attr->name, "hidereadmsgs"))
1036                         hidereadmsgs =  *attr->value == '1' ? TRUE : FALSE;
1037                 else if (!strcmp(attr->name, "reqretrcpt"))
1038                         ret_rcpt =  *attr->value == '1' ? TRUE : FALSE;
1039         }
1040
1041         item = folder_item_new(name, path);
1042         item->stype = stype;
1043         item->account = account;
1044         item->mtime = mtime;
1045         item->new = new;
1046         item->unread = unread;
1047         item->total = total;
1048         item->no_sub = no_sub;
1049         item->no_select = no_select;
1050         item->collapsed = collapsed;
1051         item->threaded  = threaded;
1052         item->hide_read_msgs  = hidereadmsgs;
1053         item->ret_rcpt  = ret_rcpt;
1054         item->parent = FOLDER_ITEM(node->parent->data);
1055         item->folder = folder;
1056         switch (stype) {
1057         case F_INBOX:  folder->inbox  = item; break;
1058         case F_OUTBOX: folder->outbox = item; break;
1059         case F_DRAFT:  folder->draft  = item; break;
1060         case F_QUEUE:  folder->queue  = item; break;
1061         case F_TRASH:  folder->trash  = item; break;
1062         default:       break;
1063         }
1064
1065         prefs_folder_item_read_config(item);
1066
1067         node->data = item;
1068         xml_free_node(xmlnode);
1069
1070         return FALSE;
1071 }
1072
1073 static gboolean folder_read_folder_func(GNode *node, gpointer data)
1074 {
1075         Folder *folder;
1076         XMLNode *xmlnode;
1077         GList *list;
1078         FolderType type = F_UNKNOWN;
1079         const gchar *name = NULL;
1080         const gchar *path = NULL;
1081         PrefsAccount *account = NULL;
1082         gboolean collapsed = FALSE, threaded = TRUE, ret_rcpt = FALSE;
1083
1084         if (g_node_depth(node) != 2) return FALSE;
1085         g_return_val_if_fail(node->data != NULL, FALSE);
1086
1087         xmlnode = node->data;
1088         if (strcmp2(xmlnode->tag->tag, "folder") != 0) {
1089                 g_warning("tag name != \"folder\"\n");
1090                 return TRUE;
1091         }
1092         g_node_unlink(node);
1093         list = xmlnode->tag->attr;
1094         for (; list != NULL; list = list->next) {
1095                 XMLAttr *attr = list->data;
1096
1097                 if (!attr || !attr->name || !attr->value) continue;
1098                 if (!strcmp(attr->name, "type")) {
1099                         if (!strcasecmp(attr->value, "mh"))
1100                                 type = F_MH;
1101                         else if (!strcasecmp(attr->value, "mbox"))
1102                                 type = F_MBOX;
1103                         else if (!strcasecmp(attr->value, "maildir"))
1104                                 type = F_MAILDIR;
1105                         else if (!strcasecmp(attr->value, "imap"))
1106                                 type = F_IMAP;
1107                         else if (!strcasecmp(attr->value, "news"))
1108                                 type = F_NEWS;
1109                 } else if (!strcmp(attr->name, "name"))
1110                         name = attr->value;
1111                 else if (!strcmp(attr->name, "path"))
1112                         path = attr->value;
1113                 else if (!strcmp(attr->name, "account_id")) {
1114                         account = account_find_from_id(atoi(attr->value));
1115                         if (!account) g_warning("account_id: %s not found\n",
1116                                                 attr->value);
1117                 } else if (!strcmp(attr->name, "collapsed"))
1118                         collapsed = *attr->value == '1' ? TRUE : FALSE;
1119                 else if (!strcmp(attr->name, "threaded"))
1120                         threaded = *attr->value == '1' ? TRUE : FALSE;
1121                 else if (!strcmp(attr->name, "reqretrcpt"))
1122                         ret_rcpt = *attr->value == '1' ? TRUE : FALSE;
1123         }
1124
1125         folder = folder_new(type, name, path);
1126         g_return_val_if_fail(folder != NULL, FALSE);
1127         folder->account = account;
1128         if (account && (type == F_IMAP || type == F_NEWS))
1129                 account->folder = REMOTE_FOLDER(folder);
1130         node->data = folder->node->data;
1131         g_node_destroy(folder->node);
1132         folder->node = node;
1133         folder_add(folder);
1134         FOLDER_ITEM(node->data)->collapsed = collapsed;
1135         FOLDER_ITEM(node->data)->threaded  = threaded;
1136         FOLDER_ITEM(node->data)->ret_rcpt  = ret_rcpt;
1137
1138         g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1139                         folder_build_tree, folder);
1140
1141         return FALSE;
1142 }
1143
1144 static gchar *folder_get_list_path(void)
1145 {
1146         static gchar *filename = NULL;
1147
1148         if (!filename)
1149                 filename =  g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1150                                         FOLDER_LIST, NULL);
1151
1152         return filename;
1153 }
1154
1155 static void folder_write_list_recursive(GNode *node, gpointer data)
1156 {
1157         FILE *fp = (FILE *)data;
1158         FolderItem *item = FOLDER_ITEM(node->data);
1159         gint i, depth;
1160         static gchar *folder_type_str[] = {"mh", "mbox", "maildir", "imap",
1161                                            "news", "unknown"};
1162         static gchar *folder_item_stype_str[] = {"normal", "inbox", "outbox",
1163                                                  "draft", "queue", "trash"};
1164
1165         g_return_if_fail(item != NULL);
1166
1167         depth = g_node_depth(node);
1168         for (i = 0; i < depth; i++)
1169                 fputs("    ", fp);
1170         if (depth == 1) {
1171                 Folder *folder = item->folder;
1172
1173                 fprintf(fp, "<folder type=\"%s\"", folder_type_str[folder->type]);
1174                 if (folder->name) {
1175                         fputs(" name=\"", fp);
1176                         xml_file_put_escape_str(fp, folder->name);
1177                         fputs("\"", fp);
1178                 }
1179                 if ((folder->type == F_MH) || (folder->type == F_MBOX)) {
1180                         fputs(" path=\"", fp);
1181                         xml_file_put_escape_str
1182                                 (fp, LOCAL_FOLDER(folder)->rootpath);
1183                         fputs("\"", fp);
1184                 }
1185                 if (folder->account)
1186                         fprintf(fp, " account_id=\"%d\"",
1187                                 folder->account->account_id);
1188                 if (item->collapsed && node->children)
1189                         fputs(" collapsed=\"1\"", fp);
1190                 if (item->ret_rcpt)
1191                         fputs(" reqretrcpt=\"1\"", fp);
1192         } else {
1193                 fprintf(fp, "<folderitem type=\"%s\"",
1194                         folder_item_stype_str[item->stype]);
1195                 if (item->name) {
1196                         fputs(" name=\"", fp);
1197                         xml_file_put_escape_str(fp, item->name);
1198                         fputs("\"", fp);
1199                 }
1200                 if (item->path) {
1201                         fputs(" path=\"", fp);
1202                         xml_file_put_escape_str(fp, item->path);
1203                         fputs("\"", fp);
1204                 }
1205                 if (item->account)
1206                         fprintf(fp, " account_id=\"%d\"",
1207                                 item->account->account_id);
1208                 if (item->no_sub)
1209                         fputs(" no_sub=\"1\"", fp);
1210                 if (item->no_select)
1211                         fputs(" no_select=\"1\"", fp);
1212                 if (item->collapsed && node->children)
1213                         fputs(" collapsed=\"1\"", fp);
1214                 if (item->threaded)
1215                         fputs(" threaded=\"1\"", fp);
1216                 else
1217                         fputs(" threaded=\"0\"", fp);
1218                 if (item->hide_read_msgs)
1219                         fputs(" hidereadmsgs=\"1\"", fp);
1220                 else
1221                         fputs(" hidereadmsgs=\"0\"", fp);
1222                 if (item->ret_rcpt)
1223                         fputs(" reqretrcpt=\"1\"", fp);
1224                 fprintf(fp,
1225                         " mtime=\"%lu\" new=\"%d\" unread=\"%d\" total=\"%d\"",
1226                         item->mtime, item->new, item->unread, item->total);
1227         }
1228
1229         if (node->children) {
1230                 GNode *child;
1231                 fputs(">\n", fp);
1232
1233                 child = node->children;
1234                 while (child) {
1235                         GNode *cur;
1236
1237                         cur = child;
1238                         child = cur->next;
1239                         folder_write_list_recursive(cur, data);
1240                 }
1241
1242                 for (i = 0; i < depth; i++)
1243                         fputs("    ", fp);
1244                 fprintf(fp, "</%s>\n", depth == 1 ? "folder" : "folderitem");
1245         } else
1246                 fputs(" />\n", fp);
1247 }
1248
1249 static void folder_update_op_count_rec(GNode *node) {
1250         FolderItem *fitem = FOLDER_ITEM(node->data);
1251
1252         if (g_node_depth(node) > 0) {
1253                 if (fitem->op_count > 0) {
1254                         fitem->op_count = 0;
1255                         folderview_update_item(fitem, 0);
1256                 }
1257                 if (node->children) {
1258                         GNode *child;
1259
1260                         child = node->children;
1261                         while (child) {
1262                                 GNode *cur;
1263
1264                                 cur = child;
1265                                 child = cur->next;
1266                                 folder_update_op_count_rec(cur);
1267                         }
1268                 }
1269         }
1270 }
1271
1272 void folder_update_op_count() {
1273         GList *cur;
1274         Folder *folder;
1275
1276         for (cur = folder_list; cur != NULL; cur = cur->next) {
1277                 folder = cur->data;
1278                 folder_update_op_count_rec(folder->node);
1279         }
1280 }
1281
1282 typedef struct _type_str {
1283         gchar * str;
1284         gint type;
1285 } type_str;
1286
1287
1288 static type_str type_str_table[] =
1289 {
1290         {"#mh", F_MH},
1291         {"#mbox", F_MBOX},
1292         {"#maildir", F_MAILDIR},
1293         {"#imap", F_IMAP},
1294         {"#news", F_NEWS}
1295 };
1296
1297
1298 static gchar * folder_get_type_string(gint type)
1299 {
1300         gint i;
1301
1302         for(i = 0 ; i < sizeof(type_str_table) / sizeof(type_str) ; i++) {
1303                 if (type_str_table[i].type == type)
1304                         return type_str_table[i].str;
1305         }
1306         return NULL;
1307 }
1308
1309 static gint folder_get_type_from_string(gchar * str)
1310 {
1311         gint i;
1312
1313         for(i = 0 ; i < sizeof(type_str_table) / sizeof(type_str) ; i++) {
1314                 if (g_strcasecmp(type_str_table[i].str, str))
1315                         return type_str_table[i].type;
1316         }
1317         return F_UNKNOWN;
1318 }
1319
1320 gchar * folder_get_identifier(Folder * folder)
1321 {
1322         gchar * type_str;
1323         type_str = folder_get_type_string(folder->type);
1324
1325         return g_strconcat(type_str, "/", folder->name, NULL);
1326 }
1327
1328 /*
1329 static gchar * folder_item_get_tree_identifier(FolderItem * item)
1330 {
1331         if (item->parent != NULL) {
1332                 gchar * path;
1333                 gchar * id;
1334
1335                 path = folder_item_get_tree_identifier(item->parent);
1336                 if (path == NULL)
1337                         return NULL;
1338
1339                 id = g_strconcat(path, "/", item->name, NULL);
1340                 g_free(path);
1341
1342                 return id;
1343         }
1344         else {
1345                 return g_strconcat("/", item->name, NULL);
1346         }
1347 }
1348 */
1349
1350 gchar * folder_item_get_identifier(FolderItem * item)
1351 {
1352         gchar * id;
1353         gchar * folder_str;
1354
1355         g_return_val_if_fail(item->path != NULL, NULL);
1356
1357         folder_str = folder_get_identifier(item->folder);
1358         id = g_strconcat(folder_str, "/", item->path, NULL);
1359         g_free(folder_str);
1360
1361         return id;
1362 }
1363
1364 Folder * folder_find_from_name(const gchar * name)
1365 {
1366         GList *list;
1367         Folder *folder;
1368
1369         for (list = g_list_first(folder_list); list != NULL;
1370              list = list->next) {
1371                 folder = list->data;
1372                 if (strcmp(name, folder->name) == 0)
1373                         return folder;
1374         }
1375         return NULL;
1376 }
1377
1378 FolderItem * folder_find_item_from_identifier(const gchar *identifier)
1379 {
1380         Folder *folder;
1381         gpointer d[2];
1382         gchar * str;
1383         gchar * p;
1384         gint type;
1385         gchar * name;
1386         gchar * path;
1387
1388         Xstrdup_a(str, identifier, return NULL);
1389
1390         /* extract box type */
1391
1392         p = strchr(str, '/');
1393
1394         if (p == NULL)
1395                 return NULL;
1396
1397         *p = '\0';
1398
1399         type = folder_get_type_from_string(str);
1400
1401         str = p + 1;
1402
1403         /* extract box name */
1404
1405         p = strchr(str, '/');
1406
1407         if (p == NULL)
1408                 return NULL;
1409
1410         *p = '\0';
1411
1412         name = str;
1413
1414         folder = folder_find_from_name(name);
1415         if (folder == NULL)
1416                 return;
1417
1418         path = p + 1;
1419
1420         d[0] = (gpointer)path;
1421         d[1] = NULL;
1422         g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1423                         folder_item_find_func, d);
1424         return d[1];
1425 }
1426
1427 /* CLAWS: temporary local folder for filtering */
1428
1429 static Folder *processing_folder;
1430 static FolderItem *processing_folder_item;
1431
1432 static void folder_create_processing_folder(void)
1433 {
1434 #define PROCESSING_FOLDER ".processing"
1435         Folder     *tmpparent;
1436         FolderItem *tmpfolder;
1437         gchar      *tmpname;
1438
1439         tmpparent = folder_get_default_folder();
1440         g_assert(tmpparent);
1441         debug_print("tmpparentroot %s\n", LOCAL_FOLDER(tmpparent)->rootpath);
1442         if (LOCAL_FOLDER(tmpparent)->rootpath[0] == '/')
1443                 tmpname = g_strconcat(LOCAL_FOLDER(tmpparent)->rootpath,
1444                                       G_DIR_SEPARATOR_S, PROCESSING_FOLDER,
1445                                       NULL);
1446         else
1447                 tmpname = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
1448                                       LOCAL_FOLDER(tmpparent)->rootpath,
1449                                       G_DIR_SEPARATOR_S, PROCESSING_FOLDER,
1450                                       NULL);
1451
1452         processing_folder = folder_new(F_MH, "PROCESSING", LOCAL_FOLDER(tmpparent)->rootpath);
1453         g_assert(processing_folder);
1454
1455         if (!is_dir_exist(tmpname)) {
1456                 debug_print("*TMP* creating %s\n", tmpname);
1457                 processing_folder_item = processing_folder->create_folder(processing_folder,
1458                                                                           processing_folder->node->data,
1459                                                                           PROCESSING_FOLDER);
1460                 g_assert(processing_folder_item);
1461         }
1462         else {
1463                 debug_print("*TMP* already created\n");
1464                 processing_folder_item = folder_item_new(".processing", ".processing");
1465                 g_assert(processing_folder_item);
1466                 folder_item_append(processing_folder->node->data, processing_folder_item);
1467         }
1468         g_free(tmpname);
1469 }
1470
1471 FolderItem *folder_get_default_processing(void)
1472 {
1473         if (!processing_folder_item) {
1474                 folder_create_processing_folder();
1475         }
1476         return processing_folder_item;
1477 }
1478
1479 /* folder_persist_prefs_new() - return hash table with persistent
1480  * settings (and folder name as key).
1481  * (note that in claws other options are in the PREFS_FOLDER_ITEM_RC
1482  * file, so those don't need to be included in PersistPref yet)
1483  */
1484 GHashTable *folder_persist_prefs_new(Folder *folder)
1485 {
1486         GHashTable *pptable;
1487
1488         g_return_val_if_fail(folder, NULL);
1489         pptable = g_hash_table_new(g_str_hash, g_str_equal);
1490         folder_get_persist_prefs_recursive(folder->node, pptable);
1491         return pptable;
1492 }
1493
1494 void folder_persist_prefs_free(GHashTable *pptable)
1495 {
1496         g_return_if_fail(pptable);
1497         g_hash_table_foreach_remove(pptable, persist_prefs_free, NULL);
1498         g_hash_table_destroy(pptable);
1499 }
1500
1501 const PersistPrefs *folder_get_persist_prefs(GHashTable *pptable, const char *name)
1502 {
1503         if (pptable == NULL || name == NULL) return NULL;
1504         return g_hash_table_lookup(pptable, name);
1505 }
1506
1507 void folder_item_restore_persist_prefs(FolderItem *item, GHashTable *pptable)
1508 {
1509         const PersistPrefs *pp;
1510
1511         pp = folder_get_persist_prefs(pptable, item->path);
1512         if (!pp) return;
1513
1514         /* CLAWS: since not all folder properties have been migrated to
1515          * folderlist.xml, we need to call the old stuff first before
1516          * setting things that apply both to Main and Claws. */
1517         prefs_folder_item_read_config(item);
1518
1519         item->collapsed = pp->collapsed;
1520         item->threaded  = pp->threaded;
1521         item->ret_rcpt  = pp->ret_rcpt;
1522         item->hide_read_msgs = pp->hide_read_msgs;
1523 }
1524
1525 static void folder_get_persist_prefs_recursive(GNode *node, GHashTable *pptable)
1526 {
1527         FolderItem *item = FOLDER_ITEM(node->data);
1528         PersistPrefs *pp;
1529         GNode *child, *cur;
1530
1531         g_return_if_fail(node != NULL);
1532         g_return_if_fail(item != NULL);
1533
1534         /* FIXME: item->path == NULL for top level folder, so this means that
1535          * properties of MH folder root will not be stored. Not quite important,
1536          * because the top level folder properties are not special anyway. */
1537         if (item->path) {
1538                 pp = g_new0(PersistPrefs, 1);
1539                 g_return_if_fail(pp != NULL);
1540                 pp->collapsed = item->collapsed;
1541                 pp->threaded  = item->threaded;
1542                 pp->ret_rcpt  = item->ret_rcpt;
1543                 pp->hide_read_msgs = item->hide_read_msgs;
1544                 g_hash_table_insert(pptable, item->path, pp);
1545         }
1546
1547         if (node->children) {
1548                 child = node->children;
1549                 while (child) {
1550                         cur = child;
1551                         child = cur->next;
1552                         folder_get_persist_prefs_recursive(cur, pptable);
1553                 }
1554         }
1555 }
1556
1557 static gboolean persist_prefs_free(gpointer key, gpointer val, gpointer data)
1558 {
1559         if (val)
1560                 g_free(val);
1561         return TRUE;
1562 }
1563