## ECalBackend

ECalBackend — Base class for calendar/tasks backend implementations.

## Synopsis

                        ECalBackend;
    ESource *           e_cal_backend_get_source            (ECalBackend *backend);
    const gchar *       e_cal_backend_get_uri               (ECalBackend *backend);
    icalcomponent_kind  e_cal_backend_get_kind              (ECalBackend *backend);
    const gchar *       e_cal_backend_get_cache_dir         (ECalBackend *backend);
    void                e_cal_backend_set_cache_dir         (ECalBackend *backend,
                                                             const gchar *cache_dir);
    void                e_cal_backend_add_client            (ECalBackend *backend,
                                                             EDataCal *cal);
    void                e_cal_backend_remove_client         (ECalBackend *backend,
                                                             EDataCal *cal);
    void                e_cal_backend_add_query             (ECalBackend *backend,
                                                             EDataCalView *query);
    EList *             e_cal_backend_get_queries           (ECalBackend *backend);
    void                e_cal_backend_remove_query          (ECalBackend *backend,
                                                             EDataCalView *query);
    void                e_cal_backend_is_read_only          (ECalBackend *backend,
                                                             EDataCal *cal);
    void                e_cal_backend_get_cal_address       (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);
    void                e_cal_backend_get_alarm_email_address
                                                            (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);
    void                e_cal_backend_get_ldap_attribute    (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);
    void                e_cal_backend_get_static_capabilities
                                                            (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);
    void                e_cal_backend_open                  (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             gboolean only_if_exists,
                                                             const gchar *username,
                                                             const gchar *password);
    void                e_cal_backend_refresh               (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);
    void                e_cal_backend_remove                (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);
    void                e_cal_backend_create_object         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *calobj);
    void                e_cal_backend_modify_object         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *calobj,
                                                             CalObjModType mod);
    void                e_cal_backend_remove_object         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             CalObjModType mod);
    void                e_cal_backend_discard_alarm         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *uid,
                                                             const gchar *auid);
    void                e_cal_backend_receive_objects       (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *calobj);
    void                e_cal_backend_send_objects          (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *calobj);
    void                e_cal_backend_get_default_object    (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);
    void                e_cal_backend_get_object            (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *uid,
                                                             const gchar *rid);
    void                e_cal_backend_get_object_list       (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *sexp);
    void                e_cal_backend_get_attachment_list   (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *uid,
                                                             const gchar *rid);
    gboolean            e_cal_backend_is_loaded             (ECalBackend *backend);
    void                e_cal_backend_start_query           (ECalBackend *backend,
                                                             EDataCalView *query);
    CalMode             e_cal_backend_get_mode              (ECalBackend *backend);
    void                e_cal_backend_set_mode              (ECalBackend *backend,
                                                             CalMode mode);
    void                e_cal_backend_get_timezone          (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *tzid);
    void                e_cal_backend_add_timezone          (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *object);
    void                e_cal_backend_set_default_zone      (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *tzobj);
    void                e_cal_backend_get_changes           (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *change_id);
    void                e_cal_backend_get_free_busy         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             GList *users,
                                                             time_t start,
                                                             time_t end);
    icaltimezone*       e_cal_backend_internal_get_default_timezone
                                                            (ECalBackend *backend);
    icaltimezone*       e_cal_backend_internal_get_timezone (ECalBackend *backend,
                                                             const gchar *tzid);
    void                e_cal_backend_set_notification_proxy
                                                            (ECalBackend *backend,
                                                             ECalBackend *proxy);
    void                e_cal_backend_notify_object_created (ECalBackend *backend,
                                                             const gchar *calobj);
    void                e_cal_backend_notify_object_modified
                                                            (ECalBackend *backend,
                                                             const gchar *old_object,
                                                             const gchar *object);
    void                e_cal_backend_notify_object_removed (ECalBackend *backend,
                                                             const ECalComponentId *id,
                                                             const gchar *old_object,
                                                             const gchar *object);
    void                e_cal_backend_notify_mode           (ECalBackend *backend,
                                                             EDataCalViewListenerSetModeStatus status,
                                                             EDataCalMode mode);
    void                e_cal_backend_notify_auth_required  (ECalBackend *backend);
    void                e_cal_backend_notify_error          (ECalBackend *backend,
                                                             const gchar *message);
    void                e_cal_backend_notify_view_done      (ECalBackend *backend,
                                                             const GError *error);
    void                e_cal_backend_notify_view_progress_start
                                                            (ECalBackend *backend);
    void                e_cal_backend_notify_view_progress  (ECalBackend *backend,
                                                             const gchar *message,
                                                             gint percent);
    void                e_cal_backend_notify_readonly       (ECalBackend *backend,
                                                             gboolean read_only);
    void                e_cal_backend_notify_cal_address    (ECalBackend *backend,
                                                             EServerMethodContext context,
                                                             gchar *address);
    void                e_cal_backend_notify_objects_added  (ECalBackend *backend,
                                                             EDataCalView *query,
                                                             const GList *objects);
    void                e_cal_backend_notify_objects_removed
                                                            (ECalBackend *backend,
                                                             EDataCalView *query,
                                                             const GList *ids);
    void                e_cal_backend_notify_objects_modified
                                                            (ECalBackend *backend,
                                                             EDataCalView *query,
                                                             const GList *objects);
    void                e_cal_backend_empty_cache           (ECalBackend *backend,
                                                             struct _ECalBackendCache *cache);

## Object Hierarchy

      GObject
       +----ECalBackend
             +----ECalBackendSync

## Properties

      "cache-dir"                gchar*                : Read / Write
      "kind"                     gulong                : Read / Write / Construct Only
      "source"                   ESource*              : Read / Write / Construct Only
      "uri"                      gchar*                : Read / Write / Construct Only

## Signals

      "last-client-gone"                               : Run First

## Description

## Details

### ECalBackend

    typedef struct _ECalBackend ECalBackend;

### e_cal_backend_get_source ()

    ESource *           e_cal_backend_get_source            (ECalBackend *backend);

Gets the ESource associated with the given backend.

`backend` : | an ECalBackend
Returns : | The ESource for the backend.

### e_cal_backend_get_uri ()

    const gchar *       e_cal_backend_get_uri               (ECalBackend *backend);

Queries the URI of a calendar backend, which must already have an open calendar.

`backend` : | an ECalBackend
Returns : | The URI where the calendar is stored.

### 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_get_cache_dir ()

    const gchar *       e_cal_backend_get_cache_dir         (ECalBackend *backend);

Returns the cache directory for the given backend.

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

Since 2.32

### e_cal_backend_set_cache_dir ()

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

Sets the cache directory for the given backend.

Note that ECalBackend is initialized with a usable default based on "source" and "kind" properties. Backends should not override the default without good reason.

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

Since 2.32

### e_cal_backend_add_client ()

    void                e_cal_backend_add_client            (ECalBackend *backend,
                                                             EDataCal *cal);

Adds a new client to the given backend. For any event, the backend will notify all clients added via this function.

`backend` : | an ECalBackend
`cal` : | an EDataCal

### e_cal_backend_remove_client ()

    void                e_cal_backend_remove_client         (ECalBackend *backend,
                                                             EDataCal *cal);

Removes a client from the list of connected clients to the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal

### e_cal_backend_add_query ()

    void                e_cal_backend_add_query             (ECalBackend *backend,
                                                             EDataCalView *query);

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

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

### e_cal_backend_get_queries ()

    EList *             e_cal_backend_get_queries           (ECalBackend *backend);

Gets the list of live queries being run on the given backend.

`backend` : | an ECalBackend
Returns : | The list of live queries.

### e_cal_backend_remove_query ()

    void                e_cal_backend_remove_query          (ECalBackend *backend,
                                                             EDataCalView *query);

Removes query from the list of live queries for the backend.

`backend` : | an ECalBackend
`query` : | An EDataCalView object, previously added with `ref` e_cal_backend_add_query.

Since 2.24

### e_cal_backend_is_read_only ()

    void                e_cal_backend_is_read_only          (ECalBackend *backend,
                                                             EDataCal *cal);

Queries whether a calendar backend is read only or not.

`backend` : | an ECalBackend
`cal` : | an EDataCal

### e_cal_backend_get_cal_address ()

    void                e_cal_backend_get_cal_address       (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);

Queries the cal address associated with a calendar backend, which must already have an open calendar.

`backend` : | an ECalBackend
`cal` : |
`context` : |

### e_cal_backend_get_alarm_email_address ()

    void                e_cal_backend_get_alarm_email_address
                                                            (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);

Calls the get_static_capabilities method on the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |

### e_cal_backend_get_ldap_attribute ()

    void                e_cal_backend_get_ldap_attribute    (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);

`backend` : |
`cal` : |
`context` : |

### e_cal_backend_get_static_capabilities ()

    void                e_cal_backend_get_static_capabilities
                                                            (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);

`backend` : |
`cal` : |
`context` : |

### e_cal_backend_open ()

    void                e_cal_backend_open                  (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             gboolean only_if_exists,
                                                             const gchar *username,
                                                             const gchar *password);

Opens a calendar backend with data from a calendar stored at the specified URI.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`only_if_exists` : | Whether the calendar should be opened only if it already exists. If FALSE, a new calendar will be created when the specified `uri` does not exist.
`username` : | User name to use for authentication (if needed).
`password` : | Password for `username`.

### e_cal_backend_refresh ()

    void                e_cal_backend_refresh               (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);

Refreshes the calendar being accessed by the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |

Since 2.30

### e_cal_backend_remove ()

    void                e_cal_backend_remove                (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);

Removes the calendar being accessed by the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |

### e_cal_backend_create_object ()

    void                e_cal_backend_create_object         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *calobj);

Calls the create_object method on the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`calobj` : | The object to create.

### e_cal_backend_modify_object ()

    void                e_cal_backend_modify_object         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *calobj,
                                                             CalObjModType mod);

Calls the modify_object method on the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`calobj` : | Object to be modified.
`mod` : | Type of modification.

### e_cal_backend_remove_object ()

    void                e_cal_backend_remove_object         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             CalObjModType mod);

Removes an object in a calendar backend. The backend will notify all of its clients about the change.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`uid` : | Unique identifier of the object to remove.
`rid` : | A recurrence ID.
`mod` : | Type of removal.

### e_cal_backend_discard_alarm ()

    void                e_cal_backend_discard_alarm         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *uid,
                                                             const gchar *auid);

Discards an alarm from the given component. This allows the specific backend to do whatever is needed to really discard the alarm.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`uid` : | UID of the component to discard the alarm from.
`auid` : | Alarm ID.

### e_cal_backend_receive_objects ()

    void                e_cal_backend_receive_objects       (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *calobj);

Calls the receive_objects method on the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`calobj` : | iCalendar object.

### e_cal_backend_send_objects ()

    void                e_cal_backend_send_objects          (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *calobj);

Calls the send_objects method on the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`calobj` : | iCalendar object to be sent.

### e_cal_backend_get_default_object ()

    void                e_cal_backend_get_default_object    (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context);

Calls the get_default_object method on the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |

### e_cal_backend_get_object ()

    void                e_cal_backend_get_object            (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *uid,
                                                             const gchar *rid);

Queries a calendar backend for a calendar object based on its unique identifier and its recurrence ID (if a recurrent appointment).

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`uid` : | Unique identifier for a calendar object.
`rid` : | ID for the object's recurrence to get.

### e_cal_backend_get_object_list ()

    void                e_cal_backend_get_object_list       (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *sexp);

Calls the get_object_list method on the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`sexp` : | Expression to search for.

### e_cal_backend_get_attachment_list ()

    void                e_cal_backend_get_attachment_list   (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *uid,
                                                             const gchar *rid);

Queries a calendar backend for attachments present in a calendar object based on its unique identifier and its recurrence ID (if a recurrent appointment).

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`uid` : | Unique identifier for a calendar object.
`rid` : | ID for the object's recurrence to get.

### e_cal_backend_is_loaded ()

    gboolean            e_cal_backend_is_loaded             (ECalBackend *backend);

Queries whether a calendar backend has been loaded yet.

`backend` : | an ECalBackend
Returns : | TRUE if the backend has been loaded with data, FALSE otherwise.

### e_cal_backend_start_query ()

    void                e_cal_backend_start_query           (ECalBackend *backend,
                                                             EDataCalView *query);

Starts a new live query on the given backend.

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

### e_cal_backend_get_mode ()

    CalMode             e_cal_backend_get_mode              (ECalBackend *backend);

Queries whether a calendar backend is connected remotely.

`backend` : | an ECalBackend
Returns : | The current mode the calendar is in

### e_cal_backend_set_mode ()

    void                e_cal_backend_set_mode              (ECalBackend *backend,
                                                             CalMode mode);

Sets the mode of the calendar

`backend` : | A calendar backend
`mode` : | Mode to change to

### e_cal_backend_get_timezone ()

    void                e_cal_backend_get_timezone          (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *tzid);

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`tzid` : | Unique identifier of a VTIMEZONE object. Note that this must not be NULL.

### e_cal_backend_add_timezone ()

    void                e_cal_backend_add_timezone          (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *object);

Add a timezone object to the given backend.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`object` : |

### e_cal_backend_set_default_zone ()

    void                e_cal_backend_set_default_zone      (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *tzobj);

Sets the default timezone for the calendar, which is used to resolve DATE and floating DATE-TIME values.

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`tzobj` : | The timezone object, in a string.

### e_cal_backend_get_changes ()

    void                e_cal_backend_get_changes           (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             const gchar *change_id);

Builds a sequence of objects and the type of change that occurred on them since the last time the give change_id was seen

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`change_id` : | A unique uid for the callers change list

### e_cal_backend_get_free_busy ()

    void                e_cal_backend_get_free_busy         (ECalBackend *backend,
                                                             EDataCal *cal,
                                                             EServerMethodContext context,
                                                             GList *users,
                                                             time_t start,
                                                             time_t end);

Gets a free/busy object for the given time interval

`backend` : | an ECalBackend
`cal` : | an EDataCal
`context` : |
`users` : | List of users to get free/busy information for.
`start` : | Start time for query.
`end` : | End time for query.

### e_cal_backend_internal_get_default_timezone ()

    icaltimezone*       e_cal_backend_internal_get_default_timezone
                                                            (ECalBackend *backend);

Calls the internal_get_default_timezone method on the given backend.

`backend` : | an ECalBackend
Returns : |

### e_cal_backend_internal_get_timezone ()

    icaltimezone*       e_cal_backend_internal_get_timezone (ECalBackend *backend,
                                                             const gchar *tzid);

Calls the internal_get_timezone method on the given backend.

`backend` : | an ECalBackend
`tzid` : | ID of the timezone to get.
Returns : |

### e_cal_backend_set_notification_proxy ()

    void                e_cal_backend_set_notification_proxy
                                                            (ECalBackend *backend,
                                                             ECalBackend *proxy);

Sets the backend that will act as notification proxy for the given backend.

`backend` : | an ECalBackend
`proxy` : | The calendar backend to act as notification proxy.

### e_cal_backend_notify_object_created ()

    void                e_cal_backend_notify_object_created (ECalBackend *backend,
                                                             const gchar *calobj);

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

#`e_data_cal_notify_object_created()` calls this for you. You only need to call `e_cal_backend_notify_object_created()` yourself to report objects created by non-EDS clients.

`backend` : | an ECalBackend
`calobj` : | iCalendar representation of new object

### e_cal_backend_notify_object_modified ()

    void                e_cal_backend_notify_object_modified
                                                            (ECalBackend *backend,
                                                             const gchar *old_object,
                                                             const gchar *object);

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

#`e_data_cal_notify_object_modified()` calls this for you. You only need to call `e_cal_backend_notify_object_modified()` yourself to report objects modified by non-EDS clients.

`backend` : | an ECalBackend
`old_object` : | iCalendar representation of the original form of the object
`object` : | iCalendar representation of the new form of the object

### e_cal_backend_notify_object_removed ()

    void                e_cal_backend_notify_object_removed (ECalBackend *backend,
                                                             const ECalComponentId *id,
                                                             const gchar *old_object,
                                                             const gchar *object);

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

`e_data_cal_notify_object_removed()` calls this for you. You only need to call `e_cal_backend_notify_object_removed()` yourself to report objects removed by non-EDS clients.

`backend` : | an ECalBackend
`id` : | the Id of the removed object
`old_object` : | iCalendar representation of the removed object
`object` : |

### e_cal_backend_notify_mode ()

    void                e_cal_backend_notify_mode           (ECalBackend *backend,
                                                             EDataCalViewListenerSetModeStatus status,
                                                             EDataCalMode mode);

Notifies each of the backend's listeners about the results of a setMode call.

`backend` : | an ECalBackend
`status` : | Status of the mode set
`mode` : | the current mode

### e_cal_backend_notify_auth_required ()

    void                e_cal_backend_notify_auth_required  (ECalBackend *backend);

Notifies each of the backend's listeners that authentication is required to open the calendar.

`backend` : | an ECalBackend

### 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_view_done ()

    void                e_cal_backend_notify_view_done      (ECalBackend *backend,
                                                             const GError *error);

Notifies each of the backend's listeners about the view_done in downloading the items.

`backend` : | an ECalBackend
`error` : | returns the error, if any, once the view is fully populated.

### e_cal_backend_notify_view_progress_start ()

    void                e_cal_backend_notify_view_progress_start
                                                            (ECalBackend *backend);

This methods has to be used before e_cal_backend_notify_view_progress. Sets last notified percent value to 0.

`backend` : | an ECalBackend

Since 2.24

### e_cal_backend_notify_view_progress ()

    void                e_cal_backend_notify_view_progress  (ECalBackend *backend,
                                                             const gchar *message,
                                                             gint percent);

Notifies each of the backend's listeners about the view_progress in downloading the items.

`backend` : | an ECalBackend
`message` : | the UID of the removed object
`percent` : | percentage of the objects loaded in the view

### e_cal_backend_notify_readonly ()

    void                e_cal_backend_notify_readonly       (ECalBackend *backend,
                                                             gboolean read_only);

`backend` : |
`read_only` : |

### e_cal_backend_notify_cal_address ()

    void                e_cal_backend_notify_cal_address    (ECalBackend *backend,
                                                             EServerMethodContext context,
                                                             gchar *address);

`backend` : |
`context` : |
`address` : |

### e_cal_backend_notify_objects_added ()

    void                e_cal_backend_notify_objects_added  (ECalBackend *backend,
                                                             EDataCalView *query,
                                                             const GList *objects);

`backend` : |
`query` : |
`objects` : |

Since 2.24

### e_cal_backend_notify_objects_removed ()

    void                e_cal_backend_notify_objects_removed
                                                            (ECalBackend *backend,
                                                             EDataCalView *query,
                                                             const GList *ids);

`backend` : |
`query` : |
`ids` : |

Since 2.24

### e_cal_backend_notify_objects_modified ()

    void                e_cal_backend_notify_objects_modified
                                                            (ECalBackend *backend,
                                                             EDataCalView *query,
                                                             const GList *objects);

`backend` : |
`query` : |
`objects` : |

Since 2.24

### 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

## Property Details

### The `"cache-dir"` property

      "cache-dir"                gchar*                : Read / Write

Default value: NULL

### The `"kind"` property

      "kind"                     gulong                : Read / Write / Construct Only

Allowed values: <= 25

### The `"source"` property

      "source"                   ESource*              : Read / Write / Construct Only

### The `"uri"` property

      "uri"                      gchar*                : Read / Write / Construct Only

Default value: ""

## Signal Details

### The `"last-client-gone"` signal

    void                user_function                      (ECalBackend *ecalbackend,
                                                            gpointer     user_data)        : Run First

`ecalbackend` : | the object which received the signal.
`user_data` : | user data set when the signal handler was connected.