2007-11-26 [colin] 3.1.0cvs30
[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-2007 Hiroyuki Yamamoto and the Claws Mail team
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 3 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, see <http://www.gnu.org/licenses/>.
19  * 
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         SORT_BY_TAGS,
85         SORT_BY_THREAD_DATE
86 } FolderSortKey;
87
88 typedef enum
89 {
90         SORT_ASCENDING,
91         SORT_DESCENDING
92 } FolderSortType;
93
94 typedef enum
95 {
96         F_MOVE_OK = 0,
97         F_MOVE_FAILED_DEST_IS_PARENT = -1,
98         F_MOVE_FAILED_DEST_IS_CHILD = -2,
99         F_MOVE_FAILED_DEST_OUTSIDE_MAILBOX = -3,
100         F_MOVE_FAILED = -4
101 } FolderItemMoveResult;
102
103 typedef enum
104 {
105         FOLDER_ADD_FOLDER               = 1 << 0,
106         FOLDER_REMOVE_FOLDER            = 1 << 1,
107         FOLDER_TREE_CHANGED             = 1 << 2,
108         FOLDER_ADD_FOLDERITEM           = 1 << 3,
109         FOLDER_REMOVE_FOLDERITEM        = 1 << 4,
110         FOLDER_RENAME_FOLDERITEM        = 1 << 5
111 } FolderUpdateFlags;
112
113 typedef enum
114 {
115         F_ITEM_UPDATE_MSGCNT = 1 << 0,
116         F_ITEM_UPDATE_CONTENT = 1 << 1,
117         F_ITEM_UPDATE_ADDMSG = 1 << 2,
118         F_ITEM_UPDATE_REMOVEMSG = 1 << 3,
119         F_ITEM_UPDATE_NAME = 1 << 4
120 } FolderItemUpdateFlags;
121
122 typedef void (*FolderUIFunc)            (Folder         *folder,
123                                          FolderItem     *item,
124                                          gpointer        data);
125 typedef void (*FolderDestroyNotify)     (Folder         *folder,
126                                          FolderItem     *item,
127                                          gpointer        data);
128 typedef void (*FolderItemFunc)  (FolderItem     *item,
129                                          gpointer        data);
130
131
132 #include "folder_item_prefs.h"
133
134 #include "procmsg.h"
135 #include "msgcache.h"
136 #include "xml.h"
137 #include "prefs_account.h"
138
139 struct _Folder
140 {
141         FolderClass *klass;
142
143         gchar *name;
144         PrefsAccount *account;
145         guint sort;
146
147         FolderItem *inbox;
148         FolderItem *outbox;
149         FolderItem *draft;
150         FolderItem *queue;
151         FolderItem *trash;
152
153         FolderUIFunc ui_func;
154         gpointer     ui_func_data;
155
156         GNode *node;
157
158         gpointer data;
159
160         GHashTable *newsart;
161 };
162
163 struct _FolderClass
164 {
165         /**
166          * A numeric identifier for the FolderClass. Will be removed in the future
167          */
168         FolderType  type;
169         /**
170          * A string identifier for the FolderClass. Currently used in folderlist.xml.
171          * Should be lowercase.
172          */
173         gchar      *idstr;
174         /**
175          * A string for the User Interface that identifies the FolderClass to the
176          * user. Can be upper and lowercase unlike the idstr.
177          */
178         gchar      *uistr;
179         
180         /* virtual functions */
181
182         /* Folder funtions */
183         /**
184          * Create a new \c Folder of this \c FolderClass.
185          *
186          * \param name The name of the new Folder
187          * \param path The path of the new Folder
188          * \return The new \c Folder, or \c NULL when creating the \c Folder 
189          *         failed
190          */
191         Folder          *(*new_folder)          (const gchar    *name,
192                                                  const gchar    *path);
193         /**
194          * Destroy a \c Folder of this \c FolderClass, frees all resources
195          * allocated by the Folder
196          *
197          * \param folder The \c Folder that should be destroyed.
198          */
199         void            (*destroy_folder)       (Folder         *folder);
200         /**
201          * Set the Folder's internal attributes from an \c XMLTag. Also sets the
202          * parameters of the root-FolderItem of the \c Folder. If \c NULL
203          * the default function of the basic \ยข FolderClass is used, so it
204          * must not be \c NULL if one of the parent \c FolderClasses has a \c set_xml
205          * function. In that case the parent \c FolderClass' \c set_xml function
206          * can be used or it has to be called with the \c folder and \c tag by
207          * the implementation.
208          *
209          * \param folder The \c Folder which's attributes should be updated
210          * \param tag The \c XMLTag containing the \c XMLAttrs for the attributes
211          */
212         void             (*set_xml)             (Folder         *folder,
213                                                  XMLTag         *tag);
214         /**
215          * Get an \c XMLTag for the attributes of the \c Folder and the root-FolderItem
216          * of the \c Folder. If \c NULL the default implementation for the basic
217          * FolderClass will be used, so it must not be \c NULL if one of the
218          * parent \c FolderClasses has it's own implementation for \c get_xml.
219          * In that case the parent FolderClass' \c get_xml function can be
220          * used or the \c XMLTag has to be fetched from the parent's \c get_xml
221          * function and then the \c FolderClass specific attributes can be
222          * added to it.
223          *
224          * \param Folder The \c Folder which's attributes should be set in the
225          *               \c XMLTag's \c XMLAttrs
226          * \return XMLTag An \c XMLTag with \c XMLAttrs containing the \c Folder's
227          *                attributes.
228          */
229         XMLTag          *(*get_xml)             (Folder         *folder);
230         /**
231          * Rebuild the folder tree from the folder's data
232          * \todo New implementations of MH and IMAP are actually syncronizing
233          *       the tree with the folder by reusing the old \c FolderItems.
234          *       Claws still destroys the old tree before calling this function.
235          *
236          * \param folder The folder which's tree should be rebuild
237          * \return 0 on success, a negative number otherwise
238          */
239         gint            (*scan_tree)            (Folder         *folder);
240
241         gint            (*create_tree)          (Folder         *folder);
242
243         /* FolderItem functions */
244         /**
245          * Create a new \c FolderItem structure for the \c FolderClass.
246          * \c FolderClasses can have their own \c FolderItem structure with
247          * extra attributes.
248          *
249          * \param folder The \c Folder for that a \c FolderItem should be
250          *               created
251          * \return The new \c FolderItem or NULL in case of an error
252          */
253         FolderItem      *(*item_new)            (Folder         *folder);
254         /**
255          * Destroy a \c FolderItem from this \c FolderClass. The \c FolderClass
256          * has to free all private resources used by the \c FolderItem.
257          *
258          * \param folder The \c Folder of the \c FolderItem
259          * \param item The \c FolderItem that should be destroyed
260          */
261         void             (*item_destroy)        (Folder         *folder,
262                                                  FolderItem     *item);
263         /**
264          * Set the \c FolderItem's internal attributes from an \c XMLTag. If
265          * \c NULL the default function of the basic \c FolderClass is used, so it
266          * must not be \c NULL if one of the parent \c FolderClasses has a \c item_set_xml
267          * function. In that case the parent \c FolderClass' \c item_set_xml function
268          * can be used or it has to be called with the \c folder, \c item and \c tag by
269          * the implementation.
270          *
271          * \param folder The \c Folder of the \c FolderItem
272          * \param item The \c FolderItems which's attributes should be set
273          * \param tag The \c XMLTag with \c XMLAttrs for the \c FolderItem's
274          *            attributes
275          */
276         void             (*item_set_xml)        (Folder         *folder,
277                                                  FolderItem     *item,
278                                                  XMLTag         *tag);
279         /**
280          * Get an \c XMLTag for the attributes of the \c FolderItem If \c NULL
281          * the default implementation for the basic \c FolderClass will be used,
282          * so it must not be \c NULL if one of the parent \c FolderClasses has
283          * it's own implementation for \c item_get_xml. In that case the parent 
284          * FolderClass' \c item_get_xml function can be used or the \c XMLTag
285          * has to be fetched from the parent's \c item_get_xml function and 
286          * then the \c FolderClass specific attributes can be added to it.
287          *
288          * \param folder The \c Folder of the \c FolderItem
289          * \parem item The \c FolderItem which's attributes should be set in
290          *             the \c XMLTag's \c XMLAttrs
291          * \return An \c XMLTag with \c XMLAttrs containing the \c FolderItem's
292          *         attributes.
293          */
294         XMLTag          *(*item_get_xml)        (Folder         *folder,
295                                                  FolderItem     *item);
296         /**
297          * Get a local path for the \c FolderItem where Sylpheed can save
298          * it's cache data. For local directory based folders this can be the
299          * real path. For other folders it can be the local cache directory.
300          *
301          * \param folder The \c Folder of the \c FolderItem
302          * \param item The \c FolderItem for that a path should be returned
303          * \return A path for the \c FolderItem
304          */
305         gchar           *(*item_get_path)       (Folder         *folder,
306                                                  FolderItem     *item);
307         /**
308          * Create a new \c FolderItem. The function must use folder_item_append
309          * to add the new \c FolderItem to the folder tree
310          *
311          * \param folder The \c Folder in which a new \c FolderItem should be
312          *               created
313          * \param parent \c The parent \c FolderItem for the new \c FolderItem
314          * \parem name The name for the new \c FolderItem
315          * \return The new \c FolderItem
316          */
317         FolderItem      *(*create_folder)       (Folder         *folder,
318                                                  FolderItem     *parent,
319                                                  const gchar    *name);
320         /**
321          * Rename a \c FolderItem
322          *
323          * \param folder The \c Folder of the \c FolderItem that should be
324          *               renamed
325          * \param item The \c FolderItem that should be renamed
326          * \param name The new name of the \c FolderItem
327          * \return 0 on success, a negative number otherwise
328          */
329         gint             (*rename_folder)       (Folder         *folder,
330                                                  FolderItem     *item,
331                                                  const gchar    *name);
332         /**
333          * Remove a \c FolderItem from the \c Folder
334          *
335          * \param folder The \c Folder that contains the \c FolderItem
336          * \param item The \c FolderItem that should be removed
337          * \return 0 on sucess, a negative number otherwise
338          */
339         gint             (*remove_folder)       (Folder         *folder,
340                                                  FolderItem     *item);
341         /**
342          * Close a \c FolderItem. Called when the user deselects a
343          * \c FolderItem.
344          * 
345          * \attention In Sylpheed-Main operations can only be done on the
346          *            \c FolderItem that is opened in the SummaryView. This
347          *            \c FolderItem will be closed when you select a new
348          *            \c FolderItem in the FolderView. In Claws operations can
349          *            be done any time on any folder and you should not expect
350          *            that all \c FolderItems get closed after operations
351          *
352          * \param folder The \c Folder that contains the \c FolderItem
353          * \param item The \c FolderItem that should be closed
354          * \return 0 on success, a negative number otherwise
355          */
356         gint             (*close)               (Folder         *folder,
357                                                  FolderItem     *item);
358         /**
359          * Get the list of message numbers for the messages in the \c FolderItem
360          *
361          * \param folder The \c Folder that contains the \c FolderItem
362          * \param item The \c FolderItem for which the message numbers should
363          *             be fetched
364          * \param list Pointer to a GSList where message numbers have to be
365          *             added. Because of the implementation of the GSList that
366          *             changes the pointer of the GSList itself when the first
367          *             item is added this is a pointer to a pointer to a
368          *             GSList structure. Use *item = g_slist_...(*item, ...)
369          *             operations to modify the list.
370          * \param old_uids_valid In some \c Folders the old UIDs can be invalid.
371          *                       Set this pointer to a gboolean to TRUE if the
372          *                       old UIDs are still valid, otherwise set it to
373          *                       FALSE and the folder system will discard it's
374          *                       cache data of the previously know UIDs
375          * \return The number of message numbers add to the list on success,
376          *         a negative number otherwise.
377          */
378         gint             (*get_num_list)        (Folder         *folder,
379                                                  FolderItem     *item,
380                                                  GSList        **list,
381                                                  gboolean       *old_uids_valid);
382         /**
383          * Tell the folder system if a \c FolderItem should be scanned
384          * (cache data syncronized with the folder content) when it is required
385          * because the \c FolderItem's content changed. If NULL the folder
386          * system will not do automatic scanning of \c FolderItems
387          *
388          * \param folder The \c Folder that contains the \c FolderItem
389          * \param item The \c FolderItem which's content should be checked
390          * \return TRUE if the \c FolderItem should be scanned, FALSE otherwise
391          */
392         gboolean        (*scan_required)        (Folder         *folder,
393                                                  FolderItem     *item);
394
395         /**
396          * Updates the known mtime of a folder
397          */
398         void            (*set_mtime)            (Folder         *folder,
399                                                  FolderItem     *item);
400
401         /* Message functions */
402         /**
403          * Get a MsgInfo for a message in a \c FolderItem
404          *
405          * \param folder The \c Folder containing the message
406          * \param item The \c FolderItem containing the message
407          * \param num The message number of the message
408          * \return A pointer to a \c MsgInfo decribing the message or \c 
409          *         NULL in case of an error
410          */
411         MsgInfo         *(*get_msginfo)         (Folder         *folder,
412                                                  FolderItem     *item,
413                                                  gint            num);
414         /**
415          * Get \c MsgInfos for a list of message numbers
416          *
417          * \param folder The \c Folder containing the message
418          * \param item The \c FolderItem containing the message
419          * \param msgnum_list A list of message numbers for which the
420          *                    \c MsgInfos should be fetched
421          * \return A list of \c MsgInfos for the messages in the \c msgnum_list
422          *         that really exist. Messages that are not found can simply
423          *         be left out.
424          */
425         MsgInfoList     *(*get_msginfos)        (Folder         *folder,
426                                                  FolderItem     *item,
427                                                  MsgNumberList  *msgnum_list);
428         /**
429          * Get the filename for a message. This can either be the real message
430          * file for local folders or a temporary file for remote folders.
431          *
432          * \param folder The \c Folder containing the message
433          * \param item The \c FolderItem containing the message
434          * \param num The message number of the message
435          * \return A string with the filename of the message file. The returned
436          *         string has to be freed with \c g_free(). If message is not
437          *         available return NULL.
438          */
439         gchar           *(*fetch_msg)           (Folder         *folder,
440                                                  FolderItem     *item,
441                                                  gint            num);
442         gchar           *(*fetch_msg_full)      (Folder         *folder,
443                                                  FolderItem     *item,
444                                                  gint            num,
445                                                  gboolean        headers,
446                                                  gboolean        body);
447         /**
448          * Add a single message file to a folder with the given flags (if
449          * flag handling is supported by the folder)
450          *
451          * \param folder The target \c Folder for the message
452          * \param dest the target \c FolderItem for the message
453          * \param file The file that contains the message
454          * \param flags The flags the new message should have in the folder
455          * \return 0 on success, a negative number otherwise
456          */
457         gint            (*add_msg)              (Folder         *folder,
458                                                  FolderItem     *dest,
459                                                  const gchar    *file,
460                                                  MsgFlags       *flags);
461         /**
462          * Add multiple messages to a \c FolderItem. If NULL the folder
463          * system will add messages with \c add_msg one by one
464          *
465          * \param folder The target \c Folder for the messages
466          * \param dest the target \c FolderItem for the messages
467          * \param file_list A list of \c MsgFileInfos which contain the
468          *                  filenames and flags for the new messages
469          * \param relation Insert tuples of (MsgFileInfo, new message number) to
470          *                 provide feedback for the folder system which new
471          *                 message number a \c MsgFileInfo got in dest. Insert
472          *                 0 if the new message number is unknown.
473          */
474         gint            (*add_msgs)             (Folder         *folder,
475                                                  FolderItem     *dest,
476                                                  GSList         *file_list,
477                                                  GRelation      *relation);
478         /**
479          * Copy a message to a FolderItem
480          *
481          * \param folder The \c Folder of the destination FolderItem
482          * \param dest The destination \c FolderItem for the message
483          * \param msginfo The message that should be copied
484          * \return The message number the copied message got, 0 if it is
485          *         unknown because message numbers are assigned by an external
486          *         system and not available after copying or a negative number
487          *         if an error occuried
488          */
489         gint            (*copy_msg)             (Folder         *folder,
490                                                  FolderItem     *dest,
491                                                  MsgInfo        *msginfo);
492         /**
493          * Copy multiple messages to a \c FolderItem. If \c NULL the folder
494          * system will use \c copy_msg to copy messages one by one.
495          *
496          * \param folder The \c Folder of the destination FolderItem
497          * \param dest The destination \c FolderItem for the message
498          * \param msglist A list of \c MsgInfos which should be copied to dest
499          * \param relation Insert tuples of (MsgInfo, new message number) to
500          *                 provide feedback for the folder system which new
501          *                 message number a \c MsgInfo got in dest. Insert
502          *                 0 if the new message number is unknown.
503          * \return 0 on success, a negative number otherwise
504          */
505         gint            (*copy_msgs)            (Folder         *folder,
506                                                  FolderItem     *dest,
507                                                  MsgInfoList    *msglist,
508                                                  GRelation      *relation);
509         /**
510          * Remove a message from a \c FolderItem.
511          *
512          * \param folder The \c Folder of the message
513          * \param item The \c FolderItem containing the message
514          * \param num The message number of the message
515          * \return 0 on success, a negative number otherwise
516          */
517         gint            (*remove_msg)           (Folder         *folder,
518                                                  FolderItem     *item,
519                                                  gint            num);
520         gint            (*remove_msgs)          (Folder         *folder,
521                                                  FolderItem     *item,
522                                                  MsgInfoList    *msglist,
523                                                  GRelation      *relation);
524         /**
525          * Remove all messages in a \ c FolderItem
526          *
527          * \param folder The \c Folder of the \c FolderItem
528          * \param item The \FolderItem which's messages should be deleted
529          * \return 0 on succes, a negative number otherwise
530          */
531         gint            (*remove_all_msg)       (Folder         *folder,
532                                                  FolderItem     *item);
533         /**
534          * Check if a message has been modified by someone else
535          *
536          * \param folder The \c Folder of the message
537          * \param item The \c FolderItem containing the message
538          * \param msginfo The \c MsgInfo for the message that should be checked
539          * \return \c TRUE if the message was modified, \c FALSE otherwise
540          */
541         gboolean        (*is_msg_changed)       (Folder         *folder,
542                                                  FolderItem     *item,
543                                                  MsgInfo        *msginfo);
544         /**
545          * Update a message's flags in the folder data. If NULL only the
546          * internal flag management will be used. The function has to set
547          * \c msginfo->flags.perm_flags. It does not have to set the flags
548          * that it got as \c newflags. If a flag can not be set in this
549          * \c FolderClass the function can refuse to set it. Flags that are not
550          * supported by the \c FolderClass should not be refused. They will be
551          * managed by the internal cache in this case.
552          *
553          * \param folder The \c Folder of the message
554          * \param item The \c FolderItem of the message
555          * \param msginfo The \c MsgInfo for the message which's flags should be
556          *                updated
557          * \param newflags The flags the message should get
558          */
559         void            (*change_flags)         (Folder         *folder,
560                                                  FolderItem     *item,
561                                                  MsgInfo        *msginfo,
562                                                  MsgPermFlags    newflags);
563         /**
564          * Get the flags for a list of messages. Flags that are not supported
565          * by the folder should be preserved. They can be copied from
566          * \c msginfo->flags.perm_flags
567          *
568          * \param folder The \c Folder of the messages
569          * \param item The \c FolderItem of the messages
570          * \param msglist The list of \c MsgInfos for which the flags should
571          *                   be returned
572          * \param msgflags A \c GRelation for tuples of (MsgInfo, new permanent
573          *        flags for MsgInfo). Add tuples for the messages in msglist
574          * \return 0 on success, a negative number otherwise
575          */
576         gint            (*get_flags)            (Folder         *folder,
577                                                  FolderItem     *item,
578                                                  MsgInfoList    *msglist,
579                                                  GRelation      *msgflags);
580         
581         /* Sets batch mode for a FolderItem. It means that numerous flags updates
582          * could follow, and the FolderClass implementation can cache them in order
583          * to process them later when set_false will be called again with the
584          * batch parameter set to FALSE. 
585          */
586         void            (*set_batch)            (Folder         *folder,
587                                                  FolderItem     *item,
588                                                  gboolean        batch);
589         /* Called when switching offline or asking for synchronisation. the imple
590          * mentation should do what's necessary to be able to read mails present
591          * in the FolderItem at this time with no network connectivity. 
592          * Days: max number of days of mail to fetch.
593          */
594         void            (*synchronise)          (FolderItem     *item,
595                                                  gint            days);
596         
597         /* Passed from claws-mail --subscribe scheme://uri. Implementations
598          * should check if they handle this type of URI, and return TRUE in this
599          * case after having subscribed it.
600          */
601         gboolean        (*subscribe)            (Folder         *folder,
602                                                  const gchar    *uri);
603         
604         /* Gets the preferred sort key and type for a folderclass. */
605         void            (*get_sort_type)        (Folder         *folder,
606                                                  FolderSortKey  *sort_key,
607                                                  FolderSortType *sort_type);
608         
609         /* Copies internal FolderItem data from one folderItem to another. Used
610          * when moving folders (this move is in reality a folder creation, content
611          * move, folder delettion).
612          */
613         void            (*copy_private_data)    (Folder         *folder,
614                                                  FolderItem     *src,
615                                                  FolderItem     *dest);
616
617         void            (*remove_cached_msg)    (Folder         *folder,
618                                                  FolderItem     *item,
619                                                  MsgInfo        *msginfo);
620         void            (*commit_tags)          (FolderItem     *item,
621                                                  MsgInfo        *msginfo,
622                                                  GSList         *tags_set,
623                                                  GSList         *tags_unset);
624 };
625
626 struct _FolderItem
627 {
628         SpecialFolderItemType stype;
629
630         gchar *name; /* UTF-8 */
631         gchar *path; /* UTF-8 */
632
633         time_t mtime;
634
635         gint new_msgs;
636         gint unread_msgs;
637         gint total_msgs;
638         gint unreadmarked_msgs;
639         gint marked_msgs;
640
641         gint order;
642
643         gint last_num;
644
645         MsgCache *cache;
646
647         /* special flags */
648         guint no_sub         : 1; /* no child allowed?    */
649         guint no_select      : 1; /* not selectable?      */
650         guint collapsed      : 1; /* collapsed item       */
651         guint thread_collapsed      : 1; /* collapsed item       */
652         guint threaded       : 1; /* threaded folder view */
653         guint hide_read_msgs : 1; /* hide read messages   */
654         guint ret_rcpt       : 1; /* return receipt       */
655         guint search_match   : 1;
656
657         gint op_count;
658         guint opened         : 1; /* opened by summary view */
659         FolderItemUpdateFlags update_flags; /* folderview for this folder should be updated */
660
661         FolderSortKey sort_key;
662         FolderSortType sort_type;
663
664         GNode *node;
665
666         Folder *folder;
667
668         PrefsAccount *account;
669
670         gboolean apply_sub;
671         
672         GSList *mark_queue;
673
674         gpointer data;
675
676         FolderItemPrefs * prefs;
677         
678         /* for faster search of special parents */
679         SpecialFolderItemType parent_stype;
680         gboolean processing_pending;
681         gboolean scanning;
682         guint last_seen;
683 };
684
685 struct _PersistPrefs
686 {
687         FolderSortKey   sort_key;
688         FolderSortType  sort_type;
689         guint           collapsed       : 1;
690         guint           thread_collapsed        : 1;
691         guint           threaded        : 1;
692         guint           hide_read_msgs  : 1; /* CLAWS */
693         guint           ret_rcpt        : 1; /* CLAWS */
694 };
695
696 struct _FolderUpdateData
697 {
698         Folder                  *folder;
699         FolderUpdateFlags        update_flags;
700         FolderItem              *item;
701 };
702
703 struct _FolderItemUpdateData
704 {
705         FolderItem              *item;
706         FolderItemUpdateFlags    update_flags;
707         MsgInfo                 *msg;
708 };
709
710 void        folder_system_init          (void);
711 void        folder_register_class       (FolderClass    *klass);
712 void        folder_unregister_class     (FolderClass    *klass);
713 Folder     *folder_new                  (FolderClass    *type,
714                                          const gchar    *name,
715                                          const gchar    *path);
716 void        folder_init                 (Folder         *folder,
717                                          const gchar    *name);
718
719 void        folder_destroy              (Folder         *folder);
720
721 void        folder_set_xml              (Folder          *folder,
722                                          XMLTag          *tag);
723 XMLTag     *folder_get_xml              (Folder          *folder);
724
725 FolderItem *folder_item_new             (Folder         *folder,
726                                          const gchar    *name,
727                                          const gchar    *path);
728 void        folder_item_append          (FolderItem     *parent,
729                                          FolderItem     *item);
730 void        folder_item_remove          (FolderItem     *item);
731 void        folder_item_remove_children (FolderItem     *item);
732 void        folder_item_destroy         (FolderItem     *item);
733 FolderItem *folder_item_parent          (FolderItem     *item);
734
735 void        folder_item_set_xml         (Folder          *folder,
736                                          FolderItem      *item,
737                                          XMLTag          *tag);
738 XMLTag     *folder_item_get_xml         (Folder          *folder,
739                                          FolderItem      *item);
740
741 void        folder_set_ui_func  (Folder         *folder,
742                                  FolderUIFunc    func,
743                                  gpointer        data);
744 void        folder_set_name     (Folder         *folder,
745                                  const gchar    *name);
746 void        folder_set_sort     (Folder         *folder,
747                                  guint           sort);
748 void        folder_tree_destroy (Folder         *folder);
749
750 void   folder_add               (Folder         *folder);
751 void   folder_remove            (Folder         *folder);
752
753 GList *folder_get_list          (void);
754 gint   folder_read_list         (void);
755 void   folder_write_list        (void);
756 void   folder_scan_tree         (Folder *folder, gboolean rebuild);
757 void   folder_fast_scan_tree    (Folder *folder);
758 FolderItem *folder_create_folder(FolderItem     *parent, const gchar *name);
759 gint   folder_item_rename       (FolderItem *item, gchar *newname);
760 void   folder_update_op_count           (void);
761 void   folder_func_to_all_folders       (FolderItemFunc function,
762                                          gpointer data);
763 void folder_count_total_msgs(guint *new_msgs, guint *unread_msgs, 
764                              guint *unreadmarked_msgs, guint *marked_msgs,
765                              guint *total_msgs);
766 gchar *folder_get_status        (GPtrArray      *folders,
767                                  gboolean        full);
768
769 Folder     *folder_find_from_path               (const gchar    *path);
770 Folder     *folder_find_from_name               (const gchar    *name,
771                                                  FolderClass    *klass);
772 FolderItem *folder_find_item_from_path          (const gchar    *path);
773 FolderClass *folder_get_class_from_string       (const gchar    *str);
774 FolderItem *folder_find_child_item_by_name      (FolderItem     *item,
775                                                  const gchar    *name);
776 gchar      *folder_item_get_identifier          (FolderItem     *item);
777 FolderItem *folder_find_item_from_identifier    (const gchar    *identifier);
778 gchar      *folder_item_get_name                (FolderItem     *item);
779
780 FolderItem *folder_get_default_inbox    (void);
781 FolderItem *folder_get_default_inbox_for_class(FolderType type);
782 FolderItem *folder_get_default_outbox   (void);
783 FolderItem *folder_get_default_outbox_for_class(FolderType type);
784 FolderItem *folder_get_default_draft    (void);
785 FolderItem *folder_get_default_draft_for_class(FolderType type);
786 FolderItem *folder_get_default_queue    (void);
787 FolderItem *folder_get_default_queue_for_class(FolderType type);
788 FolderItem *folder_get_default_trash    (void);
789 FolderItem *folder_get_default_trash_for_class(FolderType type);
790 FolderItem *folder_get_default_processing (void);
791 void folder_set_missing_folders         (void);
792 void folder_unref_account_all           (PrefsAccount   *account);
793
794 /* return value is locale encoded file name */
795 gchar *folder_item_get_path             (FolderItem     *item);
796
797 gint   folder_item_open                 (FolderItem     *item);
798 gint   folder_item_close                (FolderItem     *item);
799 gint   folder_item_scan                 (FolderItem     *item);
800 gint   folder_item_scan_full            (FolderItem     *item, 
801                                          gboolean        filtering);
802 MsgInfo *folder_item_get_msginfo        (FolderItem     *item,
803                                          gint            num);
804 MsgInfo *folder_item_get_msginfo_by_msgid(FolderItem    *item,
805                                          const gchar    *msgid);
806 GSList *folder_item_get_msg_list        (FolderItem     *item);
807 /* return value is locale charset */
808 gchar *folder_item_fetch_msg            (FolderItem     *item,
809                                          gint            num);
810 gchar *folder_item_fetch_msg_full       (FolderItem     *item,
811                                          gint            num, 
812                                          gboolean        get_headers,
813                                          gboolean        get_body);
814 gint   folder_item_add_msg              (FolderItem     *dest,
815                                          const gchar    *file,
816                                          MsgFlags       *flags,
817                                          gboolean        remove_source);
818 gint   folder_item_add_msgs             (FolderItem     *dest,
819                                          GSList         *file_list,
820                                          gboolean        remove_source);
821 gint   folder_item_move_to              (FolderItem     *src,
822                                          FolderItem     *dest,
823                                          FolderItem    **new_item,
824                                          gboolean        copy);
825 gint   folder_item_move_msg             (FolderItem     *dest,
826                                          MsgInfo        *msginfo);
827 gint   folder_item_move_msgs            (FolderItem     *dest,
828                                          GSList         *msglist);
829 gint   folder_item_copy_msg             (FolderItem     *dest,
830                                          MsgInfo        *msginfo);
831 gint   folder_item_copy_msgs            (FolderItem     *dest,
832                                          GSList         *msglist);
833 gint   folder_item_remove_msg           (FolderItem     *item,
834                                          gint            num);
835 gint   folder_item_remove_msgs          (FolderItem     *item,
836                                          GSList         *msglist);
837 gint   folder_item_remove_all_msg       (FolderItem     *item);
838 void    folder_item_change_msg_flags    (FolderItem     *item,
839                                          MsgInfo        *msginfo,
840                                          MsgPermFlags    newflags);
841 gboolean folder_item_is_msg_changed     (FolderItem     *item,
842                                          MsgInfo        *msginfo);
843 /* return value is locale chaset */
844 gchar * folder_item_get_identifier      (FolderItem * item);
845
846 void folder_clean_cache_memory          (FolderItem *protected_item);
847 void folder_clean_cache_memory_force    (void);
848 void folder_item_write_cache            (FolderItem *item);
849
850 void folder_item_apply_processing       (FolderItem *item);
851
852 void folder_item_update                 (FolderItem *item,
853                                          FolderItemUpdateFlags update_flags);
854 void folder_item_update_recursive       (FolderItem *item,
855                                          FolderItemUpdateFlags update_flags);
856 void folder_item_update_freeze          (void);
857 void folder_item_update_thaw            (void);
858 void folder_item_set_batch              (FolderItem *item, gboolean batch);
859 gboolean folder_has_parent_of_type      (FolderItem *item, SpecialFolderItemType type);
860 void folder_synchronise                 (Folder *folder);
861 gboolean folder_want_synchronise        (Folder *folder);
862 gboolean folder_subscribe               (const gchar *uri);
863 gboolean folder_have_mailbox            (void);
864 gboolean folder_item_free_cache         (FolderItem *item, gboolean force);
865 void folder_item_change_type            (FolderItem *item,
866                                          SpecialFolderItemType newtype);
867 gboolean folder_get_sort_type           (Folder         *folder,
868                                          FolderSortKey  *sort_key,
869                                          FolderSortType *sort_type);
870 void folder_item_synchronise            (FolderItem *item);
871 void folder_item_discard_cache          (FolderItem *item);
872 void folder_item_commit_tags(FolderItem *item, MsgInfo *msginfo, GSList *tags_set, GSList *tags_unset);
873
874 #endif /* __FOLDER_H__ */