e60b401296
* matcher.c * procmsg.c * procmsg.h Add a way to fetch only headers. This speeds up filtering on headers for IMAP. Fixes: bug #481 extraneous imap commands slow down imap filtering bug #522 Sylpheed downloads all messages when opening mailbox (IMAP) bug #677 IMAP fetch is soooooooooooooo slow * src/folder.c * src/folder.h Add a folder set_batch method so that implementations can speed up flags changes * src/folderutils.c * src/summaryview.c Use that in mark as (un)read and mark all read Refix bug #679 * src/imap.c Implement set_batch - brings back deferred flags in a less buggy manner. Fixes: bug #729 IMAP immediate expunge of deleted messages bug #191 remove list of messages with one command Fix login with strange chars Implement fetch_msg_full Fix copy (wrong counts)
806 lines
27 KiB
C
806 lines
27 KiB
C
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
|
|
|
|
/*
|
|
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
|
|
* Copyright (C) 1999-2003 Hiroyuki Yamamoto
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#ifndef __FOLDER_H__
|
|
#define __FOLDER_H__
|
|
|
|
#include <glib.h>
|
|
#include <time.h>
|
|
|
|
typedef struct _Folder Folder;
|
|
typedef struct _FolderClass FolderClass;
|
|
|
|
typedef struct _FolderItem FolderItem;
|
|
typedef struct _FolderUpdateData FolderUpdateData;
|
|
typedef struct _FolderItemUpdateData FolderItemUpdateData;
|
|
typedef struct _PersistPrefs PersistPrefs;
|
|
|
|
#define FOLDER(obj) ((Folder *)obj)
|
|
#define FOLDER_CLASS(obj) (FOLDER(obj)->klass)
|
|
#define FOLDER_TYPE(obj) (FOLDER(obj)->klass->type)
|
|
|
|
#define FOLDER_IS_LOCAL(obj) (FOLDER_TYPE(obj) == F_MH || \
|
|
FOLDER_TYPE(obj) == F_MBOX || \
|
|
FOLDER_TYPE(obj) == F_MAILDIR)
|
|
|
|
#define FOLDER_ITEM(obj) ((FolderItem *)obj)
|
|
|
|
#define FOLDER_UPDATE_HOOKLIST "folder_update"
|
|
#define FOLDER_ITEM_UPDATE_HOOKLIST "folder_item_update"
|
|
|
|
typedef enum
|
|
{
|
|
F_MH,
|
|
F_MBOX,
|
|
F_MAILDIR,
|
|
F_IMAP,
|
|
F_NEWS,
|
|
F_UNKNOWN
|
|
} FolderType;
|
|
|
|
typedef enum
|
|
{
|
|
F_NORMAL,
|
|
F_INBOX,
|
|
F_OUTBOX,
|
|
F_DRAFT,
|
|
F_QUEUE,
|
|
F_TRASH
|
|
} SpecialFolderItemType;
|
|
|
|
typedef enum
|
|
{
|
|
SORT_BY_NONE,
|
|
SORT_BY_NUMBER,
|
|
SORT_BY_SIZE,
|
|
SORT_BY_DATE,
|
|
SORT_BY_FROM,
|
|
SORT_BY_SUBJECT,
|
|
SORT_BY_SCORE,
|
|
SORT_BY_LABEL,
|
|
SORT_BY_MARK,
|
|
SORT_BY_STATUS,
|
|
SORT_BY_MIME,
|
|
SORT_BY_TO,
|
|
SORT_BY_LOCKED
|
|
} FolderSortKey;
|
|
|
|
typedef enum
|
|
{
|
|
SORT_ASCENDING,
|
|
SORT_DESCENDING
|
|
} FolderSortType;
|
|
|
|
typedef enum
|
|
{
|
|
F_MOVE_OK = 0,
|
|
F_MOVE_FAILED_DEST_IS_PARENT = -1,
|
|
F_MOVE_FAILED_DEST_IS_CHILD = -2,
|
|
F_MOVE_FAILED_DEST_OUTSIDE_MAILBOX = -3,
|
|
F_MOVE_FAILED = -4,
|
|
} FolderItemMoveResult;
|
|
|
|
typedef enum
|
|
{
|
|
FOLDER_ADD_FOLDER = 1 << 0,
|
|
FOLDER_REMOVE_FOLDER = 1 << 1,
|
|
FOLDER_TREE_CHANGED = 1 << 2,
|
|
FOLDER_ADD_FOLDERITEM = 1 << 3,
|
|
FOLDER_REMOVE_FOLDERITEM = 1 << 4,
|
|
} FolderUpdateFlags;
|
|
|
|
typedef enum
|
|
{
|
|
F_ITEM_UPDATE_MSGCNT = 1 << 0,
|
|
F_ITEM_UPDATE_CONTENT = 1 << 1,
|
|
F_ITEM_UPDATE_ADDMSG = 1 << 2,
|
|
F_ITEM_UPDATE_REMOVEMSG = 1 << 3,
|
|
F_ITEM_UPDATE_NAME = 1 << 4,
|
|
} FolderItemUpdateFlags;
|
|
|
|
typedef void (*FolderUIFunc) (Folder *folder,
|
|
FolderItem *item,
|
|
gpointer data);
|
|
typedef void (*FolderDestroyNotify) (Folder *folder,
|
|
FolderItem *item,
|
|
gpointer data);
|
|
typedef void (*FolderItemFunc) (FolderItem *item,
|
|
gpointer data);
|
|
|
|
|
|
#include "folder_item_prefs.h"
|
|
|
|
#include "procmsg.h"
|
|
#include "msgcache.h"
|
|
#include "xml.h"
|
|
#include "prefs_account.h"
|
|
|
|
struct _Folder
|
|
{
|
|
FolderClass *klass;
|
|
|
|
gchar *name;
|
|
PrefsAccount *account;
|
|
guint sort;
|
|
|
|
FolderItem *inbox;
|
|
FolderItem *outbox;
|
|
FolderItem *draft;
|
|
FolderItem *queue;
|
|
FolderItem *trash;
|
|
|
|
FolderUIFunc ui_func;
|
|
gpointer ui_func_data;
|
|
|
|
GNode *node;
|
|
|
|
gpointer data;
|
|
|
|
GHashTable *newsart;
|
|
};
|
|
|
|
struct _FolderClass
|
|
{
|
|
/**
|
|
* A numeric identifier for the FolderClass. Will be removed in the future
|
|
*/
|
|
FolderType type;
|
|
/**
|
|
* A string identifier for the FolderClass. Currently used in folderlist.xml.
|
|
* Should be lowercase.
|
|
*/
|
|
gchar *idstr;
|
|
/**
|
|
* A string for the User Interface that identifies the FolderClass to the
|
|
* user. Can be upper and lowercase unlike the idstr.
|
|
*/
|
|
gchar *uistr;
|
|
|
|
/* virtual functions */
|
|
|
|
/* Folder funtions */
|
|
/**
|
|
* Create a new \c Folder of this \c FolderClass.
|
|
*
|
|
* \param name The name of the new Folder
|
|
* \param path The path of the new Folder
|
|
* \return The new \c Folder, or \c NULL when creating the \c Folder
|
|
* failed
|
|
*/
|
|
Folder *(*new_folder) (const gchar *name,
|
|
const gchar *path);
|
|
/**
|
|
* Destroy a \c Folder of this \c FolderClass, frees all resources
|
|
* allocated by the Folder
|
|
*
|
|
* \param folder The \c Folder that should be destroyed.
|
|
*/
|
|
void (*destroy_folder) (Folder *folder);
|
|
/**
|
|
* Set the Folder's internal attributes from an \c XMLTag. Also sets the
|
|
* parameters of the root-FolderItem of the \c Folder. If \c NULL
|
|
* the default function of the basic \¢ FolderClass is used, so it
|
|
* must not be \c NULL if one of the parent \c FolderClasses has a \c set_xml
|
|
* function. In that case the parent \c FolderClass' \c set_xml function
|
|
* can be used or it has to be called with the \c folder and \c tag by
|
|
* the implementation.
|
|
*
|
|
* \param folder The \c Folder which's attributes should be updated
|
|
* \param tag The \c XMLTag containing the \c XMLAttrs for the attributes
|
|
*/
|
|
void (*set_xml) (Folder *folder,
|
|
XMLTag *tag);
|
|
/**
|
|
* Get an \c XMLTag for the attributes of the \c Folder and the root-FolderItem
|
|
* of the \c Folder. If \c NULL the default implementation for the basic
|
|
* FolderClass will be used, so it must not be \c NULL if one of the
|
|
* parent \c FolderClasses has it's own implementation for \c get_xml.
|
|
* In that case the parent FolderClass' \c get_xml function can be
|
|
* used or the \c XMLTag has to be fetched from the parent's \c get_xml
|
|
* function and then the \c FolderClass specific attributes can be
|
|
* added to it.
|
|
*
|
|
* \param Folder The \c Folder which's attributes should be set in the
|
|
* \c XMLTag's \c XMLAttrs
|
|
* \return XMLTag An \c XMLTag with \c XMLAttrs containing the \c Folder's
|
|
* attributes.
|
|
*/
|
|
XMLTag *(*get_xml) (Folder *folder);
|
|
/**
|
|
* Rebuild the folder tree from the folder's data
|
|
* \todo New implementations of MH and IMAP are actually syncronizing
|
|
* the tree with the folder by reusing the old \c FolderItems.
|
|
* Claws still destroys the old tree before calling this function.
|
|
*
|
|
* \param folder The folder which's tree should be rebuild
|
|
* \return 0 on success, a negative number otherwise
|
|
*/
|
|
gint (*scan_tree) (Folder *folder);
|
|
|
|
gint (*create_tree) (Folder *folder);
|
|
|
|
/* FolderItem functions */
|
|
/**
|
|
* Create a new \c FolderItem structure for the \c FolderClass.
|
|
* \c FolderClasses can have their own \c FolderItem structure with
|
|
* extra attributes.
|
|
*
|
|
* \param folder The \c Folder for that a \c FolderItem should be
|
|
* created
|
|
* \return The new \c FolderItem or NULL in case of an error
|
|
*/
|
|
FolderItem *(*item_new) (Folder *folder);
|
|
/**
|
|
* Destroy a \c FolderItem from this \c FolderClass. The \c FolderClass
|
|
* has to free all private resources used by the \c FolderItem.
|
|
*
|
|
* \param folder The \c Folder of the \c FolderItem
|
|
* \param item The \c FolderItem that should be destroyed
|
|
*/
|
|
void (*item_destroy) (Folder *folder,
|
|
FolderItem *item);
|
|
/**
|
|
* Set the \c FolderItem's internal attributes from an \c XMLTag. If
|
|
* \c NULL the default function of the basic \c FolderClass is used, so it
|
|
* must not be \c NULL if one of the parent \c FolderClasses has a \c item_set_xml
|
|
* function. In that case the parent \c FolderClass' \c item_set_xml function
|
|
* can be used or it has to be called with the \c folder, \c item and \c tag by
|
|
* the implementation.
|
|
*
|
|
* \param folder The \c Folder of the \c FolderItem
|
|
* \param item The \c FolderItems which's attributes should be set
|
|
* \param tag The \c XMLTag with \c XMLAttrs for the \c FolderItem's
|
|
* attributes
|
|
*/
|
|
void (*item_set_xml) (Folder *folder,
|
|
FolderItem *item,
|
|
XMLTag *tag);
|
|
/**
|
|
* Get an \c XMLTag for the attributes of the \c FolderItem If \c NULL
|
|
* the default implementation for the basic \c FolderClass will be used,
|
|
* so it must not be \c NULL if one of the parent \c FolderClasses has
|
|
* it's own implementation for \c item_get_xml. In that case the parent
|
|
* FolderClass' \c item_get_xml function can be used or the \c XMLTag
|
|
* has to be fetched from the parent's \c item_get_xml function and
|
|
* then the \c FolderClass specific attributes can be added to it.
|
|
*
|
|
* \param folder The \c Folder of the \c FolderItem
|
|
* \parem item The \c FolderItem which's attributes should be set in
|
|
* the \c XMLTag's \c XMLAttrs
|
|
* \return An \c XMLTag with \c XMLAttrs containing the \c FolderItem's
|
|
* attributes.
|
|
*/
|
|
XMLTag *(*item_get_xml) (Folder *folder,
|
|
FolderItem *item);
|
|
/**
|
|
* Get a local path for the \c FolderItem where Sylpheed can save
|
|
* it's cache data. For local directory based folders this can be the
|
|
* real path. For other folders it can be the local cache directory.
|
|
*
|
|
* \param folder The \c Folder of the \c FolderItem
|
|
* \param item The \c FolderItem for that a path should be returned
|
|
* \return A path for the \c FolderItem
|
|
*/
|
|
gchar *(*item_get_path) (Folder *folder,
|
|
FolderItem *item);
|
|
/**
|
|
* Create a new \c FolderItem. The function must use folder_item_append
|
|
* to add the new \c FolderItem to the folder tree
|
|
*
|
|
* \param folder The \c Folder in which a new \c FolderItem should be
|
|
* created
|
|
* \param parent \c The parent \c FolderItem for the new \c FolderItem
|
|
* \parem name The name for the new \c FolderItem
|
|
* \return The new \c FolderItem
|
|
*/
|
|
FolderItem *(*create_folder) (Folder *folder,
|
|
FolderItem *parent,
|
|
const gchar *name);
|
|
/**
|
|
* Rename a \c FolderItem
|
|
*
|
|
* \param folder The \c Folder of the \c FolderItem that should be
|
|
* renamed
|
|
* \param item The \c FolderItem that should be renamed
|
|
* \param name The new name of the \c FolderItem
|
|
* \return 0 on success, a negative number otherwise
|
|
*/
|
|
gint (*rename_folder) (Folder *folder,
|
|
FolderItem *item,
|
|
const gchar *name);
|
|
/**
|
|
* Remove a \c FolderItem from the \c Folder
|
|
*
|
|
* \param folder The \c Folder that contains the \c FolderItem
|
|
* \param item The \c FolderItem that should be removed
|
|
* \return 0 on sucess, a negative number otherwise
|
|
*/
|
|
gint (*remove_folder) (Folder *folder,
|
|
FolderItem *item);
|
|
/**
|
|
* Close a \c FolderItem. Called when the user deselects a
|
|
* \c FolderItem.
|
|
*
|
|
* \attention In Sylpheed-Main operations can only be done on the
|
|
* \c FolderItem that is opened in the SummaryView. This
|
|
* \c FolderItem will be closed when you select a new
|
|
* \c FolderItem in the FolderView. In Claws operations can
|
|
* be done any time on any folder and you should not expect
|
|
* that all \c FolderItems get closed after operations
|
|
*
|
|
* \param folder The \c Folder that contains the \c FolderItem
|
|
* \param item The \c FolderItem that should be closed
|
|
* \return 0 on success, a negative number otherwise
|
|
*/
|
|
gint (*close) (Folder *folder,
|
|
FolderItem *item);
|
|
/**
|
|
* Get the list of message numbers for the messages in the \c FolderItem
|
|
*
|
|
* \param folder The \c Folder that contains the \c FolderItem
|
|
* \param item The \c FolderItem for which the message numbers should
|
|
* be fetched
|
|
* \param list Pointer to a GSList where message numbers have to be
|
|
* added. Because of the implementation of the GSList that
|
|
* changes the pointer of the GSList itself when the first
|
|
* item is added this is a pointer to a pointer to a
|
|
* GSList structure. Use *item = g_slist_...(*item, ...)
|
|
* operations to modify the list.
|
|
* \param old_uids_valid In some \c Folders the old UIDs can be invalid.
|
|
* Set this pointer to a gboolean to TRUE if the
|
|
* old UIDs are still valid, otherwise set it to
|
|
* FALSE and the folder system will discard it's
|
|
* cache data of the previously know UIDs
|
|
* \return The number of message numbers add to the list on success,
|
|
* a negative number otherwise.
|
|
*/
|
|
gint (*get_num_list) (Folder *folder,
|
|
FolderItem *item,
|
|
GSList **list,
|
|
gboolean *old_uids_valid);
|
|
/**
|
|
* Tell the folder system if a \c FolderItem should be scanned
|
|
* (cache data syncronized with the folder content) when it is required
|
|
* because the \c FolderItem's content changed. If NULL the folder
|
|
* system will not do automatic scanning of \c FolderItems
|
|
*
|
|
* \param folder The \c Folder that contains the \c FolderItem
|
|
* \param item The \c FolderItem which's content should be checked
|
|
* \return TRUE if the \c FolderItem should be scanned, FALSE otherwise
|
|
*/
|
|
gboolean (*scan_required) (Folder *folder,
|
|
FolderItem *item);
|
|
|
|
/* Message functions */
|
|
/**
|
|
* Get a MsgInfo for a message in a \c FolderItem
|
|
*
|
|
* \param folder The \c Folder containing the message
|
|
* \param item The \c FolderItem containing the message
|
|
* \param num The message number of the message
|
|
* \return A pointer to a \c MsgInfo decribing the message or \c
|
|
* NULL in case of an error
|
|
*/
|
|
MsgInfo *(*get_msginfo) (Folder *folder,
|
|
FolderItem *item,
|
|
gint num);
|
|
/**
|
|
* Get \c MsgInfos for a list of message numbers
|
|
*
|
|
* \param folder The \c Folder containing the message
|
|
* \param item The \c FolderItem containing the message
|
|
* \param msgnum_list A list of message numbers for which the
|
|
* \c MsgInfos should be fetched
|
|
* \return A list of \c MsgInfos for the messages in the \c msgnum_list
|
|
* that really exist. Messages that are not found can simply
|
|
* be left out.
|
|
*/
|
|
MsgInfoList *(*get_msginfos) (Folder *folder,
|
|
FolderItem *item,
|
|
MsgNumberList *msgnum_list);
|
|
/**
|
|
* Get the filename for a message. This can either be the real message
|
|
* file for local folders or a temporary file for remote folders.
|
|
*
|
|
* \param folder The \c Folder containing the message
|
|
* \param item The \c FolderItem containing the message
|
|
* \param num The message number of the message
|
|
* \return A string with the filename of the message file. The returned
|
|
* string has to be freed with \c g_free(). If message is not
|
|
* available return NULL.
|
|
*/
|
|
gchar *(*fetch_msg) (Folder *folder,
|
|
FolderItem *item,
|
|
gint num);
|
|
gchar *(*fetch_msg_full) (Folder *folder,
|
|
FolderItem *item,
|
|
gint num,
|
|
gboolean headers,
|
|
gboolean body);
|
|
/**
|
|
* Add a single message file to a folder with the given flags (if
|
|
* flag handling is supported by the folder)
|
|
*
|
|
* \param folder The target \c Folder for the message
|
|
* \param dest the target \c FolderItem for the message
|
|
* \param file The file that contains the message
|
|
* \param flags The flags the new message should have in the folder
|
|
* \return 0 on success, a negative number otherwise
|
|
*/
|
|
gint (*add_msg) (Folder *folder,
|
|
FolderItem *dest,
|
|
const gchar *file,
|
|
MsgFlags *flags);
|
|
/**
|
|
* Add multiple messages to a \c FolderItem. If NULL the folder
|
|
* system will add messages with \c add_msg one by one
|
|
*
|
|
* \param folder The target \c Folder for the messages
|
|
* \param dest the target \c FolderItem for the messages
|
|
* \param file_list A list of \c MsgFileInfos which contain the
|
|
* filenames and flags for the new messages
|
|
* \param relation Insert tuples of (MsgFileInfo, new message number) to
|
|
* provide feedback for the folder system which new
|
|
* message number a \c MsgFileInfo got in dest. Insert
|
|
* 0 if the new message number is unknown.
|
|
*/
|
|
gint (*add_msgs) (Folder *folder,
|
|
FolderItem *dest,
|
|
GSList *file_list,
|
|
GRelation *relation);
|
|
/**
|
|
* Copy a message to a FolderItem
|
|
*
|
|
* \param folder The \c Folder of the destination FolderItem
|
|
* \param dest The destination \c FolderItem for the message
|
|
* \param msginfo The message that should be copied
|
|
* \return The message number the copied message got, 0 if it is
|
|
* unknown because message numbers are assigned by an external
|
|
* system and not available after copying or a negative number
|
|
* if an error occuried
|
|
*/
|
|
gint (*copy_msg) (Folder *folder,
|
|
FolderItem *dest,
|
|
MsgInfo *msginfo);
|
|
/**
|
|
* Copy multiple messages to a \c FolderItem. If \c NULL the folder
|
|
* system will use \c copy_msg to copy messages one by one.
|
|
*
|
|
* \param folder The \c Folder of the destination FolderItem
|
|
* \param dest The destination \c FolderItem for the message
|
|
* \param msglist A list of \c MsgInfos which should be copied to dest
|
|
* \param relation Insert tuples of (MsgInfo, new message number) to
|
|
* provide feedback for the folder system which new
|
|
* message number a \c MsgInfo got in dest. Insert
|
|
* 0 if the new message number is unknown.
|
|
* \return 0 on success, a negative number otherwise
|
|
*/
|
|
gint (*copy_msgs) (Folder *folder,
|
|
FolderItem *dest,
|
|
MsgInfoList *msglist,
|
|
GRelation *relation);
|
|
/**
|
|
* Remove a message from a \c FolderItem.
|
|
*
|
|
* \param folder The \c Folder of the message
|
|
* \param item The \c FolderItem containing the message
|
|
* \param num The message number of the message
|
|
* \return 0 on success, a negative number otherwise
|
|
*/
|
|
gint (*remove_msg) (Folder *folder,
|
|
FolderItem *item,
|
|
gint num);
|
|
gint (*remove_msgs) (Folder *folder,
|
|
FolderItem *item,
|
|
MsgInfoList *msglist,
|
|
GRelation *relation);
|
|
/**
|
|
* Remove all messages in a \ c FolderItem
|
|
*
|
|
* \param folder The \c Folder of the \c FolderItem
|
|
* \param item The \FolderItem which's messages should be deleted
|
|
* \return 0 on succes, a negative number otherwise
|
|
*/
|
|
gint (*remove_all_msg) (Folder *folder,
|
|
FolderItem *item);
|
|
/**
|
|
* Check if a message has been modified by someone else
|
|
*
|
|
* \param folder The \c Folder of the message
|
|
* \param item The \c FolderItem containing the message
|
|
* \param msginfo The \c MsgInfo for the message that should be checked
|
|
* \return \c TRUE if the message was modified, \c FALSE otherwise
|
|
*/
|
|
gboolean (*is_msg_changed) (Folder *folder,
|
|
FolderItem *item,
|
|
MsgInfo *msginfo);
|
|
/**
|
|
* Update a message's flags in the folder data. If NULL only the
|
|
* internal flag management will be used. The function has to set
|
|
* \c msginfo->flags.perm_flags. It does not have to set the flags
|
|
* that it got as \c newflags. If a flag can not be set in this
|
|
* \c FolderClass the function can refuse to set it. Flags that are not
|
|
* supported by the \c FolderClass should not be refused. They will be
|
|
* managed by the internal cache in this case.
|
|
*
|
|
* \param folder The \c Folder of the message
|
|
* \param item The \c FolderItem of the message
|
|
* \param msginfo The \c MsgInfo for the message which's flags should be
|
|
* updated
|
|
* \param newflags The flags the message should get
|
|
*/
|
|
void (*change_flags) (Folder *folder,
|
|
FolderItem *item,
|
|
MsgInfo *msginfo,
|
|
MsgPermFlags newflags);
|
|
/**
|
|
* Get the flags for a list of messages. Flags that are not supported
|
|
* by the folder should be preserved. They can be copied from
|
|
* \c msginfo->flags.perm_flags
|
|
*
|
|
* \param folder The \c Folder of the messages
|
|
* \param item The \c FolderItem of the messages
|
|
* \param msglist The list of \c MsgInfos for which the flags should
|
|
* be returned
|
|
* \param msgflags A \c GRelation for tuples of (MsgInfo, new permanent
|
|
* flags for MsgInfo). Add tuples for the messages in msglist
|
|
* \return 0 on success, a negative number otherwise
|
|
*/
|
|
gint (*get_flags) (Folder *folder,
|
|
FolderItem *item,
|
|
MsgInfoList *msglist,
|
|
GRelation *msgflags);
|
|
|
|
void (*set_batch) (Folder *folder,
|
|
FolderItem *item,
|
|
gboolean batch);
|
|
};
|
|
|
|
struct _FolderItem
|
|
{
|
|
SpecialFolderItemType stype;
|
|
|
|
gchar *name; /* UTF-8 */
|
|
gchar *path; /* UTF-8 */
|
|
|
|
time_t mtime;
|
|
|
|
gint new_msgs;
|
|
gint unread_msgs;
|
|
gint total_msgs;
|
|
gint unreadmarked_msgs;
|
|
|
|
gint last_num;
|
|
|
|
MsgCache *cache;
|
|
|
|
/* special flags */
|
|
guint no_sub : 1; /* no child allowed? */
|
|
guint no_select : 1; /* not selectable? */
|
|
guint collapsed : 1; /* collapsed item */
|
|
guint thread_collapsed : 1; /* collapsed item */
|
|
guint threaded : 1; /* threaded folder view */
|
|
guint hide_read_msgs : 1; /* hide read messages */
|
|
guint ret_rcpt : 1; /* return receipt */
|
|
guint search_match : 1;
|
|
|
|
gint op_count;
|
|
guint opened : 1; /* opened by summary view */
|
|
FolderItemUpdateFlags update_flags; /* folderview for this folder should be updated */
|
|
|
|
FolderSortKey sort_key;
|
|
FolderSortType sort_type;
|
|
|
|
GNode *node;
|
|
|
|
Folder *folder;
|
|
|
|
PrefsAccount *account;
|
|
|
|
gboolean apply_sub;
|
|
|
|
GSList *mark_queue;
|
|
|
|
gpointer data;
|
|
|
|
FolderItemPrefs * prefs;
|
|
};
|
|
|
|
struct _PersistPrefs
|
|
{
|
|
FolderSortKey sort_key;
|
|
FolderSortType sort_type;
|
|
guint collapsed : 1;
|
|
guint thread_collapsed : 1;
|
|
guint threaded : 1;
|
|
guint hide_read_msgs : 1; /* CLAWS */
|
|
guint ret_rcpt : 1; /* CLAWS */
|
|
};
|
|
|
|
struct _FolderUpdateData
|
|
{
|
|
Folder *folder;
|
|
FolderUpdateFlags update_flags;
|
|
FolderItem *item;
|
|
};
|
|
|
|
struct _FolderItemUpdateData
|
|
{
|
|
FolderItem *item;
|
|
FolderItemUpdateFlags update_flags;
|
|
MsgInfo *msg;
|
|
};
|
|
|
|
void folder_system_init (void);
|
|
void folder_register_class (FolderClass *klass);
|
|
void folder_unregister_class (FolderClass *klass);
|
|
Folder *folder_new (FolderClass *type,
|
|
const gchar *name,
|
|
const gchar *path);
|
|
void folder_init (Folder *folder,
|
|
const gchar *name);
|
|
|
|
void folder_destroy (Folder *folder);
|
|
|
|
void folder_set_xml (Folder *folder,
|
|
XMLTag *tag);
|
|
XMLTag *folder_get_xml (Folder *folder);
|
|
|
|
FolderItem *folder_item_new (Folder *folder,
|
|
const gchar *name,
|
|
const gchar *path);
|
|
void folder_item_append (FolderItem *parent,
|
|
FolderItem *item);
|
|
void folder_item_remove (FolderItem *item);
|
|
void folder_item_remove_children (FolderItem *item);
|
|
void folder_item_destroy (FolderItem *item);
|
|
FolderItem *folder_item_parent (FolderItem *item);
|
|
|
|
void folder_item_set_xml (Folder *folder,
|
|
FolderItem *item,
|
|
XMLTag *tag);
|
|
XMLTag *folder_item_get_xml (Folder *folder,
|
|
FolderItem *item);
|
|
|
|
void folder_set_ui_func (Folder *folder,
|
|
FolderUIFunc func,
|
|
gpointer data);
|
|
void folder_set_name (Folder *folder,
|
|
const gchar *name);
|
|
void folder_set_sort (Folder *folder,
|
|
guint sort);
|
|
void folder_tree_destroy (Folder *folder);
|
|
|
|
void folder_add (Folder *folder);
|
|
void folder_remove (Folder *folder);
|
|
|
|
GList *folder_get_list (void);
|
|
gint folder_read_list (void);
|
|
void folder_write_list (void);
|
|
void folder_scan_tree (Folder *folder);
|
|
FolderItem *folder_create_folder(FolderItem *parent, const gchar *name);
|
|
gint folder_item_rename (FolderItem *item, gchar *newname);
|
|
void folder_update_op_count (void);
|
|
void folder_func_to_all_folders (FolderItemFunc function,
|
|
gpointer data);
|
|
void folder_count_total_msgs (guint *new_msgs,
|
|
guint *unread_msgs,
|
|
guint *unreadmarked_msgs,
|
|
guint *total_msgs);
|
|
gchar *folder_get_status (GPtrArray *folders,
|
|
gboolean full);
|
|
|
|
Folder *folder_find_from_path (const gchar *path);
|
|
Folder *folder_find_from_name (const gchar *name,
|
|
FolderClass *klass);
|
|
FolderItem *folder_find_item_from_path (const gchar *path);
|
|
FolderClass *folder_get_class_from_string (const gchar *str);
|
|
FolderItem *folder_find_child_item_by_name (FolderItem *item,
|
|
const gchar *name);
|
|
gchar *folder_get_identifier (Folder *folder);
|
|
gchar *folder_item_get_identifier (FolderItem *item);
|
|
FolderItem *folder_find_item_from_identifier (const gchar *identifier);
|
|
gchar *folder_item_get_name (FolderItem *item);
|
|
|
|
Folder *folder_get_default_folder (void);
|
|
FolderItem *folder_get_default_inbox (void);
|
|
FolderItem *folder_get_default_outbox (void);
|
|
FolderItem *folder_get_default_draft (void);
|
|
FolderItem *folder_get_default_queue (void);
|
|
FolderItem *folder_get_default_trash (void);
|
|
FolderItem *folder_get_default_processing (void);
|
|
void folder_set_missing_folders (void);
|
|
void folder_unref_account_all (PrefsAccount *account);
|
|
|
|
/* return value is locale encoded file name */
|
|
gchar *folder_item_get_path (FolderItem *item);
|
|
|
|
gint folder_item_open (FolderItem *item);
|
|
gint folder_item_close (FolderItem *item);
|
|
gint folder_item_scan (FolderItem *item);
|
|
gint folder_item_syncronize_flags (FolderItem *item);
|
|
void folder_item_scan_foreach (GHashTable *table);
|
|
MsgInfo *folder_item_get_msginfo (FolderItem *item,
|
|
gint num);
|
|
MsgInfo *folder_item_get_msginfo_by_msgid(FolderItem *item,
|
|
const gchar *msgid);
|
|
GSList *folder_item_get_msg_list (FolderItem *item);
|
|
/* return value is locale charset */
|
|
gchar *folder_item_fetch_msg (FolderItem *item,
|
|
gint num);
|
|
gchar *folder_item_fetch_msg_full (FolderItem *item,
|
|
gint num,
|
|
gboolean get_headers,
|
|
gboolean get_body);
|
|
gint folder_item_fetch_all_msg (FolderItem *item);
|
|
gint folder_item_add_msg (FolderItem *dest,
|
|
const gchar *file,
|
|
MsgFlags *flags,
|
|
gboolean remove_source);
|
|
gint folder_item_add_msgs (FolderItem *dest,
|
|
GSList *file_list,
|
|
gboolean remove_source);
|
|
gint folder_item_move_to (FolderItem *src,
|
|
FolderItem *dest,
|
|
FolderItem **new_item);
|
|
gint folder_item_move_msg (FolderItem *dest,
|
|
MsgInfo *msginfo);
|
|
gint folder_item_move_msgs (FolderItem *dest,
|
|
GSList *msglist);
|
|
gint folder_item_copy_msg (FolderItem *dest,
|
|
MsgInfo *msginfo);
|
|
gint folder_item_copy_msgs (FolderItem *dest,
|
|
GSList *msglist);
|
|
gint folder_item_remove_msg (FolderItem *item,
|
|
gint num);
|
|
gint folder_item_remove_msgs (FolderItem *item,
|
|
GSList *msglist);
|
|
gint folder_item_remove_all_msg (FolderItem *item);
|
|
void folder_item_change_msg_flags (FolderItem *item,
|
|
MsgInfo *msginfo,
|
|
MsgPermFlags newflags);
|
|
gboolean folder_item_is_msg_changed (FolderItem *item,
|
|
MsgInfo *msginfo);
|
|
/* return value is locale chaset */
|
|
gchar *folder_item_get_cache_file (FolderItem *item);
|
|
gchar *folder_item_get_mark_file (FolderItem *item);
|
|
gchar * folder_item_get_identifier (FolderItem * item);
|
|
|
|
GHashTable *folder_persist_prefs_new (Folder *folder);
|
|
void folder_persist_prefs_free (GHashTable *pptable);
|
|
const PersistPrefs *folder_get_persist_prefs
|
|
(GHashTable *pptable, const char *name);
|
|
|
|
void folder_item_restore_persist_prefs (FolderItem *item, GHashTable *pptable);
|
|
void folder_clean_cache_memory (void);
|
|
void folder_item_write_cache (FolderItem *item);
|
|
void folder_item_set_default_flags (FolderItem *dest, MsgFlags *flags);
|
|
|
|
void folder_item_apply_processing (FolderItem *item);
|
|
|
|
void folder_item_update (FolderItem *item,
|
|
FolderItemUpdateFlags update_flags);
|
|
void folder_item_update_recursive (FolderItem *item,
|
|
FolderItemUpdateFlags update_flags);
|
|
void folder_item_update_freeze (void);
|
|
void folder_item_update_thaw (void);
|
|
void folder_item_set_batch (FolderItem *item, gboolean batch);
|
|
#endif /* __FOLDER_H__ */
|