0.9.10claws5
[claws.git] / src / folder.h
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2
3 /*
4  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
5  * Copyright (C) 1999-2003 Hiroyuki Yamamoto
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20  */
21
22 #ifndef __FOLDER_H__
23 #define __FOLDER_H__
24
25 #include <glib.h>
26 #include <time.h>
27
28 typedef struct _Folder          Folder;
29 typedef struct _FolderClass     FolderClass;
30
31 typedef struct _FolderItem      FolderItem;
32 typedef struct _FolderUpdateData        FolderUpdateData;
33 typedef struct _FolderItemUpdateData    FolderItemUpdateData;
34 typedef struct _PersistPrefs            PersistPrefs;
35
36 #define FOLDER(obj)             ((Folder *)obj)
37 #define FOLDER_CLASS(obj)       (FOLDER(obj)->klass)
38 #define FOLDER_TYPE(obj)        (FOLDER(obj)->klass->type)
39
40 #define FOLDER_IS_LOCAL(obj)    (FOLDER_TYPE(obj) == F_MH      || \
41                                  FOLDER_TYPE(obj) == F_MBOX    || \
42                                  FOLDER_TYPE(obj) == F_MAILDIR)
43
44 #define FOLDER_ITEM(obj)        ((FolderItem *)obj)
45
46 #define FOLDER_UPDATE_HOOKLIST "folder_update"
47 #define FOLDER_ITEM_UPDATE_HOOKLIST "folder_item_update"
48
49 typedef enum
50 {
51         F_MH,
52         F_MBOX,
53         F_MAILDIR,
54         F_IMAP,
55         F_NEWS,
56         F_UNKNOWN
57 } FolderType;
58
59 typedef enum
60 {
61         F_NORMAL,
62         F_INBOX,
63         F_OUTBOX,
64         F_DRAFT,
65         F_QUEUE,
66         F_TRASH
67 } SpecialFolderItemType;
68
69 typedef enum
70 {
71         SORT_BY_NONE,
72         SORT_BY_NUMBER,
73         SORT_BY_SIZE,
74         SORT_BY_DATE,
75         SORT_BY_FROM,
76         SORT_BY_SUBJECT,
77         SORT_BY_SCORE,
78         SORT_BY_LABEL,
79         SORT_BY_MARK,
80         SORT_BY_STATUS,
81         SORT_BY_MIME,
82         SORT_BY_TO,
83         SORT_BY_LOCKED
84 } FolderSortKey;
85
86 typedef enum
87 {
88         SORT_ASCENDING,
89         SORT_DESCENDING
90 } FolderSortType;
91
92 typedef enum
93 {
94         F_MOVE_OK = 0,
95         F_MOVE_FAILED_DEST_IS_PARENT = -1,
96         F_MOVE_FAILED_DEST_IS_CHILD = -2,
97         F_MOVE_FAILED_DEST_OUTSIDE_MAILBOX = -3,
98         F_MOVE_FAILED = -4,
99 } FolderItemMoveResult;
100
101 typedef enum
102 {
103         FOLDER_NEW_FOLDER               = 1 << 0,
104         FOLDER_DESTROY_FOLDER           = 1 << 1,
105         FOLDER_TREE_CHANGED             = 1 << 2,
106         FOLDER_NEW_FOLDERITEM           = 1 << 3,
107         FOLDER_REMOVE_FOLDERITEM        = 1 << 4,
108 } FolderUpdateFlags;
109
110 typedef enum
111 {
112         F_ITEM_UPDATE_MSGCNT = 1 << 0,
113         F_ITEM_UPDATE_CONTENT = 1 << 1,
114 } FolderItemUpdateFlags;
115
116 typedef void (*FolderUIFunc)            (Folder         *folder,
117                                          FolderItem     *item,
118                                          gpointer        data);
119 typedef void (*FolderDestroyNotify)     (Folder         *folder,
120                                          FolderItem     *item,
121                                          gpointer        data);
122 typedef void (*FolderItemFunc)          (FolderItem     *item,
123                                          gpointer        data);
124
125
126 #include "folder_item_prefs.h"
127
128 #include "procmsg.h"
129 #include "msgcache.h"
130 #include "xml.h"
131 #include "prefs_account.h"
132
133 struct _Folder
134 {
135         FolderClass *klass;
136
137         gchar *name;
138         PrefsAccount *account;
139
140         FolderItem *inbox;
141         FolderItem *outbox;
142         FolderItem *draft;
143         FolderItem *queue;
144         FolderItem *trash;
145
146         FolderUIFunc ui_func;
147         gpointer     ui_func_data;
148
149         GNode *node;
150
151         gpointer data;
152
153         GHashTable *newsart;
154 };
155
156 struct _FolderClass
157 {
158         /**
159          * A numeric identifier for the FolderClass. Will be removed in the future
160          */
161         FolderType  type;
162         /**
163          * A string identifier for the FolderClass. Currently used in folderlist.xml.
164          * Should be lowercase.
165          */
166         gchar      *idstr;
167         /**
168          * A string for the User Interface that identifies the FolderClass to the
169          * user. Can be upper and lowercase unlike the idstr.
170          */
171         gchar      *uistr;
172         
173         /* virtual functions */
174
175         /* Folder funtions */
176         /**
177          * Create a new \c Folder of this \c FolderClass.
178          *
179          * \param name The name of the new Folder
180          * \param path The path of the new Folder
181          * \return The new \c Folder, or \c NULL when creating the \c Folder 
182          *         failed
183          */
184         Folder          *(*new_folder)          (const gchar    *name,
185                                                  const gchar    *path);
186         /**
187          * Destroy a \c Folder of this \c FolderClass, frees all resources
188          * allocated by the Folder
189          *
190          * \param folder The \c Folder that should be destroyed.
191          */
192         void            (*destroy_folder)       (Folder         *folder);
193         /**
194          * Set the Folder's internal attributes from an \c XMLTag. Also sets the
195          * parameters of the root-FolderItem of the \c Folder. If \c NULL
196          * the default function of the basic \ยข FolderClass is used, so it
197          * must not be \c NULL if one of the parent \c FolderClasses has a \c set_xml
198          * function. In that case the parent \c FolderClass' \c set_xml function
199          * can be used or it has to be called with the \c folder and \c tag by
200          * the implementation.
201          *
202          * \param folder The \c Folder which's attributes should be updated
203          * \param tag The \c XMLTag containing the \c XMLAttrs for the attributes
204          */
205         void             (*set_xml)             (Folder         *folder,
206                                                  XMLTag         *tag);
207         /**
208          * Get an \c XMLTag for the attributes of the \c Folder and the root-FolderItem
209          * of the \c Folder. If \c NULL the default implementation for the basic
210          * FolderClass will be used, so it must not be \c NULL if one of the
211          * parent \c FolderClasses has it's own implementation for \c get_xml.
212          * In that case the parent FolderClass' \c get_xml function can be
213          * used or the \c XMLTag has to be fetched from the parent's \c get_xml
214          * function and then the \c FolderClass specific attributes can be
215          * added to it.
216          *
217          * \param Folder The \c Folder which's attributes should be set in the
218          *               \c XMLTag's \c XMLAttrs
219          * \return XMLTag An \c XMLTag with \c XMLAttrs containing the \c Folder's
220          *                attributes.
221          */
222         XMLTag          *(*get_xml)             (Folder         *folder);
223         /**
224          * Rebuild the folder tree from the folder's data
225          * \todo New implementations of MH and IMAP are actually syncronizing
226          *       the tree with the folder by reusing the old \c FolderItems.
227          *       Claws still destroys the old tree before calling this function.
228          *
229          * \param folder The folder which's tree should be rebuild
230          * \return 0 on success, a negative number otherwise
231          */
232         gint            (*scan_tree)            (Folder         *folder);
233
234         gint            (*create_tree)          (Folder         *folder);
235
236         /* FolderItem functions */
237         /**
238          * Create a new \c FolderItem structure for the \c FolderClass.
239          * \c FolderClasses can have their own \c FolderItem structure with
240          * extra attributes.
241          *
242          * \param folder The \c Folder for that a \c FolderItem should be
243          *               created
244          * \return The new \c FolderItem or NULL in case of an error
245          */
246         FolderItem      *(*item_new)            (Folder         *folder);
247         /**
248          * Destroy a \c FolderItem from this \c FolderClass. The \c FolderClass
249          * has to free all private resources used by the \c FolderItem.
250          *
251          * \param folder The \c Folder of the \c FolderItem
252          * \param item The \c FolderItem that should be destroyed
253          */
254         void             (*item_destroy)        (Folder         *folder,
255                                                  FolderItem     *item);
256         /**
257          * Set the \c FolderItem's internal attributes from an \c XMLTag. If
258          * \c NULL the default function of the basic \c FolderClass is used, so it
259          * must not be \c NULL if one of the parent \c FolderClasses has a \c item_set_xml
260          * function. In that case the parent \c FolderClass' \c item_set_xml function
261          * can be used or it has to be called with the \c folder, \c item and \c tag by
262          * the implementation.
263          *
264          * \param folder The \c Folder of the \c FolderItem
265          * \param item The \c FolderItems which's attributes should be set
266          * \param tag The \c XMLTag with \c XMLAttrs for the \c FolderItem's
267          *            attributes
268          */
269         void             (*item_set_xml)        (Folder         *folder,
270                                                  FolderItem     *item,
271                                                  XMLTag         *tag);
272         /**
273          * Get an \c XMLTag for the attributes of the \c FolderItem If \c NULL
274          * the default implementation for the basic \c FolderClass will be used,
275          * so it must not be \c NULL if one of the parent \c FolderClasses has
276          * it's own implementation for \c item_get_xml. In that case the parent 
277          * FolderClass' \c item_get_xml function can be used or the \c XMLTag
278          * has to be fetched from the parent's \c item_get_xml function and 
279          * then the \c FolderClass specific attributes can be added to it.
280          *
281          * \param folder The \c Folder of the \c FolderItem
282          * \parem item The \c FolderItem which's attributes should be set in
283          *             the \c XMLTag's \c XMLAttrs
284          * \return An \c XMLTag with \c XMLAttrs containing the \c FolderItem's
285          *         attributes.
286          */
287         XMLTag          *(*item_get_xml)        (Folder         *folder,
288                                                  FolderItem     *item);
289         /**
290          * Get a local path for the \c FolderItem where Sylpheed can save
291          * it's cache data. For local directory based folders this can be the
292          * real path. For other folders it can be the local cache directory.
293          *
294          * \param folder The \c Folder of the \c FolderItem
295          * \param item The \c FolderItem for that a path should be returned
296          * \return A path for the \c FolderItem
297          */
298         gchar           *(*item_get_path)       (Folder         *folder,
299                                                  FolderItem     *item);
300         /**
301          * Create a new \c FolderItem. The function must use folder_item_append
302          * to add the new \c FolderItem to the folder tree
303          *
304          * \param folder The \c Folder in which a new \c FolderItem should be
305          *               created
306          * \param parent \c The parent \c FolderItem for the new \c FolderItem
307          * \parem name The name for the new \c FolderItem
308          * \return The new \c FolderItem
309          */
310         FolderItem      *(*create_folder)       (Folder         *folder,
311                                                  FolderItem     *parent,
312                                                  const gchar    *name);
313         /**
314          * Rename a \c FolderItem
315          *
316          * \param folder The \c Folder of the \c FolderItem that should be
317          *               renamed
318          * \param item The \c FolderItem that should be renamed
319          * \param name The new name of the \c FolderItem
320          * \return 0 on success, a negative number otherwise
321          */
322         gint             (*rename_folder)       (Folder         *folder,
323                                                  FolderItem     *item,
324                                                  const gchar    *name);
325         /**
326          * Remove a \c FolderItem from the \c Folder
327          *
328          * \param folder The \c Folder that contains the \c FolderItem
329          * \param item The \c FolderItem that should be removed
330          * \return 0 on sucess, a negative number otherwise
331          */
332         gint             (*remove_folder)       (Folder         *folder,
333                                                  FolderItem     *item);
334         /**
335          * Close a \c FolderItem. Called when the user deselects a
336          * \c FolderItem.
337          * 
338          * \attention In Sylpheed-Main operations can only be done on the
339          *            \c FolderItem that is opened in the SummaryView. This
340          *            \c FolderItem will be closed when you select a new
341          *            \c FolderItem in the FolderView. In Claws operations can
342          *            be done any time on any folder and you should not expect
343          *            that all \c FolderItems get closed after operations
344          *
345          * \param folder The \c Folder that contains the \c FolderItem
346          * \param item The \c FolderItem that should be closed
347          * \return 0 on success, a negative number otherwise
348          */
349         gint             (*close)               (Folder         *folder,
350                                                  FolderItem     *item);
351         /**
352          * Get the list of message numbers for the messages in the \c FolderItem
353          *
354          * \param folder The \c Folder that contains the \c FolderItem
355          * \param item The \c FolderItem for which the message numbers should
356          *             be fetched
357          * \param list Pointer to a GSList where message numbers have to be
358          *             added. Because of the implementation of the GSList that
359          *             changes the pointer of the GSList itself when the first
360          *             item is added this is a pointer to a pointer to a
361          *             GSList structure. Use *item = g_slist_...(*item, ...)
362          *             operations to modify the list.
363          * \param old_uids_valid In some \c Folders the old UIDs can be invalid.
364          *                       Set this pointer to a gboolean to TRUE if the
365          *                       old UIDs are still valid, otherwise set it to
366          *                       FALSE and the folder system will discard it's
367          *                       cache data of the previously know UIDs
368          * \return The number of message numbers add to the list on success,
369          *         a negative number otherwise.
370          */
371         gint             (*get_num_list)        (Folder         *folder,
372                                                  FolderItem     *item,
373                                                  GSList        **list,
374                                                  gboolean       *old_uids_valid);
375         /**
376          * Tell the folder system if a \c FolderItem should be scanned
377          * (cache data syncronized with the folder content) when it is required
378          * because the \c FolderItem's content changed. If NULL the folder
379          * system will not do automatic scanning of \c FolderItems
380          *
381          * \param folder The \c Folder that contains the \c FolderItem
382          * \param item The \c FolderItem which's content should be checked
383          * \return TRUE if the \c FolderItem should be scanned, FALSE otherwise
384          */
385         gboolean        (*scan_required)        (Folder         *folder,
386                                                  FolderItem     *item);
387
388         /* Message functions */
389         /**
390          * Get a MsgInfo for a message in a \c FolderItem
391          *
392          * \param folder The \c Folder containing the message
393          * \param item The \c FolderItem containing the message
394          * \param num The message number of the message
395          * \return A pointer to a \c MsgInfo decribing the message or \c 
396          *         NULL in case of an error
397          */
398         MsgInfo         *(*get_msginfo)         (Folder         *folder,
399                                                  FolderItem     *item,
400                                                  gint            num);
401         /**
402          * Get \c MsgInfos for a list of message numbers
403          *
404          * \param folder The \c Folder containing the message
405          * \param item The \c FolderItem containing the message
406          * \param msgnum_list A list of message numbers for which the
407          *                    \c MsgInfos should be fetched
408          * \return A list of \c MsgInfos for the messages in the \c msgnum_list
409          *         that really exist. Messages that are not found can simply
410          *         be left out.
411          */
412         MsgInfoList     *(*get_msginfos)        (Folder         *folder,
413                                                  FolderItem     *item,
414                                                  MsgNumberList  *msgnum_list);
415         /**
416          * Get the filename for a message. This can either be the real message
417          * file for local folders or a temporary file for remote folders.
418          *
419          * \param folder The \c Folder containing the message
420          * \param item The \c FolderItem containing the message
421          * \param num The message number of the message
422          * \return A string with the filename of the message file. The returned
423          *         string has to be freed with \c g_free(). If message is not
424          *         available return NULL.
425          */
426         gchar           *(*fetch_msg)           (Folder         *folder,
427                                                  FolderItem     *item,
428                                                  gint            num);
429         /**
430          * Add a single message file to a folder with the given flags (if
431          * flag handling is supported by the folder)
432          *
433          * \param folder The target \c Folder for the message
434          * \param dest the target \c FolderItem for the message
435          * \param file The file that contains the message
436          * \param flags The flags the new message should have in the folder
437          * \return 0 on success, a negative number otherwise
438          */
439         gint            (*add_msg)              (Folder         *folder,
440                                                  FolderItem     *dest,
441                                                  const gchar    *file,
442                                                  MsgFlags       *flags);
443         /**
444          * Add multiple messages to a \c FolderItem. If NULL the folder
445          * system will add messages with \c add_msg one by one
446          *
447          * \param folder The target \c Folder for the messages
448          * \param dest the target \c FolderItem for the messages
449          * \param file_list A list of \c MsgFileInfos which contain the
450          *                  filenames and flags for the new messages
451          * \param relation Insert tuples of (MsgFileInfo, new message number) to
452          *                 provide feedback for the folder system which new
453          *                 message number a \c MsgFileInfo got in dest. Insert
454          *                 0 if the new message number is unknown.
455          */
456         gint            (*add_msgs)             (Folder         *folder,
457                                                  FolderItem     *dest,
458                                                  GSList         *file_list,
459                                                  GRelation      *relation);
460         /**
461          * Copy a message to a FolderItem
462          *
463          * \param folder The \c Folder of the destination FolderItem
464          * \param dest The destination \c FolderItem for the message
465          * \param msginfo The message that should be copied
466          * \return The message number the copied message got, 0 if it is
467          *         unknown because message numbers are assigned by an external
468          *         system and not available after copying or a negative number
469          *         if an error occuried
470          */
471         gint            (*copy_msg)             (Folder         *folder,
472                                                  FolderItem     *dest,
473                                                  MsgInfo        *msginfo);
474         /**
475          * Copy multiple messages to a \c FolderItem. If \c NULL the folder
476          * system will use \c copy_msg to copy messages one by one.
477          *
478          * \param folder The \c Folder of the destination FolderItem
479          * \param dest The destination \c FolderItem for the message
480          * \param msglist A list of \c MsgInfos which should be copied to dest
481          * \param relation Insert tuples of (MsgInfo, new message number) to
482          *                 provide feedback for the folder system which new
483          *                 message number a \c MsgInfo got in dest. Insert
484          *                 0 if the new message number is unknown.
485          * \return 0 on success, a negative number otherwise
486          */
487         gint            (*copy_msgs)            (Folder         *folder,
488                                                  FolderItem     *dest,
489                                                  MsgInfoList    *msglist,
490                                                  GRelation      *relation);
491         /**
492          * Remove a message from a \c FolderItem.
493          *
494          * \param folder The \c Folder of the message
495          * \param item The \c FolderItem containing the message
496          * \param num The message number of the message
497          * \return 0 on success, a negative number otherwise
498          */
499         gint            (*remove_msg)           (Folder         *folder,
500                                                  FolderItem     *item,
501                                                  gint            num);
502         /**
503          * Remove all messages in a \ c FolderItem
504          *
505          * \param folder The \c Folder of the \c FolderItem
506          * \param item The \FolderItem which's messages should be deleted
507          * \return 0 on succes, a negative number otherwise
508          */
509         gint            (*remove_all_msg)       (Folder         *folder,
510                                                  FolderItem     *item);
511         /**
512          * Check if a message has been modified by someone else
513          *
514          * \param folder The \c Folder of the message
515          * \param item The \c FolderItem containing the message
516          * \param msginfo The \c MsgInfo for the message that should be checked
517          * \return \c TRUE if the message was modified, \c FALSE otherwise
518          */
519         gboolean        (*is_msg_changed)       (Folder         *folder,
520                                                  FolderItem     *item,
521                                                  MsgInfo        *msginfo);
522         /**
523          * Update a message's flags in the folder data. If NULL only the
524          * internal flag management will be used. The function has to set
525          * \c msginfo->flags.perm_flags. It does not have to set the flags
526          * that it got as \c newflags. If a flag can not be set in this
527          * \c FolderClass the function can refuse to set it. Flags that are not
528          * supported by the \c FolderClass should not be refused. They will be
529          * managed by the internal cache in this case.
530          *
531          * \param folder The \c Folder of the message
532          * \param item The \c FolderItem of the message
533          * \param msginfo The \c MsgInfo for the message which's flags should be
534          *                updated
535          * \param newflags The flags the message should get
536          */
537         void            (*change_flags)         (Folder         *folder,
538                                                  FolderItem     *item,
539                                                  MsgInfo        *msginfo,
540                                                  MsgPermFlags    newflags);
541         /**
542          * Get the flags for a list of messages. Flags that are not supported
543          * by the folder should be preserved. They can be copied from
544          * \c msginfo->flags.perm_flags
545          *
546          * \param folder The \c Folder of the messages
547          * \param item The \c FolderItem of the messages
548          * \param msglist The list of \c MsgInfos for which the flags should
549          *                   be returned
550          * \param msgflags A \c GRelation for tuples of (MsgInfo, new permanent
551          *        flags for MsgInfo). Add tuples for the messages in msglist
552          * \return 0 on success, a negative number otherwise
553          */
554         gint            (*get_flags)            (Folder         *folder,
555                                                  FolderItem     *item,
556                                                  MsgInfoList    *msglist,
557                                                  GRelation      *msgflags);
558 };
559
560 struct _FolderItem
561 {
562         SpecialFolderItemType stype;
563
564         gchar *name;
565         gchar *path;
566
567         time_t mtime;
568
569         gint new_msgs;
570         gint unread_msgs;
571         gint total_msgs;
572         gint unreadmarked_msgs;
573
574         gint last_num;
575
576         MsgCache *cache;
577
578         /* special flags */
579         guint no_sub         : 1; /* no child allowed?    */
580         guint no_select      : 1; /* not selectable?      */
581         guint collapsed      : 1; /* collapsed item       */
582         guint thread_collapsed      : 1; /* collapsed item       */
583         guint threaded       : 1; /* threaded folder view */
584         guint hide_read_msgs : 1; /* hide read messages   */
585         guint ret_rcpt       : 1; /* return receipt       */
586
587         gint op_count;
588         guint opened         : 1; /* opened by summary view */
589         FolderItemUpdateFlags update_flags; /* folderview for this folder should be updated */
590
591         FolderSortKey sort_key;
592         FolderSortType sort_type;
593
594         GNode *node;
595
596         Folder *folder;
597
598         PrefsAccount *account;
599
600         gboolean apply_sub;
601         
602         GSList *mark_queue;
603
604         gpointer data;
605
606         FolderItemPrefs * prefs;
607 };
608
609 struct _PersistPrefs
610 {
611         FolderSortKey   sort_key;
612         FolderSortType  sort_type;
613         guint           collapsed       : 1;
614         guint           thread_collapsed        : 1;
615         guint           threaded        : 1;
616         guint           hide_read_msgs  : 1; /* CLAWS */
617         guint           ret_rcpt        : 1; /* CLAWS */
618 };
619
620 struct _FolderUpdateData
621 {
622         Folder                  *folder;
623         FolderUpdateFlags        update_flags;
624         FolderItem              *item;
625 };
626
627 struct _FolderItemUpdateData
628 {
629         FolderItem              *item;
630         FolderItemUpdateFlags    update_flags;
631 };
632
633 void        folder_system_init          (void);
634 void        folder_register_class       (FolderClass    *klass);
635 void        folder_unregister_class     (FolderClass    *klass);
636 Folder     *folder_new                  (FolderClass    *type,
637                                          const gchar    *name,
638                                          const gchar    *path);
639 void        folder_init                 (Folder         *folder,
640                                          const gchar    *name);
641
642 void        folder_destroy              (Folder         *folder);
643
644 void        folder_set_xml              (Folder          *folder,
645                                          XMLTag          *tag);
646 XMLTag     *folder_get_xml              (Folder          *folder);
647
648 FolderItem *folder_item_new             (Folder         *folder,
649                                          const gchar    *name,
650                                          const gchar    *path);
651 void        folder_item_append          (FolderItem     *parent,
652                                          FolderItem     *item);
653 void        folder_item_remove          (FolderItem     *item);
654 void        folder_item_remove_children (FolderItem     *item);
655 void        folder_item_destroy         (FolderItem     *item);
656 FolderItem *folder_item_parent          (FolderItem     *item);
657
658 void        folder_item_set_xml         (Folder          *folder,
659                                          FolderItem      *item,
660                                          XMLTag          *tag);
661 XMLTag     *folder_item_get_xml         (Folder          *folder,
662                                          FolderItem      *item);
663
664 void        folder_set_ui_func  (Folder         *folder,
665                                  FolderUIFunc    func,
666                                  gpointer        data);
667 void        folder_set_name     (Folder         *folder,
668                                  const gchar    *name);
669 void        folder_tree_destroy (Folder         *folder);
670
671 void   folder_add               (Folder         *folder);
672
673 GList *folder_get_list          (void);
674 gint   folder_read_list         (void);
675 void   folder_write_list        (void);
676 void   folder_scan_tree         (Folder *folder);
677 FolderItem *folder_create_folder(FolderItem     *parent, const gchar *name);
678 void   folder_update_op_count           (void);
679 void   folder_func_to_all_folders       (FolderItemFunc function,
680                                          gpointer data);
681 void   folder_count_total_msgs  (guint          *new_msgs,
682                                  guint          *unread_msgs,
683                                  guint          *unreadmarked_msgs,
684                                  guint          *total_msgs);
685 gchar *folder_get_status        (GPtrArray      *folders,
686                                  gboolean        full);
687
688 Folder     *folder_find_from_path               (const gchar    *path);
689 Folder     *folder_find_from_name               (const gchar    *name,
690                                                  FolderClass    *klass);
691 FolderItem *folder_find_item_from_path          (const gchar    *path);
692 FolderClass *folder_get_class_from_string       (const gchar    *str);
693 FolderItem *folder_find_child_item_by_name      (FolderItem     *item,
694                                                  const gchar    *name);
695 gchar      *folder_get_identifier               (Folder         *folder);
696 gchar      *folder_item_get_identifier          (FolderItem     *item);
697 FolderItem *folder_find_item_from_identifier    (const gchar    *identifier);
698 gchar      *folder_item_get_name                (FolderItem     *item);
699
700 Folder     *folder_get_default_folder   (void);
701 FolderItem *folder_get_default_inbox    (void);
702 FolderItem *folder_get_default_outbox   (void);
703 FolderItem *folder_get_default_draft    (void);
704 FolderItem *folder_get_default_queue    (void);
705 FolderItem *folder_get_default_trash    (void);
706 FolderItem *folder_get_default_processing (void);
707 void folder_set_missing_folders         (void);
708 void folder_unref_account_all           (PrefsAccount   *account);
709
710 gchar *folder_item_get_path             (FolderItem     *item);
711
712 gint   folder_item_open                 (FolderItem     *item);
713 gint   folder_item_close                (FolderItem     *item);
714 gint   folder_item_scan                 (FolderItem     *item);
715 void   folder_item_scan_foreach         (GHashTable     *table);
716 MsgInfo *folder_item_get_msginfo        (FolderItem     *item,
717                                          gint            num);
718 MsgInfo *folder_item_get_msginfo_by_msgid(FolderItem    *item,
719                                          const gchar    *msgid);
720 GSList *folder_item_get_msg_list        (FolderItem     *item);
721 gchar *folder_item_fetch_msg            (FolderItem     *item,
722                                          gint            num);
723 gint   folder_item_fetch_all_msg        (FolderItem     *item);
724 gint   folder_item_add_msg              (FolderItem     *dest,
725                                          const gchar    *file,
726                                          MsgFlags       *flags,
727                                          gboolean        remove_source);
728 gint   folder_item_add_msgs             (FolderItem     *dest,
729                                          GSList         *file_list,
730                                          gboolean        remove_source);
731 gint   folder_item_move_to              (FolderItem     *src,
732                                          FolderItem     *dest,
733                                          FolderItem    **new_item);
734 gint   folder_item_move_msg             (FolderItem     *dest,
735                                          MsgInfo        *msginfo);
736 gint   folder_item_move_msgs            (FolderItem     *dest,
737                                          GSList         *msglist);
738 gint   folder_item_copy_msg             (FolderItem     *dest,
739                                          MsgInfo        *msginfo);
740 gint   folder_item_copy_msgs            (FolderItem     *dest,
741                                          GSList         *msglist);
742 gint   folder_item_remove_msg           (FolderItem     *item,
743                                          gint            num);
744 gint   folder_item_remove_msgs          (FolderItem     *item,
745                                          GSList         *msglist);
746 gint   folder_item_remove_all_msg       (FolderItem     *item);
747 void    folder_item_change_msg_flags    (FolderItem     *item,
748                                          MsgInfo        *msginfo,
749                                          MsgPermFlags    newflags);
750 gboolean folder_item_is_msg_changed     (FolderItem     *item,
751                                          MsgInfo        *msginfo);
752 gchar *folder_item_get_cache_file       (FolderItem     *item);
753 gchar *folder_item_get_mark_file        (FolderItem     *item);
754 gchar * folder_item_get_identifier      (FolderItem * item);
755
756 GHashTable *folder_persist_prefs_new    (Folder *folder);
757 void folder_persist_prefs_free          (GHashTable *pptable);
758 const PersistPrefs *folder_get_persist_prefs
759                                         (GHashTable *pptable, const char *name);
760
761 void folder_item_restore_persist_prefs  (FolderItem *item, GHashTable *pptable);
762 void folder_clean_cache_memory          (void);
763 void folder_item_write_cache            (FolderItem *item);
764 void folder_item_set_default_flags      (FolderItem *dest, MsgFlags *flags);
765
766 void folder_item_apply_processing       (FolderItem *item);
767
768 void folder_item_update                 (FolderItem *item,
769                                          FolderItemUpdateFlags update_flags);
770 void folder_item_update_recursive       (FolderItem *item,
771                                          FolderItemUpdateFlags update_flags);
772 void folder_item_update_freeze          (void);
773 void folder_item_update_thaw            (void);
774
775 #endif /* __FOLDER_H__ */