## ECalBackend

ECalBackend — An abstract class for implementing calendar backends

## Synopsis

    #include <libedata-cal/libedata-cal.h>

    #define             CLIENT_BACKEND_PROPERTY_CAPABILITIES
    #define             CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS
    #define             CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS
    #define             CAL_BACKEND_PROPERTY_DEFAULT_OBJECT
    #define             CAL_BACKEND_PROPERTY_REVISION
    struct              ECalBackend;
    struct              ECalBackendClass;
    icalcomponent_kind  e_cal_backend_get_kind              (ECalBackend *backend);
    EDataCal *          e_cal_backend_ref_data_cal          (ECalBackend *backend);
    void                e_cal_backend_set_data_cal          (ECalBackend *backend,
                                                             EDataCal *data_cal);
    GProxyResolver *    e_cal_backend_ref_proxy_resolver    (ECalBackend *backend);
    ESourceRegistry *   e_cal_backend_get_registry          (ECalBackend *backend);
    gboolean            e_cal_backend_get_writable          (ECalBackend *backend);
    void                e_cal_backend_set_writable          (ECalBackend *backend,
                                                             gboolean writable);
    gboolean            e_cal_backend_is_opened             (ECalBackend *backend);
    gboolean            e_cal_backend_is_readonly           (ECalBackend *backend);
    const gchar *       e_cal_backend_get_cache_dir         (ECalBackend *backend);
    gchar *             e_cal_backend_dup_cache_dir         (ECalBackend *backend);
    void                e_cal_backend_set_cache_dir         (ECalBackend *backend,
                                                             const gchar *cache_dir);
    gchar *             e_cal_backend_create_cache_filename (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *filename,
                                                             gint fileindex);
    void                e_cal_backend_add_view              (ECalBackend *backend,
                                                             EDataCalView *view);
    void                e_cal_backend_remove_view           (ECalBackend *backend,
                                                             EDataCalView *view);
    GList *             e_cal_backend_list_views            (ECalBackend *backend);
    gchar *             e_cal_backend_get_backend_property  (ECalBackend *backend,
                                                             const gchar *prop_name);
    gboolean            e_cal_backend_open_sync             (ECalBackend *backend,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_open                  (ECalBackend *backend,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_open_finish           (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    gboolean            e_cal_backend_refresh_sync          (ECalBackend *backend,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_refresh               (ECalBackend *backend,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_refresh_finish        (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    gchar *             e_cal_backend_get_object_sync       (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_get_object            (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gchar *             e_cal_backend_get_object_finish     (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    gboolean            e_cal_backend_get_object_list_sync  (ECalBackend *backend,
                                                             const gchar *query,
                                                             GQueue *out_objects,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_get_object_list       (ECalBackend *backend,
                                                             const gchar *query,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_get_object_list_finish
                                                            (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GQueue *out_objects,
                                                             GError **error);
    gboolean            e_cal_backend_get_free_busy_sync    (ECalBackend *backend,
                                                             time_t start,
                                                             time_t end,
                                                             const gchar * const *users,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_get_free_busy         (ECalBackend *backend,
                                                             time_t start,
                                                             time_t end,
                                                             const gchar * const *users,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_get_free_busy_finish  (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    gboolean            e_cal_backend_create_objects_sync   (ECalBackend *backend,
                                                             const gchar * const *calobjs,
                                                             GQueue *out_uids,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_create_objects        (ECalBackend *backend,
                                                             const gchar * const *calobjs,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_create_objects_finish (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GQueue *out_uids,
                                                             GError **error);
    gboolean            e_cal_backend_modify_objects_sync   (ECalBackend *backend,
                                                             const gchar * const *calobjs,
                                                             ECalObjModType mod,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_modify_objects        (ECalBackend *backend,
                                                             const gchar * const *calobjs,
                                                             ECalObjModType mod,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_modify_objects_finish (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    gboolean            e_cal_backend_remove_objects_sync   (ECalBackend *backend,
                                                             GList *component_ids,
                                                             ECalObjModType mod,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_remove_objects        (ECalBackend *backend,
                                                             GList *component_ids,
                                                             ECalObjModType mod,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_remove_objects_finish (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    gboolean            e_cal_backend_receive_objects_sync  (ECalBackend *backend,
                                                             const gchar *calobj,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_receive_objects       (ECalBackend *backend,
                                                             const gchar *calobj,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_receive_objects_finish
                                                            (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    gchar *             e_cal_backend_send_objects_sync     (ECalBackend *backend,
                                                             const gchar *calobj,
                                                             GQueue *out_users,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_send_objects          (ECalBackend *backend,
                                                             const gchar *calobj,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gchar *             e_cal_backend_send_objects_finish   (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GQueue *out_users,
                                                             GError **error);
    gboolean            e_cal_backend_get_attachment_uris_sync
                                                            (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GQueue *out_attachment_uris,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_get_attachment_uris   (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_get_attachment_uris_finish
                                                            (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GQueue *out_attachment_uris,
                                                             GError **error);
    gboolean            e_cal_backend_discard_alarm_sync    (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             const gchar *alarm_uid,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_discard_alarm         (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             const gchar *alarm_uid,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_discard_alarm_finish  (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    gchar *             e_cal_backend_get_timezone_sync     (ECalBackend *backend,
                                                             const gchar *tzid,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_get_timezone          (ECalBackend *backend,
                                                             const gchar *tzid,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gchar *             e_cal_backend_get_timezone_finish   (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    gboolean            e_cal_backend_add_timezone_sync     (ECalBackend *backend,
                                                             const gchar *tzobject,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_add_timezone          (ECalBackend *backend,
                                                             const gchar *tzobject,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            e_cal_backend_add_timezone_finish   (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);
    void                e_cal_backend_start_view            (ECalBackend *backend,
                                                             EDataCalView *view);
    void                e_cal_backend_stop_view             (ECalBackend *backend,
                                                             EDataCalView *view);
    void                e_cal_backend_notify_component_created
                                                            (ECalBackend *backend,
                                                             ECalComponent *component);
    void                e_cal_backend_notify_component_modified
                                                            (ECalBackend *backend,
                                                             ECalComponent *old_component,
                                                             ECalComponent *new_component);
    void                e_cal_backend_notify_component_removed
                                                            (ECalBackend *backend,
                                                             const ECalComponentId *id,
                                                             ECalComponent *old_component,
                                                             ECalComponent *new_component);
    void                e_cal_backend_notify_error          (ECalBackend *backend,
                                                             const gchar *message);
    void                e_cal_backend_notify_property_changed
                                                            (ECalBackend *backend,
                                                             const gchar *prop_name,
                                                             const gchar *prop_value);
    void                e_cal_backend_empty_cache           (ECalBackend *backend,
                                                             struct _ECalBackendCache *cache);
    GSimpleAsyncResult * e_cal_backend_prepare_for_completion
                                                            (ECalBackend *backend,
                                                             guint opid,
                                                             GQueue **result_queue);

## Description

This is the main server facing API for interfacing with calendar backends, calendar backends must implement methods on this class.

## Details

### CLIENT_BACKEND_PROPERTY_CAPABILITIES

    #define             CLIENT_BACKEND_PROPERTY_CAPABILITIES

FIXME: Document me.

Since 3.2

### CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS

    #define             CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS

FIXME: Document me.

Since 3.2

### CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS

    #define             CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS

FIXME: Document me.

Since 3.2

### CAL_BACKEND_PROPERTY_DEFAULT_OBJECT

    #define             CAL_BACKEND_PROPERTY_DEFAULT_OBJECT

FIXME: Document me.

Since 3.2

### CAL_BACKEND_PROPERTY_REVISION

    #define CAL_BACKEND_PROPERTY_REVISION			"revision"

The current overall revision string, this can be used as a quick check to see if data has changed at all since the last time the calendar revision was observed.

Since 3.4

### struct ECalBackend

    struct ECalBackend {
    };

Contains only private data that should be read and manipulated using the functions below.

### struct ECalBackendClass

    struct ECalBackendClass {
    	/* Set this to TRUE to use a serial dispatch queue, instead
    	 * of a concurrent dispatch queue.  A serial dispatch queue
    	 * executes one method at a time in the order in which they
    	 * were called.  This is generally slower than a concurrent
    	 * dispatch queue, but helps avoid thread-safety issues. */
    	gboolean use_serial_dispatch_queue;

    	/* Virtual methods */
    	gchar *		(*get_backend_property) (ECalBackend *backend,
    						 const gchar *prop_name);

    	void		(*open)			(ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 gboolean only_if_exists);

    	void		(*refresh)		(ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable);
    	void		(*get_object)		(ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const gchar *uid,
    						 const gchar *rid);
    	void		(*get_object_list) (ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const gchar *sexp);
    	void		(*get_free_busy) (ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const GSList *users,
    						 time_t start,
    						 time_t end);
    	void		(*create_objects) (ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const GSList *calobjs);
    	void		(*modify_objects) (ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const GSList *calobjs,
    						 ECalObjModType mod);
    	void		(*remove_objects) (ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const GSList *ids,
    						 ECalObjModType mod);
    	void		(*receive_objects) (ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const gchar *calobj);
    	void		(*send_objects)		(ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const gchar *calobj);
    	void		(*get_attachment_uris) (ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const gchar *uid,
    						 const gchar *rid);
    	void		(*discard_alarm) (ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const gchar *uid,
    						 const gchar *rid,
    						 const gchar *auid);
    	void		(*get_timezone)		(ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const gchar *tzid);
    	void		(*add_timezone)		(ECalBackend *backend,
    						 EDataCal *cal,
    						 guint32 opid,
    						 GCancellable *cancellable,
    						 const gchar *tzobject);

    	void		(*start_view)		(ECalBackend *backend,
    						 EDataCalView *view);
    	void		(*stop_view)		(ECalBackend *backend,
    						 EDataCalView *view);

    	/* Signals */
    	void		(*closed)		(ECalBackend *backend,
    						 const gchar *sender);
    	void		(*shutdown)		(ECalBackend *backend);
    };

Class structure for the ECalBackend class.

These virtual methods must be implemented when writing a calendar backend.

gboolean `use_serial_dispatch_queue`; | Whether a serial dispatch queue should be used for this backend or not.
`get_backend_property` () | Fetch a property value by name from the backend
`open` () | Open the backend
`refresh` () | Refresh the backend
`get_object` () | Fetch a calendar object
`get_object_list` () | FIXME: Document me
`get_free_busy` () | FIXME: Document me
`create_objects` () | FIXME: Document me
`modify_objects` () | FIXME: Document me
`remove_objects` () | FIXME: Document me
`receive_objects` () | FIXME: Document me
`send_objects` () | FIXME: Document me
`get_attachment_uris` () | FIXME: Document me
`discard_alarm` () | FIXME: Document me
`get_timezone` () | FIXME: Document me
`add_timezone` () | FIXME: Document me
`start_view` () | Start up the specified view
`stop_view` () | Stop the specified view
`closed` () | A signal notifying that the backend was closed
`shutdown` () | A signal notifying that the backend is being shut down

### e_cal_backend_get_kind ()

    icalcomponent_kind  e_cal_backend_get_kind              (ECalBackend *backend);

Gets the kind of components the given backend stores.

`backend` : | an ECalBackend
Returns : | The kind of components for this backend.

### e_cal_backend_ref_data_cal ()

    EDataCal *          e_cal_backend_ref_data_cal          (ECalBackend *backend);

Returns the EDataCal for `backend`. The EDataCal is essentially the glue between incoming D-Bus requests and `backend`'s native API.

An EDataCal should be set only once after `backend` is first created. If an EDataCal has not yet been set, the function returns `NULL`.

The returned EDataCal is referenced for thread-safety and must be unreferenced with `g_object_unref()` when finished with it.

`backend` : | an ECalBackend
Returns : | an EDataCal, or `NULL`

Since 3.10

### e_cal_backend_set_data_cal ()

    void                e_cal_backend_set_data_cal          (ECalBackend *backend,
                                                             EDataCal *data_cal);

Sets the EDataCal for `backend`. The EDataCal is essentially the glue between incoming D-Bus requests and `backend`'s native API.

An EDataCal should be set only once after `backend` is first created.

`backend` : | an ECalBackend
`data_cal` : | an EDataCal

Since 3.10

### e_cal_backend_ref_proxy_resolver ()

    GProxyResolver *    e_cal_backend_ref_proxy_resolver    (ECalBackend *backend);

Returns the GProxyResolver for `backend` (if applicable), as indicated by the "proxy-uid" of `backend`'s "source" or one of its ancestors.

The returned GProxyResolver is referenced for thread-safety and must be unreferenced with `g_object_unref()` when finished with it.

`backend` : | an ECalBackend
Returns : | a GProxyResolver, or `NULL`

Since 3.12

### e_cal_backend_get_registry ()

    ESourceRegistry *   e_cal_backend_get_registry          (ECalBackend *backend);

Returns the data source registry to which "source" belongs.

`backend` : | an ECalBackend
Returns : | an ESourceRegistry

Since 3.6

### e_cal_backend_get_writable ()

    gboolean            e_cal_backend_get_writable          (ECalBackend *backend);

Returns whether `backend` will accept changes to its data content.

`backend` : | an ECalBackend
Returns : | whether `backend` is writable

Since 3.8

### e_cal_backend_set_writable ()

    void                e_cal_backend_set_writable          (ECalBackend *backend,
                                                             gboolean writable);

Sets whether `backend` will accept changes to its data content.

`backend` : | an ECalBackend
`writable` : | whether `backend` is writable

Since 3.8

### e_cal_backend_is_opened ()

    gboolean            e_cal_backend_is_opened             (ECalBackend *backend);

Checks if `backend`'s storage has been opened (and authenticated, if necessary) and the backend itself is ready for accessing. This property is changed automatically within call of `e_cal_backend_notify_opened()`.

`backend` : | an ECalBackend
Returns : | `TRUE` if fully opened, `FALSE` otherwise.

Since 3.2

### e_cal_backend_is_readonly ()

    gboolean            e_cal_backend_is_readonly           (ECalBackend *backend);

`backend` : | an ECalBackend
Returns : | Whether is backend read-only. This value is the last used in a call of `e_cal_backend_notify_readonly()`.

Since 3.2

### e_cal_backend_get_cache_dir ()

    const gchar *       e_cal_backend_get_cache_dir         (ECalBackend *backend);

Returns the cache directory path used by `backend`.

`backend` : | an ECalBackend
Returns : | the cache directory path

Since 2.32

### e_cal_backend_dup_cache_dir ()

    gchar *             e_cal_backend_dup_cache_dir         (ECalBackend *backend);

Thread-safe variation of `e_cal_backend_get_cache_dir()`. Use this function when accessing `backend` from multiple threads.

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

`backend` : | an ECalBackend
Returns : | a newly-allocated copy of "cache-dir"

Since 3.10

### e_cal_backend_set_cache_dir ()

    void                e_cal_backend_set_cache_dir         (ECalBackend *backend,
                                                             const gchar *cache_dir);

Sets the cache directory path for use by `backend`.

Note that ECalBackend is initialized with a default cache directory path which should suffice for most cases. Backends should not override the default path without good reason.

`backend` : | an ECalBackend
`cache_dir` : | a local cache directory path

Since 2.32

### e_cal_backend_create_cache_filename ()

    gchar *             e_cal_backend_create_cache_filename (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *filename,
                                                             gint fileindex);

`backend` : | an ECalBackend
`uid` : | a component UID
`filename` : | a filename to use; can be NULL
`fileindex` : | index of a file; used only when `filename` is NULL
Returns : | a filename for an attachment in a local cache dir. Free returned pointer with a `g_free()`.

Since 3.4

### e_cal_backend_add_view ()

    void                e_cal_backend_add_view              (ECalBackend *backend,
                                                             EDataCalView *view);

Adds a view to the list of live views being run by the given backend. Doing so means that any listener on the view will get notified of any change that affect the live view.

`backend` : | an ECalBackend
`view` : | An EDataCalView object.

Since 3.2

### e_cal_backend_remove_view ()

    void                e_cal_backend_remove_view           (ECalBackend *backend,
                                                             EDataCalView *view);

Removes view from the list of live views for the backend.

`backend` : | an ECalBackend
`view` : | An EDataCalView object, previously added with `ref` e_cal_backend_add_view.

Since 3.2

### e_cal_backend_list_views ()

    GList *             e_cal_backend_list_views            (ECalBackend *backend);

Returns a list of ECalBookView instances added with `e_cal_backend_add_view()`.

The views returned in the list are referenced for thread-safety. They must each be unreferenced with `g_object_unref()` when finished with them. Free the returned list itself with `g_list_free()`.

An easy way to free the list properly in one step is as follows:

    1

    g_list_free_full (list, g_object_unref);

`backend` : | an ECalBackend
Returns : | a list of cal views

Since 3.8

### e_cal_backend_get_backend_property ()

    gchar *             e_cal_backend_get_backend_property  (ECalBackend *backend,
                                                             const gchar *prop_name);

Obtains the value of the backend property named `prop_name`. Freed the returned string with `g_free()` when finished with it.

`backend` : | an ECalBackend
`prop_name` : | a backend property name
Returns : | the value for `prop_name`

Since 3.10

### e_cal_backend_open_sync ()

    gboolean            e_cal_backend_open_sync             (ECalBackend *backend,
                                                             GCancellable *cancellable,
                                                             GError **error);

"Opens" the `backend`. Opening a backend is something of an outdated concept, but the operation is hanging around for a little while longer. This usually involves some custom initialization logic, and testing of remote authentication if applicable.

If an error occurs, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_open ()

    void                e_cal_backend_open                  (ECalBackend *backend,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously "opens" the `backend`. Opening a backend is something of an outdated concept, but the operation is hanging around for a little while longer. This usually involves some custom initialization logic, and testing of remote authentication if applicable.

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

`backend` : | an ECalBackend
`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.10

### e_cal_backend_open_finish ()

    gboolean            e_cal_backend_open_finish           (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_open()`.

If an error occurred, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_refresh_sync ()

    gboolean            e_cal_backend_refresh_sync          (ECalBackend *backend,
                                                             GCancellable *cancellable,
                                                             GError **error);

Initiates a refresh for `backend`, if the `backend` supports refreshing. The actual refresh operation completes on its own time. This function merely initiates the operation.

If an error occrs while initiating the refresh, the function will set `error` and return `FALSE`. If the `backend` does not support refreshing, the function will set an `E_CLIENT_ERROR_NOT_SUPPORTED` error and return `FALSE`.

`backend` : | an ECalBackend
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_refresh ()

    void                e_cal_backend_refresh               (ECalBackend *backend,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously initiates a refresh for `backend`, if the `backend` supports refreshing. The actual refresh operation completes on its own time. This function, along with `e_cal_backend_refresh_finish()`, merely initiates the operation.

Once the refresh is initiated, `callback` will be called. You can then call e_cal-`backend_refresh_finish()` to get the result of the initiation.

`backend` : | an ECalBackend
`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.10

### e_cal_backend_refresh_finish ()

    gboolean            e_cal_backend_refresh_finish        (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the refresh initiation started with `e_cal_backend_refresh()`.

If an error occurred while initiating the refresh, the function will set `error` and return `FALSE`. If the `backend` does not support refreshing, the function will set an `E_CLIENT_ERROR_NOT_SUPPORTED` error and return `FALSE`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_get_object_sync ()

    gchar *             e_cal_backend_get_object_sync       (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GCancellable *cancellable,
                                                             GError **error);

Obtains an iCalendar string for an object identified by its `uid` and, optionally, `rid`.

The returned string should be freed with `g_free()` when finished with it.

If an error occurs, the function will set `error` and return `NULL`.

`backend` : | an ECalBackend
`uid` : | a unique ID for an iCalendar object
`rid` : | a recurrence ID, or `NULL`
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | an ECalComponent, or `NULL`

Since 3.10

### e_cal_backend_get_object ()

    void                e_cal_backend_get_object            (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously obtains an ECalComponent by its `uid` and, optionally, `rid`.

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

`backend` : | an ECalBackend
`uid` : | a unique ID for an iCalendar object
`rid` : | a recurrence ID, or `NULL`
`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.10

### e_cal_backend_get_object_finish ()

    gchar *             e_cal_backend_get_object_finish     (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_get_object()`.

The returned string is an iCalendar object describing either single component or a vCalendar object, which includes also detached instances. It should be freed when no longer needed.

If an error occurs, the function will set `error` and return `NULL`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | an ECalComponent, or `NULL`

Since 3.10

### e_cal_backend_get_object_list_sync ()

    gboolean            e_cal_backend_get_object_list_sync  (ECalBackend *backend,
                                                             const gchar *query,
                                                             GQueue *out_objects,
                                                             GCancellable *cancellable,
                                                             GError **error);

Obtains a set of iCalendar string instances which satisfy the criteria specified in `query`, and deposits them in `out_objects`.

The returned instances should be freed with `g_free()` when finished with them.

If an error occurs, the function will set `error` and return `FALSE`. Note that an empty result set does not necessarily imply an error.

`backend` : | an ECalBackend
`query` : | a search query in S-expression format
`out_objects` : | a GQueue in which to deposit results
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_get_object_list ()

    void                e_cal_backend_get_object_list       (ECalBackend *backend,
                                                             const gchar *query,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously obtains a set of iCalendar instances which satisfy the criteria specified in `query`.

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

`backend` : | an ECalBackend
`query` : | a search query in S-expression format
`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.10

### e_cal_backend_get_object_list_finish ()

    gboolean            e_cal_backend_get_object_list_finish
                                                            (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GQueue *out_objects,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_get_object_list()`.

The matching iCalendar instances are deposited in `out_objects`. The returned instances should be freed with `g_free()` when finished with them.

If an error occurred, the function will set `error` and return `FALSE`. Note that an empty result set does not necessarily imply an error.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`out_objects` : | a GQueue in which to deposit results
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_get_free_busy_sync ()

    gboolean            e_cal_backend_get_free_busy_sync    (ECalBackend *backend,
                                                             time_t start,
                                                             time_t end,
                                                             const gchar * const *users,
                                                             GCancellable *cancellable,
                                                             GError **error);

Obtains a free/busy object for the list of `users` in the time interval between `start` and `end`. The free/busy results are returned through the `e_data_cal_report_free_busy_data()` function rather than directly through this function.

If an error occurs, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`start` : | start time
`end` : | end time
`users` : | a `NULL`-terminated array of user strings
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure.

Since 3.10

### e_cal_backend_get_free_busy ()

    void                e_cal_backend_get_free_busy         (ECalBackend *backend,
                                                             time_t start,
                                                             time_t end,
                                                             const gchar * const *users,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously obtains a free/busy object for the list of `users` in the time interval between `start` and `end`.

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

`backend` : | an ECalBackend
`start` : | start time
`end` : | end time
`users` : | a `NULL`-terminated array of user strings
`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.10

### e_cal_backend_get_free_busy_finish ()

    gboolean            e_cal_backend_get_free_busy_finish  (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_get_free_busy()`.

The free/busy results are returned through the `e_data_cal_report_free_busy_data()` function rather than directly through this function.

If an error occurred, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_create_objects_sync ()

    gboolean            e_cal_backend_create_objects_sync   (ECalBackend *backend,
                                                             const gchar * const *calobjs,
                                                             GQueue *out_uids,
                                                             GCancellable *cancellable,
                                                             GError **error);

Creates one or more new iCalendar objects from `calobjs`, and deposits the unique ID string for each newly-created object in `out_uids`.

Free the returned ID strings with `g_free()` when finished with them.

If an error occurs, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`calobjs` : | a `NULL`-terminated array of iCalendar strings
`out_uids` : | a GQueue in which to deposit results
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_create_objects ()

    void                e_cal_backend_create_objects        (ECalBackend *backend,
                                                             const gchar * const *calobjs,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously creates one or more new iCalendar objects from `calobjs`.

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

`backend` : | an ECalBackend
`calobjs` : | a `NULL`-terminated array of iCalendar strings
`cancellable` : | optional GCancellable object, or `NULL`
`callback` : | a GAsyncReadyCallback to call when the request is satisifed
`user_data` : | data to pass to the callback function

Since 3.10

### e_cal_backend_create_objects_finish ()

    gboolean            e_cal_backend_create_objects_finish (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GQueue *out_uids,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_create_objects()`.

A unique ID string for each newly-created object is deposited in `out_uids`. Free the returned ID strings with `g_free()` when finished with them.

If an error occurred, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`out_uids` : | a GQueue in which to deposit results
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_modify_objects_sync ()

    gboolean            e_cal_backend_modify_objects_sync   (ECalBackend *backend,
                                                             const gchar * const *calobjs,
                                                             ECalObjModType mod,
                                                             GCancellable *cancellable,
                                                             GError **error);

### e_cal_backend_modify_objects ()

    void                e_cal_backend_modify_objects        (ECalBackend *backend,
                                                             const gchar * const *calobjs,
                                                             ECalObjModType mod,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously modifies one or more iCalendar objects according to `calobjs` and `mod`.

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

`backend` : | an ECalBackend
`calobjs` : | a `NULL`-terminated array of iCalendar strings
`mod` : | modification type for recurrences
`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.10

### e_cal_backend_modify_objects_finish ()

    gboolean            e_cal_backend_modify_objects_finish (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_modify_objects()`.

If an error occurred, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_remove_objects_sync ()

    gboolean            e_cal_backend_remove_objects_sync   (ECalBackend *backend,
                                                             GList *component_ids,
                                                             ECalObjModType mod,
                                                             GCancellable *cancellable,
                                                             GError **error);

Removes one or more iCalendar objects according to `component_ids` and `mod`.

If an error occurs, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`component_ids` : | a GList of ECalComponentId structs
`mod` : | modification type for recurrences
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_remove_objects ()

    void                e_cal_backend_remove_objects        (ECalBackend *backend,
                                                             GList *component_ids,
                                                             ECalObjModType mod,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously removes one or more iCalendar objects according to `component_ids` and `mod`.

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

`backend` : | an ECalBackend
`component_ids` : | a GList of ECalComponentId structs
`mod` : | modification type for recurrences
`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.10

### e_cal_backend_remove_objects_finish ()

    gboolean            e_cal_backend_remove_objects_finish (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_remove_objects()`.

If an error occurred, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_receive_objects_sync ()

    gboolean            e_cal_backend_receive_objects_sync  (ECalBackend *backend,
                                                             const gchar *calobj,
                                                             GCancellable *cancellable,
                                                             GError **error);

Receives the set of iCalendar objects specified by `calobj`. This is used for iTIP confirmation and cancellation messages for scheduled meetings.

If an error occurs, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`calobj` : | an iCalendar string
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_receive_objects ()

    void                e_cal_backend_receive_objects       (ECalBackend *backend,
                                                             const gchar *calobj,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously receives the set of iCalendar objects specified by `calobj`. This is used for iTIP confirmation and cancellation messages for scheduled meetings.

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

`backend` : | an ECalBackend
`calobj` : | an iCalendar string
`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.10

### e_cal_backend_receive_objects_finish ()

    gboolean            e_cal_backend_receive_objects_finish
                                                            (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_receive_objects()`.

If an error occurred, the function will set `error` and erturn `FALSE`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_send_objects_sync ()

    gchar *             e_cal_backend_send_objects_sync     (ECalBackend *backend,
                                                             const gchar *calobj,
                                                             GQueue *out_users,
                                                             GCancellable *cancellable,
                                                             GError **error);

Sends meeting information in `calobj`. The `backend` may modify `calobj` and send meeting information only to particular users. The function returns the (maybe) modified `calobj` and deposits the list of users the meeting information was sent (to be send) to in `out_users`.

The returned pointer should be freed with `g_free()`, when no londer needed.

If an error occurs, the function will set `error` and return `NULL`.

`backend` : | an ECalBackend
`calobj` : | an iCalendar string
`out_users` : | a GQueue in which to deposit results
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | a vCalendar string, or `NULL`

Since 3.10

### e_cal_backend_send_objects ()

    void                e_cal_backend_send_objects          (ECalBackend *backend,
                                                             const gchar *calobj,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously sends meeting information in `calobj`. The `backend` may modify `calobj` and send meeting information only to particular users.

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

`backend` : | an ECalBackend
`calobj` : | an iCalendar string
`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.10

### e_cal_backend_send_objects_finish ()

    gchar *             e_cal_backend_send_objects_finish   (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GQueue *out_users,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_send_objects()`.

The function returns a string representation of a sent, or to be send, vCalendar and deposits the list of users the meeting information was sent to, or to be send to, in `out_users`.

Free the returned pointer with `g_free()`, when no longer needed.

If an error occurs, the function will set `error` and return `NULL`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`out_users` : | a GQueue in which to deposit results
`error` : | return location for a GError, or `NULL`
Returns : | a newly allocated vCalendar string, or `NULL`

Since 3.10

### e_cal_backend_get_attachment_uris_sync ()

    gboolean            e_cal_backend_get_attachment_uris_sync
                                                            (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GQueue *out_attachment_uris,
                                                             GCancellable *cancellable,
                                                             GError **error);

Inspects the iCalendar object specified by `uid` and, optionally, `rid` for attachments and deposits a URI string for each attachment in `out_attachment_uris`. Free the returned strings with `g_free()` when finished with them.

If an error occurs, the function will set `error` and return `FALSE`. Note that an empty result set does not necessarily imply an error.

`backend` : | an ECalBackend
`uid` : | a unique ID for an iCalendar object
`rid` : | a recurrence ID, or `NULL`
`out_attachment_uris` : | a GQueue in which to deposit results
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_get_attachment_uris ()

    void                e_cal_backend_get_attachment_uris   (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously inspects the iCalendar object specified by `uid` and, optionally, `rid` for attachments.

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

`backend` : | an ECalBackend
`uid` : | a unique ID for an iCalendar object
`rid` : | a recurrence ID, or `NULL`
`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.10

### e_cal_backend_get_attachment_uris_finish ()

    gboolean            e_cal_backend_get_attachment_uris_finish
                                                            (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GQueue *out_attachment_uris,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_get_attachment_uris()`.

The requested attachment URI strings are deposited in `out_attachment_uris`. Free the returned strings with `g_free()` when finished with them.

If an error occurred, the function will set `error` and return `FALSE`. Note that an empty result set does not necessarily imply an error.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`out_attachment_uris` : | a GQueue in which to deposit results
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_discard_alarm_sync ()

    gboolean            e_cal_backend_discard_alarm_sync    (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             const gchar *alarm_uid,
                                                             GCancellable *cancellable,
                                                             GError **error);

Discards the VALARM object with a unique ID of `alarm_uid` from the iCalendar object identified by `uid` and, optionally, `rid`.

If an error occurs, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`uid` : | a unique ID for an iCalendar object
`rid` : | a recurrence ID, or `NULL`
`alarm_uid` : | a unique ID for an iCalendar VALARM object
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_discard_alarm ()

    void                e_cal_backend_discard_alarm         (ECalBackend *backend,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             const gchar *alarm_uid,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously discards the VALARM object with a unique ID of `alarm_uid` from the iCalendar object identified by `uid` and, optionally, `rid`.

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

`backend` : | an ECalBackend
`uid` : | a unique ID for an iCalendar object
`rid` : | a recurrence ID, or `NULL`
`alarm_uid` : | a unique ID for an iCalendar VALARM object
`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.10

### e_cal_backend_discard_alarm_finish ()

    gboolean            e_cal_backend_discard_alarm_finish  (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_discard_alarm()`.

If an error occurred, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_get_timezone_sync ()

    gchar *             e_cal_backend_get_timezone_sync     (ECalBackend *backend,
                                                             const gchar *tzid,
                                                             GCancellable *cancellable,
                                                             GError **error);

Obtains the VTIMEZONE object identified by `tzid`. Free the returned string with `g_free()` when finished with it.

If an error occurs, the function will set `error` and return `NULL`.

`backend` : | an ECalBackend
`tzid` : | a unique ID for an iCalendar VTIMEZONE object
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | an iCalendar string, or `NULL`

Since 3.10

### e_cal_backend_get_timezone ()

    void                e_cal_backend_get_timezone          (ECalBackend *backend,
                                                             const gchar *tzid,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously obtains the VTIMEZONE object identified by `tzid`.

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

`backend` : | an ECalBackend
`tzid` : | a unique ID for an iCalendar VTIMEZONE object
`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.10

### e_cal_backend_get_timezone_finish ()

    gchar *             e_cal_backend_get_timezone_finish   (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_get_timezone()`.

Free the returned string with `g_free()` when finished with it.

If an error occurred, the function will set `error` and return `NULL`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | an iCalendar string, or `NULL`

Since 3.10

### e_cal_backend_add_timezone_sync ()

    gboolean            e_cal_backend_add_timezone_sync     (ECalBackend *backend,
                                                             const gchar *tzobject,
                                                             GCancellable *cancellable,
                                                             GError **error);

Adds the timezone described by `tzobject` to `backend`.

If an error occurs, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`tzobject` : | an iCalendar VTIMEZONE string
`cancellable` : | optional GCancellable object, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_add_timezone ()

    void                e_cal_backend_add_timezone          (ECalBackend *backend,
                                                             const gchar *tzobject,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously adds the timezone described by `tzobject` to `backend`.

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

`backend` : | an ECalBackend
`tzobject` : | an iCalendar VTIMEZONE string
`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.10

### e_cal_backend_add_timezone_finish ()

    gboolean            e_cal_backend_add_timezone_finish   (ECalBackend *backend,
                                                             GAsyncResult *result,
                                                             GError **error);

Finishes the operation started with `e_cal_backend_add_timezone()`.

If an error occurred, the function will set `error` and return `FALSE`.

`backend` : | an ECalBackend
`result` : | a GAsyncResult
`error` : | return location for a GError, or `NULL`
Returns : | `TRUE` on success, `FALSE` on failure

Since 3.10

### e_cal_backend_start_view ()

    void                e_cal_backend_start_view            (ECalBackend *backend,
                                                             EDataCalView *view);

Starts a new live view on the given backend.

`backend` : | an ECalBackend
`view` : | The view to be started.

Since 3.2

### e_cal_backend_stop_view ()

    void                e_cal_backend_stop_view             (ECalBackend *backend,
                                                             EDataCalView *view);

Stops a previously started live view on the given backend.

`backend` : | an ECalBackend
`view` : | The view to be stopped.

Since 3.2

### e_cal_backend_notify_component_created ()

    void                e_cal_backend_notify_component_created
                                                            (ECalBackend *backend,
                                                             ECalComponent *component);

Notifies each of the backend's listeners about a new object.

Like `e_cal_backend_notify_object_created()` except takes an ECalComponent instead of an ical string representation and uses the EDataCalView's fields-of-interest to filter out unwanted information from ical strings sent over the bus.

`backend` : | an ECalBackend
`component` : | the newly created ECalComponent

Since 3.4

### e_cal_backend_notify_component_modified ()

    void                e_cal_backend_notify_component_modified
                                                            (ECalBackend *backend,
                                                             ECalComponent *old_component,
                                                             ECalComponent *new_component);

Notifies each of the backend's listeners about a modified object.

Like `e_cal_backend_notify_object_modified()` except takes an ECalComponent instead of an ical string representation and uses the EDataCalView's fields-of-interest to filter out unwanted information from ical strings sent over the bus.

`backend` : | an ECalBackend
`old_component` : | the ECalComponent before the modification
`new_component` : | the ECalComponent after the modification

Since 3.4

### e_cal_backend_notify_component_removed ()

    void                e_cal_backend_notify_component_removed
                                                            (ECalBackend *backend,
                                                             const ECalComponentId *id,
                                                             ECalComponent *old_component,
                                                             ECalComponent *new_component);

Notifies each of the backend's listeners about a removed object.

Like `e_cal_backend_notify_object_removed()` except takes an ECalComponent instead of an ical string representation and uses the EDataCalView's fields-of-interest to filter out unwanted information from ical strings sent over the bus.

`backend` : | an ECalBackend
`id` : | the Id of the removed object
`old_component` : | the removed component
`new_component` : | the component after the removal. This only applies to recurrent appointments that had an instance removed. In that case, this function notifies a modification instead of a removal.

Since 3.4

### e_cal_backend_notify_error ()

    void                e_cal_backend_notify_error          (ECalBackend *backend,
                                                             const gchar *message);

Notifies each of the backend's listeners about an error

`backend` : | an ECalBackend
`message` : | Error message

### e_cal_backend_notify_property_changed ()

    void                e_cal_backend_notify_property_changed
                                                            (ECalBackend *backend,
                                                             const gchar *prop_name,
                                                             const gchar *prop_value);

Notifies client about property value change.

`backend` : | an ECalBackend
`prop_name` : | property name, which changed
`prop_value` : | new property value

Since 3.2

### e_cal_backend_empty_cache ()

    void                e_cal_backend_empty_cache           (ECalBackend *backend,
                                                             struct _ECalBackendCache *cache);

Empties backend's cache with all notifications and so on, thus all listening will know there is nothing in this backend.

`backend` : | an ECalBackend
`cache` : | Backend's cache to empty.

Since 2.28

### e_cal_backend_prepare_for_completion ()

    GSimpleAsyncResult * e_cal_backend_prepare_for_completion
                                                            (ECalBackend *backend,
                                                             guint opid,
                                                             GQueue **result_queue);

Obtains the GSimpleAsyncResult for `opid` and sets `result_queue` as a place to deposit results prior to completing the GSimpleAsyncResult.

### Note

This is a temporary function to serve EDataCal's "respond" functions until they can be removed. Nothing else should be calling this function.

`backend` : | an ECalBackend
`opid` : | an operation ID given to EDataCal
`result_queue` : | return location for a GQueue, or `NULL`
Returns : | a GSimpleAsyncResult. [transfer full]

Since 3.10