camel_store_error_quark ()

GQuark
camel_store_error_quark (void);

camel_store_folder_created ()

void
camel_store_folder_created (CamelStore *store,
                            CamelFolderInfo *folder_info);

Emits the “folder-created” signal from an idle source on the main loop. The idle source's priority is G_PRIORITY_HIGH_IDLE.

This function is only intended for Camel providers.

Since: 2.32

camel_store_folder_deleted ()

void
camel_store_folder_deleted (CamelStore *store,
                            CamelFolderInfo *folder_info);

Emits the “folder-deleted” signal from an idle source on the main loop. The idle source's priority is G_PRIORITY_HIGH_IDLE.

This function is only intended for Camel providers.

Since: 2.32

camel_store_folder_opened ()

void
camel_store_folder_opened (CamelStore *store,
                           CamelFolder *folder);

Emits the “folder-opened” signal from an idle source on the main loop. The idle source's priority is G_PRIORITY_HIGH_IDLE.

This function is only intended for Camel providers.

Since: 3.0

camel_store_folder_renamed ()

void
camel_store_folder_renamed (CamelStore *store,
                            const gchar *old_name,
                            CamelFolderInfo *folder_info);

Emits the “folder-renamed” signal from an idle source on the main loop. The idle source's priority is G_PRIORITY_HIGH_IDLE.

This function is only intended for Camel providers.

Since: 2.32

camel_store_folder_info_stale ()

void
camel_store_folder_info_stale (CamelStore *store);

Emits the “folder-info-stale” signal from an idle source on the main loop. The idle source's priority is G_PRIORITY_LOW.

See the “folder-info-stale” documentation for details on when to use this signal.

This function is only intended for Camel providers.

Since: 3.10

camel_folder_info_new ()

CamelFolderInfo *
camel_folder_info_new (void);

Allocates a new CamelFolderInfo instance. Free it with camel_folder_info_free().

Since: 2.22

camel_folder_info_free ()

void
camel_folder_info_free (CamelFolderInfo *fi);

Frees fi .

camel_folder_info_build ()

CamelFolderInfo *
camel_folder_info_build (GPtrArray *folders,
                         const gchar *namespace_,
                         gchar separator,
                         gboolean short_names);

This takes an array of folders and attaches them together according to the hierarchy described by their full_names and separator . If namespace_ is non-NULL, then it will be ignored as a full_name prefix, for purposes of comparison. If necessary, camel_folder_info_build() will create additional CamelFolderInfo with NULL urls to fill in gaps in the tree. The value of short_names is used in constructing the names of these intermediate folders.

NOTE: This is deprected, do not use this. FIXME: remove this/move it to imap, which is the only user of it now.

camel_folder_info_clone ()

CamelFolderInfo *
camel_folder_info_clone (CamelFolderInfo *fi);

Clones fi recursively.

camel_store_can_refresh_folder ()

gboolean
camel_store_can_refresh_folder (CamelStore *store,
                                CamelFolderInfo *info,
                                GError **error);

Returns if this folder (param info) should be checked for new mail or not. It should not look into sub infos (info->child) or next infos, it should return value only for the actual folder info. Default behavior is that all Inbox folders are intended to be refreshed.

Since: 2.22

camel_store_get_folder_sync ()

CamelFolder *
camel_store_get_folder_sync (CamelStore *store,
                             const gchar *folder_name,
                             CamelStoreGetFolderFlags flags,
                             GCancellable *cancellable,
                             GError **error);

Gets a specific folder object from store by name.

Since: 3.0

camel_store_get_folder ()

void
camel_store_get_folder (CamelStore *store,
                        const gchar *folder_name,
                        CamelStoreGetFolderFlags flags,
                        gint io_priority,
                        GCancellable *cancellable,
                        GAsyncReadyCallback callback,
                        gpointer user_data);

Asynchronously gets a specific folder object from store by name.

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

Since: 3.0

camel_store_get_folder_finish ()

CamelFolder *
camel_store_get_folder_finish (CamelStore *store,
                               GAsyncResult *result,
                               GError **error);

Finishes the operation started with camel_store_get_folder().

Since: 3.0

camel_store_get_folder_info_sync ()

CamelFolderInfo *
camel_store_get_folder_info_sync (CamelStore *store,
                                  const gchar *top,
                                  CamelStoreGetFolderInfoFlags flags,
                                  GCancellable *cancellable,
                                  GError **error);

This fetches information about the folder structure of store , starting with top , and returns a tree of CamelFolderInfo structures. If flags includes CAMEL_STORE_FOLDER_INFO_SUBSCRIBED, only subscribed folders will be listed. If the store doesn't support subscriptions, then it will list all folders. If flags includes CAMEL_STORE_FOLDER_INFO_RECURSIVE, the returned tree will include all levels of hierarchy below top . If not, it will only include the immediate subfolders of top . If flags includes CAMEL_STORE_FOLDER_INFO_FAST, the unread_message_count fields of some or all of the structures may be set to -1, if the store cannot determine that information quickly. If flags includes CAMEL_STORE_FOLDER_INFO_NO_VIRTUAL, don't include special virtual folders (such as vTrash or vJunk).

The returned CamelFolderInfo tree should be freed with camel_folder_info_free().

The CAMEL_STORE_FOLDER_INFO_FAST flag should be considered deprecated; most backends will behave the same whether it is supplied or not. The only guaranteed way to get updated folder counts is to both open the folder and invoke refresh_info() it.

Since: 3.0

camel_store_get_folder_info ()

void
camel_store_get_folder_info (CamelStore *store,
                             const gchar *top,
                             CamelStoreGetFolderInfoFlags flags,
                             gint io_priority,
                             GCancellable *cancellable,
                             GAsyncReadyCallback callback,
                             gpointer user_data);

Asynchronously fetches information about the folder structure of store , starting with top . For details of the behavior, see camel_store_get_folder_info_sync().

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

Since: 3.0

camel_store_get_folder_info_finish ()

CamelFolderInfo *
camel_store_get_folder_info_finish (CamelStore *store,
                                    GAsyncResult *result,
                                    GError **error);

Finishes the operation started with camel_store_get_folder_info(). The returned CamelFolderInfo tree should be freed with camel_folder_info_free().

Since: 3.0

camel_store_get_inbox_folder_sync ()

CamelFolder *
camel_store_get_inbox_folder_sync (CamelStore *store,
                                   GCancellable *cancellable,
                                   GError **error);

Gets the folder in store into which new mail is delivered.

Since: 3.0

camel_store_get_inbox_folder ()

void
camel_store_get_inbox_folder (CamelStore *store,
                              gint io_priority,
                              GCancellable *cancellable,
                              GAsyncReadyCallback callback,
                              gpointer user_data);

Asynchronously gets the folder in store into which new mail is delivered.

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

Since: 3.0

camel_store_get_inbox_folder_finish ()

CamelFolder *
camel_store_get_inbox_folder_finish (CamelStore *store,
                                     GAsyncResult *result,
                                     GError **error);

Finishes the operation started with camel_store_get_inbox_folder().

Since: 3.0

camel_store_get_junk_folder_sync ()

CamelFolder *
camel_store_get_junk_folder_sync (CamelStore *store,
                                  GCancellable *cancellable,
                                  GError **error);

Gets the folder in store into which junk is delivered.

Since: 3.0

camel_store_get_junk_folder ()

void
camel_store_get_junk_folder (CamelStore *store,
                             gint io_priority,
                             GCancellable *cancellable,
                             GAsyncReadyCallback callback,
                             gpointer user_data);

Asynchronously gets the folder in store into which junk is delivered.

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

Since: 3.0

camel_store_get_junk_folder_finish ()

CamelFolder *
camel_store_get_junk_folder_finish (CamelStore *store,
                                    GAsyncResult *result,
                                    GError **error);

Finishes the operation started with camel_store_get_junk_folder().

Since: 3.0

camel_store_get_trash_folder_sync ()

CamelFolder *
camel_store_get_trash_folder_sync (CamelStore *store,
                                   GCancellable *cancellable,
                                   GError **error);

Gets the folder in store into which trash is delivered.

Since: 3.0

camel_store_get_trash_folder ()

void
camel_store_get_trash_folder (CamelStore *store,
                              gint io_priority,
                              GCancellable *cancellable,
                              GAsyncReadyCallback callback,
                              gpointer user_data);

Asynchronously gets the folder in store into which trash is delivered.

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

Since: 3.0

camel_store_get_trash_folder_finish ()

CamelFolder *
camel_store_get_trash_folder_finish (CamelStore *store,
                                     GAsyncResult *result,
                                     GError **error);

Finishes the operation started with camel_store_get_trash_folder().

Since: 3.0

camel_store_create_folder_sync ()

CamelFolderInfo *
camel_store_create_folder_sync (CamelStore *store,
                                const gchar *parent_name,
                                const gchar *folder_name,
                                GCancellable *cancellable,
                                GError **error);

Creates a new folder as a child of an existing folder. parent_name can be NULL to create a new top-level folder. The returned CamelFolderInfo struct should be freed with camel_folder_info_free().

Since: 3.0

camel_store_create_folder ()

void
camel_store_create_folder (CamelStore *store,
                           const gchar *parent_name,
                           const gchar *folder_name,
                           gint io_priority,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data);

Asynchronously creates a new folder as a child of an existing folder. parent_name can be NULL to create a new top-level folder.

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

Since: 3.0

camel_store_create_folder_finish ()

CamelFolderInfo *
camel_store_create_folder_finish (CamelStore *store,
                                  GAsyncResult *result,
                                  GError **error);

Finishes the operation started with camel_store_create_folder(). The returned CamelFolderInfo struct should be freed with camel_folder_info_free().

Since: 3.0

camel_store_delete_folder_sync ()

gboolean
camel_store_delete_folder_sync (CamelStore *store,
                                const gchar *folder_name,
                                GCancellable *cancellable,
                                GError **error);

Deletes the folder described by folder_name . The folder must be empty.

Since: 3.0

camel_store_delete_folder ()

void
camel_store_delete_folder (CamelStore *store,
                           const gchar *folder_name,
                           gint io_priority,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data);

Asynchronously deletes the folder described by folder_name . The folder must be empty.

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

Since: 3.0

camel_store_delete_folder_finish ()

gboolean
camel_store_delete_folder_finish (CamelStore *store,
                                  GAsyncResult *result,
                                  GError **error);

Finishes the operation started with camel_store_delete_folder().

Since: 3.0

camel_store_rename_folder_sync ()

gboolean
camel_store_rename_folder_sync (CamelStore *store,
                                const gchar *old_name,
                                const gchar *new_name,
                                GCancellable *cancellable,
                                GError **error);

Renames the folder described by old_name to new_name .

Since: 3.0

camel_store_rename_folder ()

void
camel_store_rename_folder (CamelStore *store,
                           const gchar *old_name,
                           const gchar *new_name,
                           gint io_priority,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data);

Asynchronously renames the folder described by old_name to new_name .

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

Since: 3.0

camel_store_rename_folder_finish ()

gboolean
camel_store_rename_folder_finish (CamelStore *store,
                                  GAsyncResult *result,
                                  GError **error);

Finishes the operation started with camel_store_rename_folder().

Since: 3.0

camel_store_synchronize_sync ()

gboolean
camel_store_synchronize_sync (CamelStore *store,
                              gboolean expunge,
                              GCancellable *cancellable,
                              GError **error);

Synchronizes any changes that have been made to store and its folders with the real store.

Since: 3.0

camel_store_synchronize ()

void
camel_store_synchronize (CamelStore *store,
                         gboolean expunge,
                         gint io_priority,
                         GCancellable *cancellable,
                         GAsyncReadyCallback callback,
                         gpointer user_data);

Synchronizes any changes that have been made to store and its folders with the real store asynchronously.

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

Since: 3.0

camel_store_synchronize_finish ()

gboolean
camel_store_synchronize_finish (CamelStore *store,
                                GAsyncResult *result,
                                GError **error);

Finishes the operation started with camel_store_synchronize().

Since: 3.0

camel_store_initial_setup_sync ()

gboolean
camel_store_initial_setup_sync (CamelStore *store,
                                GHashTable **out_save_setup,
                                GCancellable *cancellable,
                                GError **error);

Runs initial setup for the store . It's meant to preset some values the first time the account connects to the server after it had been created. The function should return TRUE even if it didn't populate anything. The default implementation does just that.

The save_setup result, if not NULL, should be freed using g_hash_table_destroy(). It's not an error to have it NULL, it only means the store doesn't have anything to save. Both the key and the value in the hash are newly allocated UTF-8 strings, owned by the hash table.

The store advertises support of this function by including CAMEL_STORE_SUPPORTS_INITIAL_SETUP in CamelStore::flags.

Since: 3.20

camel_store_initial_setup ()

void
camel_store_initial_setup (CamelStore *store,
                           gint io_priority,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data);

Runs initial setup for the store asynchronously.

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

The store advertises support of this function by including CAMEL_STORE_SUPPORTS_INITIAL_SETUP in CamelStore::flags.

Since: 3.20

camel_store_initial_setup_finish ()

gboolean
camel_store_initial_setup_finish (CamelStore *store,
                                  GAsyncResult *result,
                                  GHashTable **out_save_setup,
                                  GError **error);

Finishes the operation started with camel_store_initial_setup().

The save_setup result, if not NULL, should be freed using g_hash_table_destroy(). It's not an error to have it NULL, it only means the store doesn't have anything to save.

Since: 3.20

camel_store_maybe_run_db_maintenance ()

gboolean
camel_store_maybe_run_db_maintenance (CamelStore *store,
                                      GError **error);

Checks the state of the current CamelDB used for the store and eventually runs maintenance routines on it.

Since: 3.16

CAMEL_STORE_ERROR

#define             CAMEL_STORE_ERROR

Since: 2.32

CAMEL_STORE_SETUP_ARCHIVE_FOLDER

#define CAMEL_STORE_SETUP_ARCHIVE_FOLDER "Account:Mail Account:archive-folder:f"

CAMEL_STORE_SETUP_DRAFTS_FOLDER

#define CAMEL_STORE_SETUP_DRAFTS_FOLDER		"Submission:Mail Composition:drafts-folder:f"

CAMEL_STORE_SETUP_SENT_FOLDER

#define CAMEL_STORE_SETUP_SENT_FOLDER		"Submission:Mail Submission:sent-folder:f"

CAMEL_STORE_SETUP_TEMPLATES_FOLDER

#define CAMEL_STORE_SETUP_TEMPLATES_FOLDER "Submission:Mail Composition:templates-folder:f"

enum CamelStoreError

Since: 2.32

enum CamelStoreGetFolderFlags

The “folder-created” signal

void
user_function (CamelStore *camelstore,
               gpointer    arg1,
               gpointer    user_data)

Flags: Run First

The “folder-deleted” signal

void
user_function (CamelStore *camelstore,
               gpointer    arg1,
               gpointer    user_data)

Flags: Run First

The “folder-info-stale” signal

void
user_function (CamelStore *store,
               gpointer    user_data)

This signal indicates significant changes have occurred to the folder hierarchy of store , and that previously fetched CamelFolderInfo data should be considered stale.

Applications should handle this signal by replacing cached CamelFolderInfo data for store with fresh data by way of camel_store_get_folder_info().

More often than not this signal will be emitted as a result of user preference changes rather than actual server-side changes. For example, a user may change a preference that reveals a set of folders previously hidden from view, or that alters whether to augment the store with virtual Junk and Trash folders.

Flags: Run First

The “folder-opened” signal

void
user_function (CamelStore  *camelstore,
               CamelFolder *arg1,
               gpointer     user_data)

Flags: Run First

The “folder-renamed” signal

void
user_function (CamelStore *camelstore,
               gchar      *arg1,
               gpointer    arg2,
               gpointer    user_data)

Flags: Run First