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:
1063                 break;
1064         }
1065
1066         prefs_folder_item_read_config(item);
1067
1068         node->data = item;
1069         xml_free_node(xmlnode);
1070
1071         return FALSE;
1072 }
1073
1074 static gboolean folder_read_folder_func(GNode *node, gpointer data)
1075 {
1076         Folder *folder;
1077         XMLNode *xmlnode;
1078         GList *list;
1079         FolderType type = F_UNKNOWN;
1080         const gchar *name = NULL;
1081         const gchar *path = NULL;
1082         PrefsAccount *account = NULL;
1083         gboolean collapsed = FALSE, threaded = TRUE, ret_rcpt = FALSE;
1084
1085         if (g_node_depth(node) != 2) return FALSE;
1086         g_return_val_if_fail(node->data != NULL, FALSE);
1087
1088         xmlnode = node->data;
1089         if (strcmp2(xmlnode->tag->tag, "folder") != 0) {
1090                 g_warning("tag name != \"folder\"\n");
1091                 return TRUE;
1092         }
1093         g_node_unlink(node);
1094         list = xmlnode->tag->attr;
1095         for (; list != NULL; list = list->next) {
1096                 XMLAttr *attr = list->data;
1097
1098                 if (!attr || !attr->name || !attr->value) continue;
1099                 if (!strcmp(attr->name, "type")) {
1100                         if (!strcasecmp(attr->value, "mh"))
1101                                 type = F_MH;
1102                         else if (!strcasecmp(attr->value, "mbox"))
1103                                 type = F_MBOX;
1104                         else if (!strcasecmp(attr->value, "maildir"))
1105                                 type = F_MAILDIR;
1106                         else if (!strcasecmp(attr->value, "imap"))
1107                                 type = F_IMAP;
1108                         else if (!strcasecmp(attr->value, "news"))
1109                                 type = F_NEWS;
1110                 } else if (!strcmp(attr->name, "name"))
1111                         name = attr->value;
1112                 else if (!strcmp(attr->name, "path"))
1113                         path = attr->value;
1114                 else if (!strcmp(attr->name, "account_id")) {
1115                         account = account_find_from_id(atoi(attr->value));
1116                         if (!account) g_warning("account_id: %s not found\n",
1117                                                 attr->value);
1118                 } else if (!strcmp(attr->name, "collapsed"))
1119                         collapsed = *attr->value == '1' ? TRUE : FALSE;
1120                 else if (!strcmp(attr->name, "threaded"))
1121                         threaded = *attr->value == '1' ? TRUE : FALSE;
1122                 else if (!strcmp(attr->name, "reqretrcpt"))
1123                         ret_rcpt = *attr->value == '1' ? TRUE : FALSE;
1124         }
1125
1126         folder = folder_new(type, name, path);
1127         g_return_val_if_fail(folder != NULL, FALSE);
1128         folder->account = account;
1129         if (account && (type == F_IMAP || type == F_NEWS))
1130                 account->folder = REMOTE_FOLDER(folder);
1131         node->data = folder->node->data;
1132         g_node_destroy(folder->node);
1133         folder->node = node;
1134         folder_add(folder);
1135         FOLDER_ITEM(node->data)->collapsed = collapsed;
1136         FOLDER_ITEM(node->data)->threaded  = threaded;
1137         FOLDER_ITEM(node->data)->ret_rcpt  = ret_rcpt;
1138
1139         g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1140                         folder_build_tree, folder);
1141
1142         return FALSE;
1143 }
1144
1145 static gchar *folder_get_list_path(void)
1146 {
1147         static gchar *filename = NULL;
1148
1149         if (!filename)
1150                 filename =  g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
1151                                         FOLDER_LIST, NULL);
1152
1153         return filename;
1154 }
1155
1156 static void folder_write_list_recursive(GNode *node, gpointer data)
1157 {
1158         FILE *fp = (FILE *)data;
1159         FolderItem *item = FOLDER_ITEM(node->data);
1160         gint i, depth;
1161         static gchar *folder_type_str[] = {"mh", "mbox", "maildir", "imap",
1162                                            "news", "unknown"};
1163         static gchar *folder_item_stype_str[] = {"normal", "inbox", "outbox",
1164                                                  "draft", "queue", "trash"};
1165
1166         g_return_if_fail(item != NULL);
1167
1168         depth = g_node_depth(node);
1169         for (i = 0; i < depth; i++)
1170                 fputs("    ", fp);
1171         if (depth == 1) {
1172                 Folder *folder = item->folder;
1173
1174                 fprintf(fp, "<folder type=\"%s\"", folder_type_str[folder->type]);
1175                 if (folder->name) {
1176                         fputs(" name=\"", fp);
1177                         xml_file_put_escape_str(fp, folder->name);
1178                         fputs("\"", fp);
1179                 }
1180                 if ((folder->type == F_MH) || (folder->type == F_MBOX)) {
1181                         fputs(" path=\"", fp);
1182                         xml_file_put_escape_str
1183                                 (fp, LOCAL_FOLDER(folder)->rootpath);
1184                         fputs("\"", fp);
1185                 }
1186                 if (folder->account)
1187                         fprintf(fp, " account_id=\"%d\"",
1188                                 folder->account->account_id);
1189                 if (item->collapsed && node->children)
1190                         fputs(" collapsed=\"1\"", fp);
1191                 if (item->ret_rcpt)
1192                         fputs(" reqretrcpt=\"1\"", fp);
1193         } else {
1194                 fprintf(fp, "<folderitem type=\"%s\"",
1195                         folder_item_stype_str[item->stype]);
1196                 if (item->name) {
1197                         fputs(" name=\"", fp);
1198                         xml_file_put_escape_str(fp, item->name);
1199                         fputs("\"", fp);
1200                 }
1201                 if (item->path) {
1202                         fputs(" path=\"", fp);
1203                         xml_file_put_escape_str(fp, item->path);
1204                         fputs("\"", fp);
1205                 }
1206                 if (item->account)
1207                         fprintf(fp, " account_id=\"%d\"",
1208                                 item->account->account_id);
1209                 if (item->no_sub)
1210                         fputs(" no_sub=\"1\"", fp);
1211                 if (item->no_select)
1212                         fputs(" no_select=\"1\"", fp);
1213                 if (item->collapsed && node->children)
1214                         fputs(" collapsed=\"1\"", fp);
1215                 if (item->threaded)
1216                         fputs(" threaded=\"1\"", fp);
1217                 else
1218                         fputs(" threaded=\"0\"", fp);
1219                 if (item->hide_read_msgs)
1220                         fputs(" hidereadmsgs=\"1\"", fp);
1221                 else
1222                         fputs(" hidereadmsgs=\"0\"", fp);
1223                 if (item->ret_rcpt)
1224                         fputs(" reqretrcpt=\"1\"", fp);
1225                 fprintf(fp,
1226                         " mtime=\"%lu\" new=\"%d\" unread=\"%d\" total=\"%d\"",
1227                         item->mtime, item->new, item->unread, item->total);
1228         }
1229
1230         if (node->children) {
1231                 GNode *child;
1232                 fputs(">\n", fp);
1233
1234                 child = node->children;
1235                 while (child) {
1236                         GNode *cur;
1237
1238                         cur = child;
1239                         child = cur->next;
1240                         folder_write_list_recursive(cur, data);
1241                 }
1242
1243                 for (i = 0; i < depth; i++)
1244                         fputs("    ", fp);
1245                 fprintf(fp, "</%s>\n", depth == 1 ? "folder" : "folderitem");
1246         } else
1247                 fputs(" />\n", fp);
1248 }
1249
1250 static void folder_update_op_count_rec(GNode *node) {
1251         FolderItem *fitem = FOLDER_ITEM(node->data);
1252
1253         if (g_node_depth(node) > 0) {
1254                 if (fitem->op_count > 0) {
1255                         fitem->op_count = 0;
1256                         folderview_update_item(fitem, 0);
1257                 }
1258                 if (node->children) {
1259                         GNode *child;
1260
1261                         child = node->children;
1262                         while (child) {
1263                                 GNode *cur;
1264
1265                                 cur = child;
1266                                 child = cur->next;
1267                                 folder_update_op_count_rec(cur);
1268                         }
1269                 }
1270         }
1271 }
1272
1273 void folder_update_op_count() {
1274         GList *cur;
1275         Folder *folder;
1276
1277         for (cur = folder_list; cur != NULL; cur = cur->next) {
1278                 folder = cur->data;
1279                 folder_update_op_count_rec(folder->node);
1280         }
1281 }
1282
1283 typedef struct _type_str {
1284         gchar * str;
1285         gint type;
1286 } type_str;
1287
1288
1289 static type_str type_str_table[] =
1290 {
1291         {"#mh", F_MH},
1292         {"#mbox", F_MBOX},
1293         {"#maildir", F_MAILDIR},
1294         {"#imap", F_IMAP},
1295         {"#news", F_NEWS}
1296 };
1297
1298
1299 static gchar * folder_get_type_string(gint type)
1300 {
1301         gint i;
1302
1303         for(i = 0 ; i < sizeof(type_str_table) / sizeof(type_str) ; i++) {
1304                 if (type_str_table[i].type == type)
1305                         return type_str_table[i].str;
1306         }
1307         return NULL;
1308 }
1309
1310 static gint folder_get_type_from_string(gchar * str)
1311 {
1312         gint i;
1313
1314         for(i = 0 ; i < sizeof(type_str_table) / sizeof(type_str) ; i++) {
1315                 if (g_strcasecmp(type_str_table[i].str, str))
1316                         return type_str_table[i].type;
1317         }
1318         return F_UNKNOWN;
1319 }
1320
1321 gchar * folder_get_identifier(Folder * folder)
1322 {
1323         gchar * type_str;
1324         type_str = folder_get_type_string(folder->type);
1325
1326         return g_strconcat(type_str, "/", folder->name, NULL);
1327 }
1328
1329 /*
1330 static gchar * folder_item_get_tree_identifier(FolderItem * item)
1331 {
1332         if (item->parent != NULL) {
1333                 gchar * path;
1334                 gchar * id;
1335
1336                 path = folder_item_get_tree_identifier(item->parent);
1337                 if (path == NULL)
1338                         return NULL;
1339
1340                 id = g_strconcat(path, "/", item->name, NULL);
1341                 g_free(path);
1342
1343                 return id;
1344         }
1345         else {
1346                 return g_strconcat("/", item->name, NULL);
1347         }
1348 }
1349 */
1350
1351 gchar * folder_item_get_identifier(FolderItem * item)
1352 {
1353         gchar * id;
1354         gchar * folder_str;
1355
1356         g_return_val_if_fail(item->path != NULL, NULL);
1357
1358         folder_str = folder_get_identifier(item->folder);
1359         id = g_strconcat(folder_str, "/", item->path, NULL);
1360         g_free(folder_str);
1361
1362         return id;
1363 }
1364
1365 Folder * folder_find_from_name(const gchar * name)
1366 {
1367         GList *list;
1368         Folder *folder;
1369
1370         for (list = g_list_first(folder_list); list != NULL;
1371              list = list->next) {
1372                 folder = list->data;
1373                 if (strcmp(name, folder->name) == 0)
1374                         return folder;
1375         }
1376         return NULL;
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         gint type;
1386         gchar * name;
1387         gchar * path;
1388
1389         Xstrdup_a(str, identifier, return NULL);
1390
1391         /* extract box type */
1392
1393         p = strchr(str, '/');
1394
1395         if (p == NULL)
1396                 return NULL;
1397
1398         *p = '\0';
1399
1400         type = folder_get_type_from_string(str);
1401
1402         str = p + 1;
1403
1404         /* extract box name */
1405
1406         p = strchr(str, '/');
1407
1408         if (p == NULL)
1409                 return NULL;
1410
1411         *p = '\0';
1412
1413         name = str;
1414
1415         folder = folder_find_from_name(name);
1416         if (folder == NULL)
1417                 return;
1418
1419         path = p + 1;
1420
1421         d[0] = (gpointer)path;
1422         d[1] = NULL;
1423         g_node_traverse(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1424                         folder_item_find_func, d);
1425         return d[1];
1426 }
1427
1428 /* CLAWS: temporary local folder for filtering */
1429
1430 static Folder *processing_folder;
1431 static FolderItem *processing_folder_item;
1432
1433 static void folder_create_processing_folder(void)
1434 {
1435 #define PROCESSING_FOLDER ".processing"
1436         Folder     *tmpparent;
1437         FolderItem *tmpfolder;
1438         gchar      *tmpname;
1439
1440         tmpparent = folder_get_default_folder();
1441         g_assert(tmpparent);
1442         debug_print("tmpparentroot %s\n", LOCAL_FOLDER(tmpparent)->rootpath);
1443         if (LOCAL_FOLDER(tmpparent)->rootpath[0] == '/')
1444                 tmpname = g_strconcat(LOCAL_FOLDER(tmpparent)->rootpath,
1445                                       G_DIR_SEPARATOR_S, PROCESSING_FOLDER,
1446                                       NULL);
1447         else
1448                 tmpname = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
1449                                       LOCAL_FOLDER(tmpparent)->rootpath,
1450                                       G_DIR_SEPARATOR_S, PROCESSING_FOLDER,
1451                                       NULL);
1452
1453         processing_folder = folder_new(F_MH, "PROCESSING", LOCAL_FOLDER(tmpparent)->rootpath);
1454         g_assert(processing_folder);
1455
1456         if (!is_dir_exist(tmpname)) {
1457                 debug_print("*TMP* creating %s\n", tmpname);
1458                 processing_folder_item = processing_folder->create_folder(processing_folder,
1459                                                                           processing_folder->node->data,
1460                                                                           PROCESSING_FOLDER);
1461                 g_assert(processing_folder_item);
1462         }
1463         else {
1464                 debug_print("*TMP* already created\n");
1465                 processing_folder_item = folder_item_new(".processing", ".processing");
1466                 g_assert(processing_folder_item);
1467                 folder_item_append(processing_folder->node->data, processing_folder_item);
1468         }
1469         g_free(tmpname);
1470 }
1471
1472 FolderItem *folder_get_default_processing(void)
1473 {
1474         if (!processing_folder_item) {
1475                 folder_create_processing_folder();
1476         }
1477         return processing_folder_item;
1478 }
1479
1480 /* folder_persist_prefs_new() - return hash table with persistent
1481  * settings (and folder name as key).
1482  * (note that in claws other options are in the PREFS_FOLDER_ITEM_RC
1483  * file, so those don't need to be included in PersistPref yet)
1484  */
1485 GHashTable *folder_persist_prefs_new(Folder *folder)
1486 {
1487         GHashTable *pptable;
1488
1489         g_return_val_if_fail(folder, NULL);
1490         pptable = g_hash_table_new(g_str_hash, g_str_equal);
1491         folder_get_persist_prefs_recursive(folder->node, pptable);
1492         return pptable;
1493 }
1494
1495 void folder_persist_prefs_free(GHashTable *pptable)
1496 {
1497         g_return_if_fail(pptable);
1498         g_hash_table_foreach_remove(pptable, persist_prefs_free, NULL);
1499         g_hash_table_destroy(pptable);
1500 }
1501
1502 const PersistPrefs *folder_get_persist_prefs(GHashTable *pptable, const char *name)
1503 {
1504         if (pptable == NULL || name == NULL) return NULL;
1505         return g_hash_table_lookup(pptable, name);
1506 }
1507
1508 void folder_item_restore_persist_prefs(FolderItem *item, GHashTable *pptable)
1509 {
1510         const PersistPrefs *pp;
1511
1512         pp = folder_get_persist_prefs(pptable, item->path);
1513         if (!pp) return;
1514
1515         /* CLAWS: since not all folder properties have been migrated to
1516          * folderlist.xml, we need to call the old stuff first before
1517          * setting things that apply both to Main and Claws. */
1518         prefs_folder_item_read_config(item);
1519
1520         item->collapsed = pp->collapsed;
1521         item->threaded  = pp->threaded;
1522         item->ret_rcpt  = pp->ret_rcpt;
1523         item->hide_read_msgs = pp->hide_read_msgs;
1524 }
1525
1526 static void folder_get_persist_prefs_recursive(GNode *node, GHashTable *pptable)
1527 {
1528         FolderItem *item = FOLDER_ITEM(node->data);
1529         PersistPrefs *pp;
1530         GNode *child, *cur;
1531
1532         g_return_if_fail(node != NULL);
1533         g_return_if_fail(item != NULL);
1534
1535         /* FIXME: item->path == NULL for top level folder, so this means that
1536          * properties of MH folder root will not be stored. Not quite important,
1537          * because the top level folder properties are not special anyway. */
1538         if (item->path) {
1539                 pp = g_new0(PersistPrefs, 1);
1540                 g_return_if_fail(pp != NULL);
1541                 pp->collapsed = item->collapsed;
1542                 pp->threaded  = item->threaded;
1543                 pp->ret_rcpt  = item->ret_rcpt;
1544                 pp->hide_read_msgs = item->hide_read_msgs;
1545                 g_hash_table_insert(pptable, item->path, pp);
1546         }
1547
1548         if (node->children) {
1549                 child = node->children;
1550                 while (child) {
1551                         cur = child;
1552                         child = cur->next;
1553                         folder_get_persist_prefs_recursive(cur, pptable);
1554                 }
1555         }
1556 }
1557
1558 static gboolean persist_prefs_free(gpointer key, gpointer val, gpointer data)
1559 {
1560         if (val)
1561                 g_free(val);
1562         return TRUE;
1563 }
1564