CamelFolder

CamelFolder

Synopsis

enum                CamelFolderFlags;
struct              CamelFolder;
#define             CAMEL_FOLDER_ERROR
enum                CamelFolderError;
struct              CamelFolderChangeInfo;
struct              CamelFolderQuotaInfo;
void                camel_folder_set_lock_async         (CamelFolder *folder,
                                                         gboolean skip_folder_lock);
struct _CamelStore * camel_folder_get_parent_store      (CamelFolder *folder);
const gchar *       camel_folder_get_full_name          (CamelFolder *folder);
gchar *             camel_folder_dup_full_name          (CamelFolder *folder);
void                camel_folder_set_full_name          (CamelFolder *folder,
                                                         const gchar *full_name);
const gchar *       camel_folder_get_display_name       (CamelFolder *folder);
gchar *             camel_folder_dup_display_name       (CamelFolder *folder);
void                camel_folder_set_display_name       (CamelFolder *folder,
                                                         const gchar *display_name);
const gchar *       camel_folder_get_description        (CamelFolder *folder);
gchar *             camel_folder_dup_description        (CamelFolder *folder);
void                camel_folder_set_description        (CamelFolder *folder,
                                                         const gchar *description);
CamelMessageFlags   camel_folder_get_permanent_flags    (CamelFolder *folder);
CamelMessageFlags   camel_folder_get_message_flags      (CamelFolder *folder,
                                                         const gchar *uid);
gboolean            camel_folder_set_message_flags      (CamelFolder *folder,
                                                         const gchar *uid,
                                                         CamelMessageFlags flags,
                                                         CamelMessageFlags set);
gboolean            camel_folder_get_message_user_flag  (CamelFolder *folder,
                                                         const gchar *uid,
                                                         const gchar *name);
void                camel_folder_set_message_user_flag  (CamelFolder *folder,
                                                         const gchar *uid,
                                                         const gchar *name,
                                                         gboolean value);
const gchar *       camel_folder_get_message_user_tag   (CamelFolder *folder,
                                                         const gchar *uid,
                                                         const gchar *name);
void                camel_folder_set_message_user_tag   (CamelFolder *folder,
                                                         const gchar *uid,
                                                         const gchar *name,
                                                         const gchar *value);
gboolean            camel_folder_has_summary_capability (CamelFolder *folder);
gint                camel_folder_get_message_count      (CamelFolder *folder);
gint                camel_folder_get_unread_message_count
                                                        (CamelFolder *folder);
gint                camel_folder_get_deleted_message_count
                                                        (CamelFolder *folder);
GPtrArray *         camel_folder_get_summary            (CamelFolder *folder);
void                camel_folder_free_summary           (CamelFolder *folder,
                                                         GPtrArray *array);
#define             camel_folder_delete_message         (folder,
                                                         uid)
GPtrArray *         camel_folder_get_uids               (CamelFolder *folder);
void                camel_folder_free_uids              (CamelFolder *folder,
                                                         GPtrArray *array);
GPtrArray *         camel_folder_get_uncached_uids      (CamelFolder *folder,
                                                         GPtrArray *uids,
                                                         GError **error);
gint                camel_folder_cmp_uids               (CamelFolder *folder,
                                                         const gchar *uid1,
                                                         const gchar *uid2);
void                camel_folder_sort_uids              (CamelFolder *folder,
                                                         GPtrArray *uids);
GPtrArray *         camel_folder_search_by_expression   (CamelFolder *folder,
                                                         const gchar *expr,
                                                         GCancellable *cancellable,
                                                         GError **error);
GPtrArray *         camel_folder_search_by_uids         (CamelFolder *folder,
                                                         const gchar *expr,
                                                         GPtrArray *uids,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_search_free            (CamelFolder *folder,
                                                         GPtrArray *result);
guint32             camel_folder_count_by_expression    (CamelFolder *folder,
                                                         const gchar *expression,
                                                         GCancellable *cancellable,
                                                         GError **error);
CamelMessageInfo *  camel_folder_get_message_info       (CamelFolder *folder,
                                                         const gchar *uid);
void                camel_folder_free_message_info      (CamelFolder *folder,
                                                         CamelMessageInfo *info);
void                camel_folder_ref_message_info       (CamelFolder *folder,
                                                         CamelMessageInfo *info);
void                camel_folder_delete                 (CamelFolder *folder);
void                camel_folder_rename                 (CamelFolder *folder,
                                                         const gchar *new_name);
void                camel_folder_changed                (CamelFolder *folder,
                                                         CamelFolderChangeInfo *changes);
void                camel_folder_freeze                 (CamelFolder *folder);
void                camel_folder_thaw                   (CamelFolder *folder);
gboolean            camel_folder_is_frozen              (CamelFolder *folder);
gint                camel_folder_get_frozen_count       (CamelFolder *folder);
CamelFolderQuotaInfo * camel_folder_quota_info_new      (const gchar *name,
                                                         guint64 used,
                                                         guint64 total);
CamelFolderQuotaInfo * camel_folder_quota_info_clone    (const CamelFolderQuotaInfo *info);
void                camel_folder_quota_info_free        (CamelFolderQuotaInfo *info);
void                camel_folder_free_nop               (CamelFolder *folder,
                                                         GPtrArray *array);
void                camel_folder_free_shallow           (CamelFolder *folder,
                                                         GPtrArray *array);
void                camel_folder_free_deep              (CamelFolder *folder,
                                                         GPtrArray *array);
gchar *             camel_folder_get_filename           (CamelFolder *folder,
                                                         const gchar *uid,
                                                         GError **error);
gboolean            camel_folder_append_message_sync    (CamelFolder *folder,
                                                         CamelMimeMessage *message,
                                                         CamelMessageInfo *info,
                                                         gchar **appended_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_append_message         (CamelFolder *folder,
                                                         CamelMimeMessage *message,
                                                         CamelMessageInfo *info,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            camel_folder_append_message_finish  (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         gchar **appended_uid,
                                                         GError **error);
gboolean            camel_folder_expunge_sync           (CamelFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_expunge                (CamelFolder *folder,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            camel_folder_expunge_finish         (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);
enum                CamelFetchType;
gboolean            camel_folder_fetch_messages_sync    (CamelFolder *folder,
                                                         CamelFetchType type,
                                                         gint limit,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_fetch_messages         (CamelFolder *folder,
                                                         CamelFetchType type,
                                                         gint limit,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            camel_folder_fetch_messages_finish  (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);
CamelMimeMessage *  camel_folder_get_message_sync       (CamelFolder *folder,
                                                         const gchar *message_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_get_message            (CamelFolder *folder,
                                                         const gchar *message_uid,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
CamelMimeMessage *  camel_folder_get_message_finish     (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);
CamelFolderQuotaInfo * camel_folder_get_quota_info_sync (CamelFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_get_quota_info         (CamelFolder *folder,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
CamelFolderQuotaInfo * camel_folder_get_quota_info_finish
                                                        (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            camel_folder_purge_message_cache_sync
                                                        (CamelFolder *folder,
                                                         gchar *start_uid,
                                                         gchar *end_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_purge_message_cache    (CamelFolder *folder,
                                                         gchar *start_uid,
                                                         gchar *end_uid,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            camel_folder_purge_message_cache_finish
                                                        (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            camel_folder_refresh_info_sync      (CamelFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_refresh_info           (CamelFolder *folder,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            camel_folder_refresh_info_finish    (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            camel_folder_synchronize_sync       (CamelFolder *folder,
                                                         gboolean expunge,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_synchronize            (CamelFolder *folder,
                                                         gboolean expunge,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            camel_folder_synchronize_finish     (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            camel_folder_synchronize_message_sync
                                                        (CamelFolder *folder,
                                                         const gchar *message_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_synchronize_message    (CamelFolder *folder,
                                                         const gchar *message_uid,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            camel_folder_synchronize_message_finish
                                                        (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            camel_folder_transfer_messages_to_sync
                                                        (CamelFolder *source,
                                                         GPtrArray *message_uids,
                                                         CamelFolder *destination,
                                                         gboolean delete_originals,
                                                         GPtrArray **transferred_uids,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                camel_folder_transfer_messages_to   (CamelFolder *source,
                                                         GPtrArray *message_uids,
                                                         CamelFolder *destination,
                                                         gboolean delete_originals,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            camel_folder_transfer_messages_to_finish
                                                        (CamelFolder *source,
                                                         GAsyncResult *result,
                                                         GPtrArray **transferred_uids,
                                                         GError **error);
CamelFolderChangeInfo * camel_folder_change_info_new    (void);
void                camel_folder_change_info_clear      (CamelFolderChangeInfo *info);
void                camel_folder_change_info_free       (CamelFolderChangeInfo *info);
gboolean            camel_folder_change_info_changed    (CamelFolderChangeInfo *info);
void                camel_folder_change_info_add_source (CamelFolderChangeInfo *info,
                                                         const gchar *uid);
void                camel_folder_change_info_add_source_list
                                                        (CamelFolderChangeInfo *info,
                                                         const GPtrArray *list);
void                camel_folder_change_info_add_update (CamelFolderChangeInfo *info,
                                                         const gchar *uid);
void                camel_folder_change_info_add_update_list
                                                        (CamelFolderChangeInfo *info,
                                                         const GPtrArray *list);
void                camel_folder_change_info_build_diff (CamelFolderChangeInfo *info);
void                camel_folder_change_info_cat        (CamelFolderChangeInfo *info,
                                                         CamelFolderChangeInfo *src);
void                camel_folder_change_info_add_uid    (CamelFolderChangeInfo *info,
                                                         const gchar *uid);
void                camel_folder_change_info_remove_uid (CamelFolderChangeInfo *info,
                                                         const gchar *uid);
void                camel_folder_change_info_change_uid (CamelFolderChangeInfo *info,
                                                         const gchar *uid);
void                camel_folder_change_info_recent_uid (CamelFolderChangeInfo *info,
                                                         const gchar *uid);
enum                CamelFolderLock;
void                camel_folder_lock                   (CamelFolder *folder,
                                                         CamelFolderLock lock);
void                camel_folder_unlock                 (CamelFolder *folder,
                                                         CamelFolderLock lock);

Object Hierarchy

  GObject
   +----CamelObject
         +----CamelFolder
               +----CamelDiscoFolder
               +----CamelOfflineFolder
               +----CamelVeeFolder

Properties

  "description"              gchar*                : Read / Write / Construct
  "display-name"             gchar*                : Read / Write / Construct
  "full-name"                gchar*                : Read / Write / Construct
  "parent-store"             CamelStore*           : Read / Write / Construct Only

Signals

  "changed"                                        : Run First
  "deleted"                                        : Run First
  "renamed"                                        : Run First

Description

Details

enum CamelFolderFlags

typedef enum {
 /*< flags >*/
	CAMEL_FOLDER_HAS_SUMMARY_CAPABILITY = 1 << 0,
	CAMEL_FOLDER_FILTER_RECENT = 1 << 2,
	CAMEL_FOLDER_HAS_BEEN_DELETED = 1 << 3,
	CAMEL_FOLDER_IS_TRASH = 1 << 4,
	CAMEL_FOLDER_IS_JUNK = 1 << 5,
	CAMEL_FOLDER_FILTER_JUNK = 1 << 6
} CamelFolderFlags;

CAMEL_FOLDER_HAS_SUMMARY_CAPABILITY

CAMEL_FOLDER_FILTER_RECENT

CAMEL_FOLDER_HAS_BEEN_DELETED

CAMEL_FOLDER_IS_TRASH

CAMEL_FOLDER_IS_JUNK

CAMEL_FOLDER_FILTER_JUNK


struct CamelFolder

struct CamelFolder;

CAMEL_FOLDER_ERROR

#define             CAMEL_FOLDER_ERROR

Since 2.32


enum CamelFolderError

typedef enum {
	CAMEL_FOLDER_ERROR_INVALID,
	CAMEL_FOLDER_ERROR_INVALID_STATE,
	CAMEL_FOLDER_ERROR_NON_EMPTY,
	CAMEL_FOLDER_ERROR_NON_UID,
	CAMEL_FOLDER_ERROR_INSUFFICIENT_PERMISSION,
	CAMEL_FOLDER_ERROR_INVALID_PATH,
	CAMEL_FOLDER_ERROR_INVALID_UID,
	CAMEL_FOLDER_ERROR_SUMMARY_INVALID
} CamelFolderError;

CAMEL_FOLDER_ERROR_INVALID

CAMEL_FOLDER_ERROR_INVALID_STATE

CAMEL_FOLDER_ERROR_NON_EMPTY

CAMEL_FOLDER_ERROR_NON_UID

CAMEL_FOLDER_ERROR_INSUFFICIENT_PERMISSION

CAMEL_FOLDER_ERROR_INVALID_PATH

CAMEL_FOLDER_ERROR_INVALID_UID

CAMEL_FOLDER_ERROR_SUMMARY_INVALID

Since 2.32


struct CamelFolderChangeInfo

struct CamelFolderChangeInfo {
	GPtrArray *uid_added;
	GPtrArray *uid_removed;
	GPtrArray *uid_changed;
	GPtrArray *uid_recent;

	CamelFolderChangeInfoPrivate *priv;
};

struct CamelFolderQuotaInfo

struct CamelFolderQuotaInfo {
	gchar *name;
	guint64 used;
	guint64 total;

	struct _CamelFolderQuotaInfo *next;
};

Since 2.24


camel_folder_set_lock_async ()

void                camel_folder_set_lock_async         (CamelFolder *folder,
                                                         gboolean skip_folder_lock);

FIXME Document me!

folder :

a CamelFolder

Since 2.30


camel_folder_get_parent_store ()

struct _CamelStore * camel_folder_get_parent_store      (CamelFolder *folder);

folder :

a CamelFolder

Returns :

the parent CamelStore of the folder

camel_folder_get_full_name ()

const gchar *       camel_folder_get_full_name          (CamelFolder *folder);

Returns the fully qualified name of the folder.

folder :

a CamelFolder

Returns :

the fully qualified name of the folder

camel_folder_dup_full_name ()

gchar *             camel_folder_dup_full_name          (CamelFolder *folder);

Thread-safe variation of camel_folder_get_full_name(). Use this function when accessing folder from multiple threads.

The returned string should be freed with g_free() when no longer needed.

folder :

a CamelFolder

Returns :

a newly-allocated copy of "full-name"

Since 3.8


camel_folder_set_full_name ()

void                camel_folder_set_full_name          (CamelFolder *folder,
                                                         const gchar *full_name);

Sets the fully qualified name of the folder.

folder :

a CamelFolder

full_name :

a fully qualified name for the folder

Since 2.32


camel_folder_get_display_name ()

const gchar *       camel_folder_get_display_name       (CamelFolder *folder);

Returns the display name for the folder. The fully qualified name can be obtained with camel_folder_get_full_name().

folder :

a CamelFolder

Returns :

the display name of the folder

Since 3.2


camel_folder_dup_display_name ()

gchar *             camel_folder_dup_display_name       (CamelFolder *folder);

Thread-safe variation of camel_folder_get_display_name(). Use this function when accessing folder from multiple threads.

The returned string should be freed with g_free() when no longer needed.

folder :

a CamelFolder

Returns :

a newly-allocated copy of "display-name"

Since 3.8


camel_folder_set_display_name ()

void                camel_folder_set_display_name       (CamelFolder *folder,
                                                         const gchar *display_name);

Sets the display name for the folder.

folder :

a CamelFolder

display_name :

a display name for the folder

Since 3.2


camel_folder_get_description ()

const gchar *       camel_folder_get_description        (CamelFolder *folder);

Returns a description of the folder suitable for displaying to the user.

folder :

a CamelFolder

Returns :

a description of the folder

Since 2.32


camel_folder_dup_description ()

gchar *             camel_folder_dup_description        (CamelFolder *folder);

Thread-safe variation of camel_folder_get_description(). Use this function when accessing folder from multiple threads.

The returned string should be freed with g_free() when no longer needed.

folder :

a CamelFolder

Returns :

a newly-allocated copy of "description"

Since 3.8


camel_folder_set_description ()

void                camel_folder_set_description        (CamelFolder *folder,
                                                         const gchar *description);

Sets a description of the folder suitable for displaying to the user.

folder :

a CamelFolder

description :

a description of the folder

Since 2.32


camel_folder_get_permanent_flags ()

CamelMessageFlags   camel_folder_get_permanent_flags    (CamelFolder *folder);

folder :

a CamelFolder

Returns :

the set of CamelMessageFlags that can be permanently stored on a message between sessions. If it includes CAMEL_FLAG_USER, then user-defined flags will be remembered.

camel_folder_get_message_flags ()

CamelMessageFlags   camel_folder_get_message_flags      (CamelFolder *folder,
                                                         const gchar *uid);

Warning

camel_folder_get_message_flags is deprecated and should not be used in newly-written code. Use camel_folder_get_message_info() instead.

folder :

a CamelFolder

uid :

the UID of a message in folder

Returns :

the CamelMessageFlags that are set on the indicated message.

camel_folder_set_message_flags ()

gboolean            camel_folder_set_message_flags      (CamelFolder *folder,
                                                         const gchar *uid,
                                                         CamelMessageFlags flags,
                                                         CamelMessageFlags set);

Warning

camel_folder_set_message_flags is deprecated and should not be used in newly-written code. Use camel_message_info_set_flags() on the message info directly (when it works)

Sets those flags specified by flags to the values specified by set on the indicated message. (This may or may not persist after the folder or store is closed. See camel_folder_get_permanent_flags())

E.g. to set the deleted flag and clear the draft flag, use camel_folder_set_message_flags (folder, uid, CAMEL_MESSAGE_DELETED|CAMEL_MESSAGE_DRAFT, CAMEL_MESSAGE_DELETED);

folder :

a CamelFolder

uid :

the UID of a message in folder

flags :

a set of CamelMessageFlag values to set

set :

the mask of values in flags to use.

Returns :

TRUE if the flags were changed or FALSE otherwise

camel_folder_get_message_user_flag ()

gboolean            camel_folder_get_message_user_flag  (CamelFolder *folder,
                                                         const gchar *uid,
                                                         const gchar *name);

Warning

camel_folder_get_message_user_flag is deprecated and should not be used in newly-written code. Use camel_message_info_get_user_flag() on the message info directly

folder :

a CamelFolder

uid :

the UID of a message in folder

name :

the name of a user flag

Returns :

TRUE if the given user flag is set on the message or FALSE otherwise

camel_folder_set_message_user_flag ()

void                camel_folder_set_message_user_flag  (CamelFolder *folder,
                                                         const gchar *uid,
                                                         const gchar *name,
                                                         gboolean value);

Warning

camel_folder_set_message_user_flag is deprecated and should not be used in newly-written code. Use camel_message_info_set_user_flag() on the CamelMessageInfo directly (when it works)

Sets the user flag specified by name to the value specified by value on the indicated message. (This may or may not persist after the folder or store is closed. See camel_folder_get_permanent_flags())

folder :

a CamelFolder

uid :

the UID of a message in folder

name :

the name of the user flag to set

value :

the value to set it to

camel_folder_get_message_user_tag ()

const gchar *       camel_folder_get_message_user_tag   (CamelFolder *folder,
                                                         const gchar *uid,
                                                         const gchar *name);

Warning

camel_folder_get_message_user_tag is deprecated and should not be used in newly-written code. Use camel_message_info_get_user_tag() on the CamelMessageInfo directly.

folder :

a CamelFolder

uid :

the UID of a message in folder

name :

the name of a user tag

Returns :

the value of the user tag

camel_folder_set_message_user_tag ()

void                camel_folder_set_message_user_tag   (CamelFolder *folder,
                                                         const gchar *uid,
                                                         const gchar *name,
                                                         const gchar *value);

Warning

camel_folder_set_message_user_tag is deprecated and should not be used in newly-written code. Use camel_message_info_set_user_tag() on the CamelMessageInfo directly (when it works).

Sets the user tag specified by name to the value specified by value on the indicated message. (This may or may not persist after the folder or store is closed. See camel_folder_get_permanent_flags())

folder :

a CamelFolder

uid :

the UID of a message in folder

name :

the name of the user tag to set

value :

the value to set it to

camel_folder_has_summary_capability ()

gboolean            camel_folder_has_summary_capability (CamelFolder *folder);

Get whether or not the folder has a summary.

folder :

a CamelFolder

Returns :

TRUE if a summary is available or FALSE otherwise

camel_folder_get_message_count ()

gint                camel_folder_get_message_count      (CamelFolder *folder);

folder :

a CamelFolder

Returns :

the number of messages in the folder, or -1 if unknown

camel_folder_get_unread_message_count ()

gint                camel_folder_get_unread_message_count
                                                        (CamelFolder *folder);

Warning

camel_folder_get_unread_message_count is deprecated and should not be used in newly-written code. use camel_object_get() instead.

folder :

a CamelFolder

Returns :

the number of unread messages in the folder, or -1 if unknown

camel_folder_get_deleted_message_count ()

gint                camel_folder_get_deleted_message_count
                                                        (CamelFolder *folder);

folder :

a CamelFolder

Returns :

the number of deleted messages in the folder, or -1 if unknown

camel_folder_get_summary ()

GPtrArray *         camel_folder_get_summary            (CamelFolder *folder);

This returns the summary information for the folder. This array should not be modified, and must be freed with camel_folder_free_summary().

folder :

a CamelFolder

Returns :

an array of CamelMessageInfo

camel_folder_free_summary ()

void                camel_folder_free_summary           (CamelFolder *folder,
                                                         GPtrArray *array);

Frees the summary array returned by camel_folder_get_summary().

folder :

a CamelFolder

array :

the summary array to free

camel_folder_delete_message()

#define             camel_folder_delete_message(folder, uid)

camel_folder_get_uids ()

GPtrArray *         camel_folder_get_uids               (CamelFolder *folder);

Get the list of UIDs available in a folder. This routine is useful for finding what messages are available when the folder does not support summaries. The returned array should not be modified, and must be freed by passing it to camel_folder_free_uids().

folder :

a CamelFolder

Returns :

a GPtrArray of UIDs corresponding to the messages available in the folder

camel_folder_free_uids ()

void                camel_folder_free_uids              (CamelFolder *folder,
                                                         GPtrArray *array);

Frees the array of UIDs returned by camel_folder_get_uids().

folder :

a CamelFolder

array :

the array of uids to free

camel_folder_get_uncached_uids ()

GPtrArray *         camel_folder_get_uncached_uids      (CamelFolder *folder,
                                                         GPtrArray *uids,
                                                         GError **error);

folder :

a CamelFolder

uids :

the array of uids to filter down to uncached ones.

Returns :

the known-uncached uids from a list of uids. It may return uids which are locally cached but should never filter out a uid which is not locally cached. Free the result by called camel_folder_free_uids(). Frees the array of UIDs returned by camel_folder_get_uids().

Since 2.26


camel_folder_cmp_uids ()

gint                camel_folder_cmp_uids               (CamelFolder *folder,
                                                         const gchar *uid1,
                                                         const gchar *uid2);

Compares two uids. The return value meaning is the same as in any other compare function.

Note that the default compare function expects a decimal number at the beginning of a uid, thus if provider uses different uid values, then it should subclass this function.

folder :

a CamelFolder

uid1 :

The first uid.

uid2 :

the second uid.

Since 2.28


camel_folder_sort_uids ()

void                camel_folder_sort_uids              (CamelFolder *folder,
                                                         GPtrArray *uids);

Sorts the array of UIDs.

folder :

a CamelFolder

uids :

array of uids

Since 2.24


camel_folder_search_by_expression ()

GPtrArray *         camel_folder_search_by_expression   (CamelFolder *folder,
                                                         const gchar *expr,
                                                         GCancellable *cancellable,
                                                         GError **error);

Searches the folder for messages matching the given search expression.

folder :

a CamelFolder

expr :

a search expression

cancellable :

a GCancellable

error :

return location for a GError, or NULL

Returns :

a GPtrArray of uids of matching messages. The caller must free the list and each of the elements when it is done.

camel_folder_search_by_uids ()

GPtrArray *         camel_folder_search_by_uids         (CamelFolder *folder,
                                                         const gchar *expr,
                                                         GPtrArray *uids,
                                                         GCancellable *cancellable,
                                                         GError **error);

Search a subset of uid's for an expression match.

folder :

a CamelFolder

expr :

search expression

uids :

array of uid's to match against.

cancellable :

a GCancellable

error :

return location for a GError, or NULL

Returns :

a GPtrArray of uids of matching messages. The caller must free the list and each of the elements when it is done.

camel_folder_search_free ()

void                camel_folder_search_free            (CamelFolder *folder,
                                                         GPtrArray *result);

Free the result of a search as gotten by camel_folder_search() or camel_folder_search_by_uids().

folder :

a CamelFolder

result :

search results to free

camel_folder_count_by_expression ()

guint32             camel_folder_count_by_expression    (CamelFolder *folder,
                                                         const gchar *expression,
                                                         GCancellable *cancellable,
                                                         GError **error);

Searches the folder for count of messages matching the given search expression.

folder :

a CamelFolder

expression :

a search expression

cancellable :

a GCancellable

error :

return location for a GError, or NULL

Returns :

an interger

Since 2.26


camel_folder_get_message_info ()

CamelMessageInfo *  camel_folder_get_message_info       (CamelFolder *folder,
                                                         const gchar *uid);

Retrieve the CamelMessageInfo for the specified uid. This return must be freed using camel_folder_free_message_info().

folder :

a CamelFolder

uid :

the uid of a message

Returns :

the summary information for the indicated message, or NULL if the uid does not exist

camel_folder_free_message_info ()

void                camel_folder_free_message_info      (CamelFolder *folder,
                                                         CamelMessageInfo *info);

Free (unref) a CamelMessageInfo, previously obtained with camel_folder_get_message_info().

folder :

a CamelFolder

info :

a CamelMessageInfo

camel_folder_ref_message_info ()

void                camel_folder_ref_message_info       (CamelFolder *folder,
                                                         CamelMessageInfo *info);

Warning

camel_folder_ref_message_info is deprecated and should not be used in newly-written code. Use camel_message_info_ref() directly.

Ref a CamelMessageInfo, previously obtained with camel_folder_get_message_info().

folder :

a CamelFolder

info :

a CamelMessageInfo

camel_folder_delete ()

void                camel_folder_delete                 (CamelFolder *folder);

Marks folder as deleted and performs any required cleanup.

This also emits the "deleted" signal from an idle source on the main loop. The idle source's priority is G_PRIORITY_HIGH_IDLE.

folder :

a CamelFolder

camel_folder_rename ()

void                camel_folder_rename                 (CamelFolder *folder,
                                                         const gchar *new_name);

Marks folder as renamed.

This also emits the "renamed" signal from an idle source on the main loop. The idle source's priority is G_PRIORITY_HIGH_IDLE.

NOTE: This is an internal function used by camel stores, no locking is performed on the folder.

folder :

a CamelFolder

new_name :

new name for the folder

camel_folder_changed ()

void                camel_folder_changed                (CamelFolder *folder,
                                                         CamelFolderChangeInfo *changes);

Emits the "changed" signal from an idle source on the main loop. The idle source's priority is G_PRIORITY_LOW.

folder :

a CamelFolder

changes :

change information for folder

Since 2.32


camel_folder_freeze ()

void                camel_folder_freeze                 (CamelFolder *folder);

Freezes the folder so that a series of operation can be performed without "folder_changed" signals being emitted. When the folder is later thawed with camel_folder_thaw(), the suppressed signals will be emitted.

folder :

a CamelFolder

camel_folder_thaw ()

void                camel_folder_thaw                   (CamelFolder *folder);

Thaws the folder and emits any pending folder_changed signals.

folder :

a CamelFolder

camel_folder_is_frozen ()

gboolean            camel_folder_is_frozen              (CamelFolder *folder);

folder :

a CamelFolder

Returns :

whether or not the folder is frozen

camel_folder_get_frozen_count ()

gint                camel_folder_get_frozen_count       (CamelFolder *folder);

folder :

a CamelFolder

Since 2.32


camel_folder_quota_info_new ()

CamelFolderQuotaInfo * camel_folder_quota_info_new      (const gchar *name,
                                                         guint64 used,
                                                         guint64 total);

name :

Name of the quota.

used :

Current usage of the quota.

total :

Total available size of the quota.

Returns :

newly allocated CamelFolderQuotaInfo structure with initialized values based on the parameters, with next member set to NULL.

Since 2.24


camel_folder_quota_info_clone ()

CamelFolderQuotaInfo * camel_folder_quota_info_clone    (const CamelFolderQuotaInfo *info);

Makes a copy of the given info and all next-s.

info :

a CamelFolderQuotaInfo object to clone.

Since 2.24


camel_folder_quota_info_free ()

void                camel_folder_quota_info_free        (CamelFolderQuotaInfo *info);

Frees this and all next objects.

info :

a CamelFolderQuotaInfo object to free.

Since 2.24


camel_folder_free_nop ()

void                camel_folder_free_nop               (CamelFolder *folder,
                                                         GPtrArray *array);

"Frees" the provided array by doing nothing. Used by CamelFolder subclasses as an implementation for free_uids, or free_summary when the returned array is "static" information and should not be freed.

folder :

a CamelFolder

array :

an array of uids or CamelMessageInfo

camel_folder_free_shallow ()

void                camel_folder_free_shallow           (CamelFolder *folder,
                                                         GPtrArray *array);

Frees the provided array but not its contents. Used by CamelFolder subclasses as an implementation for free_uids or free_summary when the returned array needs to be freed but its contents come from "static" information.

folder :

a CamelFolder

array :

an array of uids or CamelMessageInfo

camel_folder_free_deep ()

void                camel_folder_free_deep              (CamelFolder *folder,
                                                         GPtrArray *array);

Frees the provided array and its contents. Used by CamelFolder subclasses as an implementation for free_uids when the provided information was created explicitly by the corresponding get_ call.

folder :

a CamelFolder

array :

an array of uids

camel_folder_get_filename ()

gchar *             camel_folder_get_filename           (CamelFolder *folder,
                                                         const gchar *uid,
                                                         GError **error);

Since 2.26


camel_folder_append_message_sync ()

gboolean            camel_folder_append_message_sync    (CamelFolder *folder,
                                                         CamelMimeMessage *message,
                                                         CamelMessageInfo *info,
                                                         gchar **appended_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);

Appends message to folder. Only the flag and tag data from info are used. If info is NULL, no flags or tags will be set.

folder :

a CamelFolder

message :

a CamelMimeMessage

info :

a CamelMessageInfo with additional flags/etc to set on the new message, or NULL

appended_uid :

if non-NULL, the UID of the appended message will be returned here, if it is known

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.0


camel_folder_append_message ()

void                camel_folder_append_message         (CamelFolder *folder,
                                                         CamelMimeMessage *message,
                                                         CamelMessageInfo *info,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Appends message to folder asynchronously. Only the flag and tag data from info are used. If info is NULL, no flags or tags will be set.

When the operation is finished, callback will be called. You can then call camel_folder_append_message_finish() to get the result of the operation.

message :

a CamelMimeMessage

info :

a CamelMessageInfo with additional flags/etc to set on the new message, or NULL

io_priority :

the I/O priority of the request

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.0


camel_folder_append_message_finish ()

gboolean            camel_folder_append_message_finish  (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         gchar **appended_uid,
                                                         GError **error);

Finishes the operation started with camel_folder_append_message_finish().

folder :

a CamelFolder

result :

a GAsyncResult

appended_uid :

if non-NULL, the UID of the appended message will be returned here, if it is known

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.0


camel_folder_expunge_sync ()

gboolean            camel_folder_expunge_sync           (CamelFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);

Deletes messages which have been marked as "DELETED".

folder :

a CamelFolder

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.0


camel_folder_expunge ()

void                camel_folder_expunge                (CamelFolder *folder,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously deletes messages which have been marked as "DELETED".

When the operation is finished, callback will be called. You can then call camel_folder_expunge_finish() to get the result of the operation.

folder :

a CamelFolder

io_priority :

the I/O priority of the request

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.0


camel_folder_expunge_finish ()

gboolean            camel_folder_expunge_finish         (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with camel_folder_expunge().

folder :

a CamelFolder

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.0


enum CamelFetchType

typedef enum {
	CAMEL_FETCH_OLD_MESSAGES,
	CAMEL_FETCH_NEW_MESSAGES
} CamelFetchType;

CAMEL_FETCH_OLD_MESSAGES

CAMEL_FETCH_NEW_MESSAGES

Since 3.4


camel_folder_fetch_messages_sync ()

gboolean            camel_folder_fetch_messages_sync    (CamelFolder *folder,
                                                         CamelFetchType type,
                                                         gint limit,
                                                         GCancellable *cancellable,
                                                         GError **error);

Downloads old or new specified number of messages from the server. It is optimized for mobile client usage. Desktop clients should keep away from this api and use camel_folder_refresh_info.

folder :

a CamelFolder

type :

Type to specify fetch old or new messages. limit: Limit to specify the number of messages to download.

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE if there are more messages to fetch, FALSE if there are no more messages

Since 3.4


camel_folder_fetch_messages ()

void                camel_folder_fetch_messages         (CamelFolder *folder,
                                                         CamelFetchType type,
                                                         gint limit,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously download new or old messages from the server. It is assumes that the client has only a window of interested messages of what server has. And old/new type helps to expand that window.

type = CAMEL_FETCH_OLD_MESSAGES: Downloads messages older than what the client already has. type = CAMEL_FETCH_NEW_MESSAGES: Downloads messages newer than what the client already has.

When the operation is finished, callback will be called. You can then call camel_folder_fetch_messages_finish() to get the result of the operation.

folder :

a CamelFolder

type :

Type to specify fetch old or new messages. limit: Limit to specify the number of messages to download.

io_priority :

the I/O priority of the request

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.4


camel_folder_fetch_messages_finish ()

gboolean            camel_folder_fetch_messages_finish  (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with camel_folder_fetch_messages().

folder :

a CamelFolder

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE if there are more messages to fetch, FALSE if there are no more messages

Since 3.4


camel_folder_get_message_sync ()

CamelMimeMessage *  camel_folder_get_message_sync       (CamelFolder *folder,
                                                         const gchar *message_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);

Gets the message corresponding to message_uid from folder.

folder :

a CamelFolder

message_uid :

the message UID

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

a CamelMimeMessage corresponding to the requested UID

Since 3.0


camel_folder_get_message ()

void                camel_folder_get_message            (CamelFolder *folder,
                                                         const gchar *message_uid,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously gets the message corresponding to message_uid from folder.

When the operation is finished, callback will be called. You can then call camel_folder_get_message_finish() to get the result of the operation.

folder :

a CamelFolder

message_uid :

the message UID

io_priority :

the I/O priority of the request

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.0


camel_folder_get_message_finish ()

CamelMimeMessage *  camel_folder_get_message_finish     (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with camel_folder_get_message().

folder :

a CamelFolder

result :

a GAsyncResult

error :

return location for a GError or NULL

Returns :

a CamelMimeMessage corresponding to the requested UID

Since 3.0


camel_folder_get_quota_info_sync ()

CamelFolderQuotaInfo * camel_folder_get_quota_info_sync (CamelFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);

Gets a list of known quotas for folder. Free the returned CamelFolderQuotaInfo struct with camel_folder_quota_info_free().

If quotas are not supported for folder, the function returns NULL and sets error to G_IO_ERROR_NOT_SUPPORTED.

folder :

a CamelFolder

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

a CamelFolderQuotaInfo, or NULL

Since 3.2


camel_folder_get_quota_info ()

void                camel_folder_get_quota_info         (CamelFolder *folder,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously gets a list of known quotas for folder.

When the operation is finished, callback will be called. You can then call camel_folder_get_quota_info_finish() to get the result of the operation.

folder :

a CamelFolder

io_priority :

the I/O priority of the request

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.2


camel_folder_get_quota_info_finish ()

CamelFolderQuotaInfo * camel_folder_get_quota_info_finish
                                                        (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with camel_folder_get_quota_info(). Free the returned CamelFolderQuotaInfo struct with camel_folder_quota_info_free().

If quotas are not supported for folder, the function returns NULL and sets error to G_IO_ERROR_NOT_SUPPORTED.

folder :

a CamelFolder

result :

a GAsyncResult

error :

return location for a GError or NULL

Returns :

a CamelFolderQuotaInfo, or NULL

Since 3.2


camel_folder_purge_message_cache_sync ()

gboolean            camel_folder_purge_message_cache_sync
                                                        (CamelFolder *folder,
                                                         gchar *start_uid,
                                                         gchar *end_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);

Delete the local cache of all messages between these uids.

folder :

a CamelFolder

start_uid :

the start message UID

end_uid :

the end message UID

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE if success, FALSE if there are any errors.

Since 3.4


camel_folder_purge_message_cache ()

void                camel_folder_purge_message_cache    (CamelFolder *folder,
                                                         gchar *start_uid,
                                                         gchar *end_uid,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Delete the local cache of all messages between these uids.

When the operation is finished, callback will be called. You can then call camel_folder_purge_message_cache_finish() to get the result of the operation.

folder :

a CamelFolder

start_uid :

the start message UID

end_uid :

the end message UID

io_priority :

the I/O priority of the request

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.4


camel_folder_purge_message_cache_finish ()

gboolean            camel_folder_purge_message_cache_finish
                                                        (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with camel_folder_purge_message_cache().

folder :

a CamelFolder

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE if cache is deleted, FALSE if there are any errors

Since 3.4


camel_folder_refresh_info_sync ()

gboolean            camel_folder_refresh_info_sync      (CamelFolder *folder,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronizes a folder's summary with its backing store.

folder :

a CamelFolder

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.0


camel_folder_refresh_info ()

void                camel_folder_refresh_info           (CamelFolder *folder,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously synchronizes a folder's summary with its backing store.

When the operation is finished, callback will be called. You can then call camel_folder_refresh_info_finish() to get the result of the operation.

folder :

a CamelFolder

io_priority :

the I/O priority of the request

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.2


camel_folder_refresh_info_finish ()

gboolean            camel_folder_refresh_info_finish    (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with camel_folder_refresh_info().

folder :

a CamelFolder

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.2


camel_folder_synchronize_sync ()

gboolean            camel_folder_synchronize_sync       (CamelFolder *folder,
                                                         gboolean expunge,
                                                         GCancellable *cancellable,
                                                         GError **error);

Synchronizes any changes that have been made to folder to its backing store, optionally expunging deleted messages as well.

folder :

a CamelFolder

expunge :

whether to expunge after synchronizing

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.0


camel_folder_synchronize ()

void                camel_folder_synchronize            (CamelFolder *folder,
                                                         gboolean expunge,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Synchronizes any changes that have been made to folder to its backing store asynchronously, optionally expunging deleted messages as well.

When the operation is finished, callback will be called. You can then call camel_folder_synchronize_finish() to get the result of the operation.

folder :

a CamelFolder

expunge :

whether to expunge after synchronizing

io_priority :

the I/O priority of the request

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.0


camel_folder_synchronize_finish ()

gboolean            camel_folder_synchronize_finish     (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with camel_folder_synchronize().

folder :

a CamelFolder

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on sucess, FALSE on error

Since 3.0


camel_folder_synchronize_message_sync ()

gboolean            camel_folder_synchronize_message_sync
                                                        (CamelFolder *folder,
                                                         const gchar *message_uid,
                                                         GCancellable *cancellable,
                                                         GError **error);

Ensure that a message identified by message_uid has been synchronized in folder so that calling camel_folder_get_message() on it later will work in offline mode.

folder :

a CamelFolder

message_uid :

a message UID

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.0


camel_folder_synchronize_message ()

void                camel_folder_synchronize_message    (CamelFolder *folder,
                                                         const gchar *message_uid,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

camel_folder_synchronize_message_finish ()

gboolean            camel_folder_synchronize_message_finish
                                                        (CamelFolder *folder,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes the operation started with camel_folder_synchronize_message().

folder :

a CamelFolder

result :

a GAsyncResult

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.0


camel_folder_transfer_messages_to_sync ()

gboolean            camel_folder_transfer_messages_to_sync
                                                        (CamelFolder *source,
                                                         GPtrArray *message_uids,
                                                         CamelFolder *destination,
                                                         gboolean delete_originals,
                                                         GPtrArray **transferred_uids,
                                                         GCancellable *cancellable,
                                                         GError **error);

Copies or moves messages from one folder to another. If the source and destination folders have the same parent_store, this may be more efficient than using camel_folder_append_message_sync().

source :

the source CamelFolder

message_uids :

message UIDs in source

destination :

the destination CamelFolder

delete_originals :

whether or not to delete the original messages

transferred_uids :

if non-NULL, the UIDs of the resulting messages in destination will be stored here, if known.

cancellable :

optional GCancellable object, or NULL

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on failure

Since 3.0


camel_folder_transfer_messages_to ()

void                camel_folder_transfer_messages_to   (CamelFolder *source,
                                                         GPtrArray *message_uids,
                                                         CamelFolder *destination,
                                                         gboolean delete_originals,
                                                         gint io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously copies or moves messages from one folder to another. If the source or destination folders have the same parent store, this may be more efficient than using camel_folder_append_message().

When the operation is finished, callback will be called. You can then call camel_folder_transfer_messages_to_finish() to get the result of the operation.

source :

the source CamelFolder

message_uids :

message UIDs in source

destination :

the destination CamelFolder

delete_originals :

whether or not to delete the original messages

io_priority :

the I/O priority of the request

cancellable :

optional GCancellable object, or NULL

callback :

a GAsyncReadyCallback to call when the request is satisfied

user_data :

data to pass to the callback function

Since 3.0


camel_folder_transfer_messages_to_finish ()

gboolean            camel_folder_transfer_messages_to_finish
                                                        (CamelFolder *source,
                                                         GAsyncResult *result,
                                                         GPtrArray **transferred_uids,
                                                         GError **error);

Finishes the operation started with camel_folder_transfer_messages_to().

source :

a CamelFolder

result :

a GAsyncResult

transferred_uids :

if non-NULL, the UIDs of the resulting messages in destination will be stored here, if known.

error :

return location for a GError, or NULL

Returns :

TRUE on success, FALSE on error

Since 3.0


camel_folder_change_info_new ()

CamelFolderChangeInfo * camel_folder_change_info_new    (void);

Create a new folder change info structure.

Change info structures are not MT-SAFE and must be locked for exclusive access externally.

Returns :

a new CamelFolderChangeInfo

camel_folder_change_info_clear ()

void                camel_folder_change_info_clear      (CamelFolderChangeInfo *info);

Empty out the change info; called after changes have been processed.


camel_folder_change_info_free ()

void                camel_folder_change_info_free       (CamelFolderChangeInfo *info);

Free memory associated with the folder change info lists.


camel_folder_change_info_changed ()

gboolean            camel_folder_change_info_changed    (CamelFolderChangeInfo *info);

Gets whether or not there have been any changes.

info :

a CamelFolderChangeInfo

Returns :

TRUE if the changeset contains any changes or FALSE otherwise

camel_folder_change_info_add_source ()

void                camel_folder_change_info_add_source (CamelFolderChangeInfo *info,
                                                         const gchar *uid);

Add a source uid for generating a changeset.

info :

a CamelFolderChangeInfo

uid :

a uid

camel_folder_change_info_add_source_list ()

void                camel_folder_change_info_add_source_list
                                                        (CamelFolderChangeInfo *info,
                                                         const GPtrArray *list);

Add a list of source uid's for generating a changeset.

info :

a CamelFolderChangeInfo

list :

a list of uids

camel_folder_change_info_add_update ()

void                camel_folder_change_info_add_update (CamelFolderChangeInfo *info,
                                                         const gchar *uid);

Add a uid from the updated list, used to generate a changeset diff.

info :

a CamelFolderChangeInfo

uid :

a uid

camel_folder_change_info_add_update_list ()

void                camel_folder_change_info_add_update_list
                                                        (CamelFolderChangeInfo *info,
                                                         const GPtrArray *list);

Add a list of uid's from the updated list.

info :

a CamelFolderChangeInfo

list :

a list of uids

camel_folder_change_info_build_diff ()

void                camel_folder_change_info_build_diff (CamelFolderChangeInfo *info);

Compare the source uid set to the updated uid set and generate the differences into the added and removed lists.


camel_folder_change_info_cat ()

void                camel_folder_change_info_cat        (CamelFolderChangeInfo *info,
                                                         CamelFolderChangeInfo *src);

Concatenate one change info onto antoher. Can be used to copy them too.

info :

a CamelFolderChangeInfo to append to

src :

a CamelFolderChangeInfo to append from

camel_folder_change_info_add_uid ()

void                camel_folder_change_info_add_uid    (CamelFolderChangeInfo *info,
                                                         const gchar *uid);

Add a new uid to the changeinfo.

info :

a CamelFolderChangeInfo

uid :

a uid

camel_folder_change_info_remove_uid ()

void                camel_folder_change_info_remove_uid (CamelFolderChangeInfo *info,
                                                         const gchar *uid);

Add a uid to the removed uid list.

info :

a CamelFolderChangeInfo

uid :

a uid

camel_folder_change_info_change_uid ()

void                camel_folder_change_info_change_uid (CamelFolderChangeInfo *info,
                                                         const gchar *uid);

Add a uid to the changed uid list.

info :

a CamelFolderChangeInfo

uid :

a uid

camel_folder_change_info_recent_uid ()

void                camel_folder_change_info_recent_uid (CamelFolderChangeInfo *info,
                                                         const gchar *uid);

Add a recent uid to the changedinfo. This will also add the uid to the uid_filter array for potential filtering

info :

a CamelFolderChangeInfo

uid :

a uid

enum CamelFolderLock

typedef enum {
	CAMEL_FOLDER_CHANGE_LOCK,
	CAMEL_FOLDER_REC_LOCK
} CamelFolderLock;

CAMEL_FOLDER_CHANGE_LOCK

CAMEL_FOLDER_REC_LOCK

Since 2.32


camel_folder_lock ()

void                camel_folder_lock                   (CamelFolder *folder,
                                                         CamelFolderLock lock);

Locks folder's lock. Unlock it with camel_folder_unlock().

folder :

a CamelFolder

lock :

lock type to lock

Since 2.32


camel_folder_unlock ()

void                camel_folder_unlock                 (CamelFolder *folder,
                                                         CamelFolderLock lock);

Unlocks folder's lock, previously locked with camel_folder_lock().

folder :

a CamelFolder

lock :

lock type to unlock

Since 2.32

Property Details

The "description" property

  "description"              gchar*                : Read / Write / Construct

The folder's description.

Default value: NULL


The "display-name" property

  "display-name"             gchar*                : Read / Write / Construct

The folder's display name.

Default value: NULL


The "full-name" property

  "full-name"                gchar*                : Read / Write / Construct

The folder's fully qualified name.

Default value: NULL


The "parent-store" property

  "parent-store"             CamelStore*           : Read / Write / Construct Only

The CamelStore to which the folder belongs.

Signal Details

The "changed" signal

void                user_function                      (CamelFolder *folder,
                                                        gpointer     arg1,
                                                        gpointer     user_data)      : Run First

folder :

the CamelFolder which emitted the signal

user_data :

user data set when the signal handler was connected.

The "deleted" signal

void                user_function                      (CamelFolder *folder,
                                                        gpointer     user_data)      : Run First

folder :

the CamelFolder which emitted the signal

user_data :

user data set when the signal handler was connected.

The "renamed" signal

void                user_function                      (CamelFolder *folder,
                                                        gchar       *old_name,
                                                        gpointer     user_data)      : Run First

folder :

the CamelFolder which emitted the signal

old_name :

the previous folder name

user_data :

user data set when the signal handler was connected.