Top | ![]() |
![]() |
![]() |
![]() |
#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 |
This is the main server facing API for interfacing with calendar backends, calendar backends must implement methods on this class.
icalcomponent_kind e_cal_backend_get_kind (ECalBackend *backend
);
Gets the kind of components the given backend stores.
EDataCal * e_cal_backend_ref_data_cal (ECalBackend *backend
);
Returns the backend
. The backend
's native API.
An backend
is first created.
If an NULL
The returned g_object_unref()
Since: 3.10
void e_cal_backend_set_data_cal (ECalBackend *backend
,);
EDataCal *data_cal
Sets the backend
. The backend
's native API.
An backend
is first created.
Since: 3.10
GProxyResolver * e_cal_backend_ref_proxy_resolver (ECalBackend *backend
);
Returns the backend
(if applicable), as indicated
by the backend
's
The returned g_object_unref()
Since: 3.12
ESourceRegistry *
e_cal_backend_get_registry (ECalBackend *backend
);
Returns the data source registry to which
Since: 3.6
gboolean e_cal_backend_get_writable (ECalBackend *backend
);
Returns whether backend
will accept changes to its data content.
Since: 3.8
void e_cal_backend_set_writable (ECalBackend *backend
,);
gboolean writable
Sets whether backend
will accept changes to its data content.
Since: 3.8
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()
Since: 3.2
gboolean e_cal_backend_is_readonly (ECalBackend *backend
);
Whether is backend read-only. This value is the last used
in a call of e_cal_backend_notify_readonly()
Since: 3.2
constgchar * e_cal_backend_get_cache_dir (ECalBackend *backend
);
Returns the cache directory path used by backend
.
Since: 2.32
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()
Since: 3.10
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.
Since: 2.32
gchar * e_cal_backend_create_cache_filename (ECalBackend *backend
,const
,gchar *uidconst
,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 |
Since: 3.4
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.
Since: 3.2
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 |
Since: 3.2
GList * e_cal_backend_list_views (ECalBackend *backend
);
Returns a list of 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()
g_list_free()
An easy way to free the list properly in one step is as follows:
g_list_free_full (list, g_object_unref);
Since: 3.8
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()
Since: 3.10
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 |
|
error |
return location for a |
Since: 3.10
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 |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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
Since: 3.10
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
backend
does not support refreshing,
the function will set an E_CLIENT_ERROR_NOT_SUPPORTED
error and return
FALSE
backend |
an ECalBackend |
|
cancellable |
optional |
|
error |
return location for a |
Since: 3.10
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()
backend |
an ECalBackend |
|
cancellable |
optional |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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
backend
does not support refreshing,
the function will set an E_CLIENT_ERROR_NOT_SUPPORTED
error and return
FALSE
Since: 3.10
gchar * e_cal_backend_get_object_sync (ECalBackend *backend
,const
,gchar *uidconst
,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()
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 |
|
cancellable |
optional |
|
error |
return location for a |
Since: 3.10
void e_cal_backend_get_object (ECalBackend *backend
,const
,gchar *uidconst
,gchar *rid,
GCancellable *cancellable,
GAsyncReadyCallback callback);
gpointer user_data
Asynchronously obtains an 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 |
|
cancellable |
optional |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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
Since: 3.10
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()
If an error occurs, the function will set error
and return FALSE
backend |
an ECalBackend |
|
query |
a search query in S-expression format |
|
out_objects |
a |
|
cancellable |
optional |
|
error |
return location for a |
Since: 3.10
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 |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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()
If an error occurred, the function will set error
and return FALSE
backend |
an ECalBackend |
|
result |
a |
|
out_objects |
a |
|
error |
return location for a |
Since: 3.10
gboolean e_cal_backend_get_free_busy_sync (ECalBackend *backend
,,
time_t start,
time_t endconst
,gchar * const *users,
GSList **out_freebusy,
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 can be returned through the
e_data_cal_report_free_busy_data()
function asynchronously. The out_freebusy
will contain all the returned data, possibly again, thus the client is
responsible for the data merge, if needed.
If an error occurs, the function will set error
and return FALSE
backend |
an ECalBackend |
|
start |
start time |
|
end |
end time |
|
users |
a |
|
out_freebusy |
iCalendar strings with overall returned Free/Busy data |
|
cancellable |
optional |
|
error |
return location for a |
Since: 3.10
void e_cal_backend_get_free_busy (ECalBackend *backend
,,
time_t start,
time_t endconst
,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 |
|
cancellable |
optional |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
gboolean e_cal_backend_get_free_busy_finish (ECalBackend *backend
,,
GAsyncResult *result,
GSList **out_freebusy);
GError **error
Finishes the operation started with e_cal_backend_get_free_busy()
.
The free/busy results can be returned through the
e_data_cal_report_free_busy_data()
function asynchronously. The out_freebusy
will contain all the returned data, possibly again, thus the client is
responsible for the data merge, if needed.
If an error occurred, the function will set error
and return FALSE
backend |
an ECalBackend |
|
result |
a |
|
out_freebusy |
iCalendar strings with overall returned Free/Busy data |
|
error |
return location for a |
Since: 3.10
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()
If an error occurs, the function will set error
and return FALSE
backend |
an ECalBackend |
|
calobjs |
a |
|
out_uids |
a |
|
cancellable |
optional |
|
error |
return location for a |
Since: 3.10
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 |
|
cancellable |
optional |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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()
If an error occurred, the function will set error
and return FALSE
backend |
an ECalBackend |
|
result |
a |
|
out_uids |
a |
|
error |
return location for a |
Since: 3.10
gboolean e_cal_backend_modify_objects_sync (ECalBackend *backend
,const
,gchar * const *calobjsECalObjModType mod
,,
GCancellable *cancellable);
GError **error
void e_cal_backend_modify_objects (ECalBackend *backend
,const
,gchar * const *calobjsECalObjModType 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 |
|
mod |
modification type for recurrences |
|
cancellable |
optional |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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
Since: 3.10
gboolean e_cal_backend_remove_objects_sync (ECalBackend *backend
,,
GList *component_idsECalObjModType 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 |
|
mod |
modification type for recurrences |
|
cancellable |
optional |
|
error |
return location for a |
Since: 3.10
void e_cal_backend_remove_objects (ECalBackend *backend
,,
GList *component_idsECalObjModType 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 |
|
mod |
modification type for recurrences |
|
cancellable |
optional |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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
Since: 3.10
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 |
|
error |
return location for a |
Since: 3.10
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 |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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
Since: 3.10
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()
If an error occurs, the function will set error
and return NULL
backend |
an ECalBackend |
|
calobj |
an iCalendar string |
|
out_users |
a |
|
cancellable |
optional |
|
error |
return location for a |
Since: 3.10
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 |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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()
If an error occurs, the function will set error
and return NULL
backend |
an ECalBackend |
|
result |
a |
|
out_users |
a |
|
error |
return location for a |
Since: 3.10
gboolean e_cal_backend_get_attachment_uris_sync (ECalBackend *backend
,const
,gchar *uidconst
,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()
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 |
|
out_attachment_uris |
a |
|
cancellable |
optional |
|
error |
return location for a |
Since: 3.10
void e_cal_backend_get_attachment_uris (ECalBackend *backend
,const
,gchar *uidconst
,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 |
|
cancellable |
optional |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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()
If an error occurred, the function will set error
and return FALSE
backend |
an ECalBackend |
|
result |
a |
|
out_attachment_uris |
a |
|
error |
return location for a |
Since: 3.10
gboolean e_cal_backend_discard_alarm_sync (ECalBackend *backend
,const
,gchar *uidconst
,gchar *ridconst
,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 |
|
alarm_uid |
a unique ID for an iCalendar VALARM object |
|
cancellable |
optional |
|
error |
return location for a |
Since: 3.10
void e_cal_backend_discard_alarm (ECalBackend *backend
,const
,gchar *uidconst
,gchar *ridconst
,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 |
|
alarm_uid |
a unique ID for an iCalendar VALARM object |
|
cancellable |
optional |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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
Since: 3.10
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()
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 |
|
error |
return location for a |
Since: 3.10
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 |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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()
If an error occurred, the function will set error
and return NULL
Since: 3.10
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 |
|
error |
return location for a |
Since: 3.10
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 |
|
callback |
a |
|
user_data |
data to pass to the callback function |
Since: 3.10
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
Since: 3.10
void e_cal_backend_start_view (ECalBackend *backend
,);
EDataCalView *view
Starts a new live view on the given backend.
Since: 3.2
void e_cal_backend_stop_view (ECalBackend *backend
,);
EDataCalView *view
Stops a previously started live view on the given backend.
Since: 3.2
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()
Since: 3.4
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()
backend |
an ECalBackend |
|
old_component |
the |
|
new_component |
the |
Since: 3.4
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()
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
void e_cal_backend_notify_error (ECalBackend *backend
,const
);gchar *message
Notifies each of the backend's listeners about an error
void e_cal_backend_notify_property_changed (ECalBackend *backend
,const
,gchar *prop_nameconst
);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
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.
Since: 2.28
GSimpleAsyncResult * e_cal_backend_prepare_for_completion (ECalBackend *backend
,,
guint opid);
GQueue **result_queue
Obtains the opid
and sets result_queue
as a
place to deposit results prior to completing the
This is a temporary function to serve
backend |
an ECalBackend |
|
opid |
an operation ID given to |
|
result_queue |
return location for a |
Since: 3.10
#define CLIENT_BACKEND_PROPERTY_CAPABILITIES
FIXME: Document me.
Since: 3.2
#define CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS
FIXME: Document me.
Since: 3.2
#define CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS
FIXME: Document me.
Since: 3.2
#define CAL_BACKEND_PROPERTY_DEFAULT_OBJECT
FIXME: Document me.
Since: 3.2
#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 { };
Contains only private data that should be read and manipulated using the functions below.
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.
Whether a serial dispatch queue should be used for this backend or not. |
||
Fetch a property value by name from the backend |
||
Open the backend |
||
Refresh the backend |
||
Fetch a calendar object |
||
FIXME: Document me |
||
FIXME: Document me |
||
FIXME: Document me |
||
FIXME: Document me |
||
FIXME: Document me |
||
FIXME: Document me |
||
FIXME: Document me |
||
FIXME: Document me |
||
FIXME: Document me |
||
FIXME: Document me |
||
FIXME: Document me |
||
Start up the specified view |
||
Stop the specified view |
||
A signal notifying that the backend was closed |
||
A signal notifying that the backend is being shut down |