The capabilities of this client
The main loop context in which notifications for this client will be delivered.
Whether this client's backing data is online.
Whether this client is open and ready to use.
Whether this client's backing data is readonly.
The #ESource for which this client was created.
Add a VTIMEZONE object to the given calendar client.
The call is finished by e_cal_client_add_timezone_finish() from
the callback.
The timezone to add
a #GCancellable; can be %NULL
callback to call when a result is ready
Adds a copy of zone to cache and emits an
#ETimezoneCache::timezone-added signal. The cache will use the TZID
string returned by i_cal_timezone_get_tzid() as the lookup key, which can
be passed to e_timezone_cache_get_timezone() to obtain zone again.
If the cache already has an #ICalTimezone with the same TZID string
as zone, the cache will remain unchanged to avoid invalidating any
#ICalTimezone pointers which may have already been returned through
e_timezone_cache_get_timezone().
Finishes previous call of e_cal_client_add_timezone().
a #GAsyncResult
Add a VTIMEZONE object to the given calendar client.
The timezone to add
a #GCancellable; can be %NULL
Creates a binding between source_property on source and target_property
on target.
Whenever the source_property is changed the target_property is
updated using the same value. For instance:
g_object_bind_property (action, "active", widget, "sensitive", 0);
Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance.
If flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
if target_property on target changes then the source_property on source
will be updated as well.
The binding will automatically be removed when either the source or the
target instances are finalized. To remove the binding without affecting the
source and the target you can just call g_object_unref() on the returned
#GBinding instance.
Removing the binding by calling g_object_unref() on it must only be done if
the binding, source and target are only used from a single thread and it
is clear that both source and target outlive the binding. Especially it
is not safe to rely on this if the binding, source or target can be
finalized from different threads. Keep another reference to the binding and
use g_binding_unbind() instead to be on the safe side.
A #GObject can have multiple bindings.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
Creates a binding between source_property on source and target_property
on target, allowing you to set the transformation functions to be used by
the binding.
This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
a #GClosure wrapping the transformation function from the source to the target, or %NULL to use the default
a #GClosure wrapping the transformation function from the target to the source, or %NULL to use the default
Cancels all pending operations started on client.
Check if backend supports particular capability. To get all capabilities use e_client_get_capabilities().
a capability
Checks if a calendar supports only one alarm per component.
Checks whether a calendar requires organizer to accept their attendance to meetings.
Checks if a calendar forces organizers of meetings to be also attendees.
Checks if the calendar has a master object for recurrences.
Checks whether a client supports explicit refreshing (see e_client_refresh()).
Checks whether the calendar saves schedules.
Requests the calendar backend to create the object specified by the icalcomp
argument. Some backends would assign a specific UID to the newly created object,
but this function does not modify the original icalcomp if its UID changes.
The call is finished by e_cal_client_create_object_finish() from
the callback.
The component to create
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_create_object() and
sets out_uid to newly assigned UID for the created object.
This out_uid should be freed with g_free().
a #GAsyncResult
Requests the calendar backend to create the object specified by the
icalcomp argument. Some backends would assign a specific UID to the newly
created object, in those cases that UID would be returned in the out_uid
argument. This function does not modify the original icalcomp if its UID
changes. Returned out_uid should be freed with g_free().
The component to create
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
Requests the calendar backend to create the objects specified by the icalcomps
argument. Some backends would assign a specific UID to the newly created object,
but this function does not modify the original icalcomps if their UID changes.
The call is finished by e_cal_client_create_objects_finish() from
the callback.
The components to create
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_create_objects() and
sets out_uids to newly assigned UIDs for the created objects.
This out_uids should be freed with e_client_util_free_string_slist().
a #GAsyncResult
Requests the calendar backend to create the objects specified by the
icalcomps argument. Some backends would assign a specific UID to the
newly created objects, in those cases these UIDs would be returned in
the out_uids argument. This function does not modify the original
icalcomps if their UID changes. Returned out_uids should be freed
with e_client_util_free_string_slist().
The components to create
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
Discards alarm auid from a given component identified by uid and rid.
The call is finished by e_cal_client_discard_alarm_finish() from
the callback.
Unique identifier for a calendar component
Recurrence identifier
Alarm identifier to discard
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_discard_alarm().
a #GAsyncResult
Discards alarm auid from a given component identified by uid and rid.
Unique identifier for a calendar component
Recurrence identifier
Alarm identifier to discard
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
Returns a D-Bus bus name that will be used to connect the client to the backend subprocess.
This function is intended for #GObject implementations to re-enforce a [floating][floating-ref] object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink().
Increases the freeze count on object. If the freeze count is
non-zero, the emission of "notify" signals on object is
stopped. The signals are queued until the freeze count is decreased
to zero. Duplicate notifications are squashed so that at most one
#GObject::notify signal is emitted for each property modified while the
object is frozen.
This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.
Does a combination of e_cal_client_get_object_list() and
e_cal_recur_generate_instances_sync(). Unlike
e_cal_client_generate_instances_sync(), this returns immediately and the
cb callback is called asynchronously.
The callback function should do a g_object_ref() of the calendar component it gets passed if it intends to keep it around, since it will be unref'ed as soon as the callback returns.
Start time for query.
End time for query.
a #GCancellable; can be %NULL
Callback for each generated instance.
Does a combination of e_cal_client_get_object_list() and
e_cal_recur_generate_instances_sync(), like
e_cal_client_generate_instances(), but for a single object. Unlike
e_cal_client_generate_instances_for_object_sync(), this returns immediately
and the cb callback is called asynchronously.
The callback function should do a g_object_ref() of the calendar component it gets passed if it intends to keep it around, since it will be unref'ed as soon as the callback returns.
Object to generate instances from.
Start time for query.
End time for query.
a #GCancellable; can be %NULL
Callback for each generated instance.
Does a combination of e_cal_client_get_object_list() and e_cal_recur_generate_instances_sync(), like e_cal_client_generate_instances_sync(), but for a single object.
The callback function should do a g_object_ref() of the calendar component it gets passed if it intends to keep it around, since it will be unref'ed as soon as the callback returns.
Object to generate instances from
Start time for query
End time for query
a #GCancellable; can be %NULL
Callback for each generated instance
Does a combination of e_cal_client_get_object_list() and e_cal_recur_generate_instances_sync().
The callback function should do a g_object_ref() of the calendar component it gets passed if it intends to keep it around, since it will be unreffed as soon as the callback returns.
Start time for query
End time for query
a #GCancellable; can be %NULL
Callback for each generated instance
Queries a calendar for a specified component's object attachment uris.
The call is finished by e_cal_client_get_attachment_uris_finish() from
the callback.
Unique identifier for a calendar component
Recurrence identifier
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_get_attachment_uris() and
sets out_attachment_uris to uris for component's attachments.
The list should be freed with e_client_util_free_string_slist().
a #GAsyncResult
Queries a calendar for a specified component's object attachment URIs. The list should be freed with e_client_util_free_string_slist().
Unique identifier for a calendar component
Recurrence identifier
a #GCancellable; can be %NULL
Queries client's backend for a property of name prop_name.
The call is finished by e_client_get_backend_property_finish()
from the callback.
property name, whose value to retrieve; cannot be %NULL
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_get_backend_property().
a #GAsyncResult
Queries client's backend for a property of name prop_name.
property name, whose value to retrieve; cannot be %NULL
a #GCancellable; can be %NULL
Get list of strings with capabilities advertised by a backend.
This list, together with inner strings, is owned by the client.
To check for individual capabilities use e_client_check_capability().
Gets a named field from the objects table of associations (see g_object_set_data()).
name of the key for that association
Retrives an #ICalComponent from the backend that contains the default
values for properties needed. The call is finished
by e_cal_client_get_default_object_finish() from the callback.
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_get_default_object() and
sets out_icalcomp to an #ICalComponent from the backend that contains
the default values for properties needed. This out_icalcomp should be
freed with g_object_unref(), when no longer needed.
a #GAsyncResult
Retrives an #ICalComponent from the backend that contains the default
values for properties needed. This out_icalcomp should be freed with
g_object_unref(), when no longer needed.
a #GCancellable; can be %NULL
Begins retrieval of free/busy information from the calendar server
as a list of #ECalComponent-s. Connect to "free-busy-data" signal
to receive chunks of free/busy components.
The call is finished by e_cal_client_get_free_busy_finish() from
the callback.
Start time for query
End time for query
List of users to retrieve free/busy information for
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_get_free_busy().
The out_freebusy contains all VFREEBUSY #ECalComponent-s, which could be also
received by "free-busy-data" signal. The client is responsible to do a merge of
the components between this complete list and those received through the signal.
a #GAsyncResult
Gets free/busy information from the calendar server.
The out_freebusy contains all VFREEBUSY #ECalComponent-s, which could be also
received by "free-busy-data" signal. The client is responsible to do a merge of
the components between this complete list and those received through the signal.
Start time for query
End time for query
List of users to retrieve free/busy information for
a #GCancellable; can be %NULL
Queries the URL where the calendar attachments are serialized in the local filesystem. This enable clients to operate with the reference to attachments rather than the data itself unless it specifically uses the attachments for open/sending operations.
Queries a calendar for a calendar component object based on its unique
identifier. The call is finished by e_cal_client_get_object_finish()
from the callback.
Use e_cal_client_get_objects_for_uid() to get list of all objects for the given uid, which includes master object and all detached instances.
Unique identifier for a calendar component.
Recurrence identifier.
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_get_object() and
sets out_icalcomp to queried component. This function always returns
master object for a case of rid being NULL or an empty string.
This component should be freed with g_object_unref(), when no longer needed.
Use e_cal_client_get_objects_for_uid() to get list of all objects for the given uid, which includes master object and all detached instances.
a #GAsyncResult
Gets a list of objects from the calendar that match the query specified
by the sexp argument, returning matching objects as a list of #ICalComponent-s.
The call is finished by e_cal_client_get_object_list_finish() from
the callback.
an S-expression representing the query
a #GCancellable; can be %NULL
callback to call when a result is ready
Gets a list of objects from the calendar that match the query specified
by the sexp argument, returning matching objects as a list of #ECalComponent-s.
The call is finished by e_cal_client_get_object_list_as_comps_finish() from
the callback.
an S-expression representing the query
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_get_object_list_as_comps() and
sets out_ecalcomps to a matching list of #ECalComponent-s.
This list should be freed with e_client_util_free_object_slist().
a #GAsyncResult
Gets a list of objects from the calendar that match the query specified
by the sexp argument. The objects will be returned in the out_ecalcomps
argument, which is a list of #ECalComponent.
This list should be freed with e_client_util_free_object_slist().
an S-expression representing the query
a #GCancellable; can be %NULL
Finishes previous call of e_cal_client_get_object_list() and
sets out_icalcomps to a matching list of #ICalComponent-s.
This list should be freed with e_client_util_free_object_slist().
a #GAsyncResult
Gets a list of objects from the calendar that match the query specified
by the sexp argument. The objects will be returned in the out_icalcomps
argument, which is a list of #ICalComponent.
This list should be freed with e_client_util_free_object_slist().
an S-expression representing the query
a #GCancellable; can be %NULL
Queries a calendar for a calendar component object based
on its unique identifier. This function always returns
master object for a case of rid being NULL or an empty string.
This component should be freed with g_object_unref(),
when no longer needed.
Use e_cal_client_get_objects_for_uid_sync() to get list of all objects for the given uid, which includes master object and all detached instances.
Unique identifier for a calendar component.
Recurrence identifier.
a #GCancellable; can be %NULL
Queries a calendar for all calendar components with the given unique
ID. This will return any recurring event and all its detached recurrences.
For non-recurring events, it will just return the object with that ID.
The call is finished by e_cal_client_get_objects_for_uid_finish() from
the callback.
Unique identifier for a calendar component
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_get_objects_for_uid() and
sets out_ecalcomps to a list of #ECalComponents corresponding to
found components for a given uid of the same type as this client.
This list should be freed with e_client_util_free_object_slist().
a #GAsyncResult
Queries a calendar for all calendar components with the given unique ID. This will return any recurring event and all its detached recurrences. For non-recurring events, it will just return the object with that ID. This list should be freed with e_client_util_free_object_slist().
Unique identifier for a calendar component
a #GCancellable; can be %NULL
Gets a property of an object.
The value can be:
In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset().
Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming.
the name of the property to get
return location for the property value
This function gets back user data pointers stored via g_object_set_qdata().
A #GQuark, naming the user data pointer
Get the #ESource that this client has assigned.
Gets the source type of the calendar client.
Retrieves a timezone object from the calendar backend.
The call is finished by e_cal_client_get_timezone_finish() from
the callback.
ID of the timezone to retrieve
a #GCancellable; can be %NULL
callback to call when a result is ready
Obtains an #ICalTimezone by its TZID string. If no match is found,
the function returns %NULL. The returned #ICalTimezone is owned by
the cache and should not be modified or freed.
the TZID of a timezone
Finishes previous call of e_cal_client_get_timezone() and
sets out_zone to a retrieved timezone object from the calendar backend.
This object is owned by the client, thus do not free it.
a #GAsyncResult
Retrieves a timezone object from the calendar backend.
This object is owned by the client, thus do not free it.
ID of the timezone to retrieve
a #GCancellable; can be %NULL
Query client with sexp, creating an #ECalClientView.
The call is finished by e_cal_client_get_view_finish()
from the callback.
an S-expression representing the query.
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_get_view().
If successful, then the out_view is set to newly allocated #ECalClientView,
which should be freed with g_object_unref().
a #GAsyncResult
Query client with sexp, creating an #ECalClientView.
If successful, then the out_view is set to newly allocated #ECalClientView,
which should be freed with g_object_unref().
an S-expression representing the query.
a #GCancellable; can be %NULL
Gets n_properties properties for an object.
Obtained properties will be set to values. All properties must be valid.
Warnings will be emitted and undefined behaviour may result if invalid
properties are passed in.
the names of each property to get
the values of each property to get
Initializes the object implementing the interface.
This method is intended for language bindings. If writing in C, g_initable_new() should typically be used instead.
The object must be initialized before any real use after initial construction, either with this function or g_async_initable_init_async().
Implementations may also support cancellation. If cancellable is not %NULL,
then initialization can be cancelled by triggering the cancellable object
from another thread. If the operation was cancelled, the error
%G_IO_ERROR_CANCELLED will be returned. If cancellable is not %NULL and
the object doesn't support cancellable initialization the error
%G_IO_ERROR_NOT_SUPPORTED will be returned.
If the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. See the [introduction][ginitable] for more details.
Callers should not assume that a class which implements #GInitable can be initialized multiple times, unless the class explicitly documents itself as supporting this. Generally, a class’ implementation of init() can assume (and assert) that it will only be called once. Previously, this documentation recommended all #GInitable implementations should be idempotent; that recommendation was relaxed in GLib 2.54.
If a class explicitly supports being initialized multiple times, it is recommended that the method is idempotent: multiple calls with the same arguments should return the same results. Only the first call initializes the object; further calls return the result of the first call.
One reason why a class might need to support idempotent initialization is if it is designed to be used via the singleton pattern, with a #GObjectClass.constructor that sometimes returns an existing instance. In this pattern, a caller would expect to be able to call g_initable_init() on the result of g_object_new(), regardless of whether it is in fact a new instance.
optional #GCancellable object, %NULL to ignore.
Starts asynchronous initialization of the object implementing the interface. This must be done before any real use of the object after initial construction. If the object also implements #GInitable you can optionally call g_initable_init() instead.
This method is intended for language bindings. If writing in C, g_async_initable_new_async() should typically be used instead.
When the initialization is finished, callback will be called. You can
then call g_async_initable_init_finish() to get the result of the
initialization.
Implementations may also support cancellation. If cancellable is not
%NULL, then initialization can be cancelled by triggering the cancellable
object from another thread. If the operation was cancelled, the error
%G_IO_ERROR_CANCELLED will be returned. If cancellable is not %NULL, and
the object doesn't support cancellable initialization, the error
%G_IO_ERROR_NOT_SUPPORTED will be returned.
As with #GInitable, if the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. They will often fail with g_critical() or g_warning(), but this must not be relied on.
Callers should not assume that a class which implements #GAsyncInitable can be initialized multiple times; for more information, see g_initable_init(). If a class explicitly supports being initialized multiple times, implementation requires yielding all subsequent calls to init_async() on the results of the first call.
For classes that also support the #GInitable interface, the default implementation of this method will run the g_initable_init() function in a thread, so if you want to support asynchronous initialization via threads, just implement the #GAsyncInitable interface without overriding any interface methods.
the [I/O priority][io-priority] of the operation
optional #GCancellable object, %NULL to ignore.
a #GAsyncReadyCallback to call when the request is satisfied
Finishes asynchronous initialization and returns the result. See g_async_initable_init_async().
a #GAsyncResult.
Checks whether object has a [floating][floating-ref] reference.
Check if this client is connected.
Check if this client is fully opened. This includes
everything from e_client_open() call up to the authentication,
if required by a backend. Client cannot do any other operation
during the opening phase except of authenticate or cancel it.
Every other operation results in an %E_CLIENT_ERROR_BUSY error.
Check if this client is read-only.
Returns a list of #ICalTimezone instances that were explicitly added to
the cache through e_timezone_cache_add_timezone(). In particular, any
built-in time zone data that e_timezone_cache_get_timezone() may use to
match a TZID string is excluded from the returned list.
Free the returned list with g_list_free(). The list elements are owned
by the cache and should not be modified or freed.
Requests the calendar backend to modify an existing object. If the object does not exist on the calendar, an error will be returned.
For recurrent appointments, the mod argument specifies what to modify,
if all instances (#E_CAL_OBJ_MOD_ALL), a single instance (#E_CAL_OBJ_MOD_THIS),
or a specific set of instances (#E_CAL_OBJ_MOD_THIS_AND_PRIOR and
#E_CAL_OBJ_MOD_THIS_AND_FUTURE).
The call is finished by e_cal_client_modify_object_finish() from
the callback.
Component to modify
Type of modification
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_modify_object().
a #GAsyncResult
Requests the calendar backend to modify an existing object. If the object does not exist on the calendar, an error will be returned.
For recurrent appointments, the mod argument specifies what to modify,
if all instances (#E_CAL_OBJ_MOD_ALL), a single instance (#E_CAL_OBJ_MOD_THIS),
or a specific set of instances (#E_CAL_OBJ_MOD_THIS_AND_PRIOR and
#E_CAL_OBJ_MOD_THIS_AND_FUTURE).
Component to modify
Type of modification
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
Requests the calendar backend to modify existing objects. If an object does not exist on the calendar, an error will be returned.
For recurrent appointments, the mod argument specifies what to modify,
if all instances (#E_CAL_OBJ_MOD_ALL), a single instance (#E_CAL_OBJ_MOD_THIS),
or a specific set of instances (#E_CAL_OBJ_MOD_THIS_AND_PRIOR and
#E_CAL_OBJ_MOD_THIS_AND_FUTURE).
The call is finished by e_cal_client_modify_objects_finish() from
the callback.
Components to modify
Type of modification
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_modify_objects().
a #GAsyncResult
Requests the calendar backend to modify existing objects. If an object does not exist on the calendar, an error will be returned.
For recurrent appointments, the mod argument specifies what to modify,
if all instances (#E_CAL_OBJ_MOD_ALL), a single instance (#E_CAL_OBJ_MOD_THIS),
or a specific set of instances (#E_CAL_OBJ_MOD_THIS_AND_PRIOR and
#E_CAL_OBJ_MOD_THIS_AND_FUTURE).
Components to modify
Type of modification
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
Finishes the async construction for the various g_async_initable_new calls, returning the created object or %NULL on error.
the #GAsyncResult from the callback
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
the name of a property installed on the class of object.
Emits a "notify" signal for the property specified by pspec on object.
This function omits the property name lookup, hence it is faster than g_object_notify().
One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with g_object_class_install_property() inside a static array, e.g.:
enum
{
PROP_0,
PROP_FOO,
PROP_LAST
};
static GParamSpec *properties[PROP_LAST];
static void
my_object_class_init (MyObjectClass *klass)
{
properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
0, 100,
50,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_FOO,
properties[PROP_FOO]);
}
and then notify a change on the "foo" property with:
g_object_notify_by_pspec (self, properties[PROP_FOO]);
the #GParamSpec of a property installed on the class of object.
Opens the client, making it ready for queries and other operations.
The call is finished by e_client_open_finish() from the callback.
this parameter is not used anymore
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_open().
a #GAsyncResult
Opens the client, making it ready for queries and other operations.
this parameter is not used anymore
a #GCancellable; can be %NULL
Makes the backend receive the set of iCalendar objects specified in the
icalcomp argument. This is used for iTIP confirmation/cancellation
messages for scheduled meetings.
The call is finished by e_cal_client_receive_objects_finish() from
the callback.
An #ICalComponent
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_receive_objects().
a #GAsyncResult
Makes the backend receive the set of iCalendar objects specified in the
icalcomp argument. This is used for iTIP confirmation/cancellation
messages for scheduled meetings.
An #ICalComponent
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
Returns the #GMainContext on which event sources for client are to
be attached.
The returned #GMainContext is referenced for thread-safety and must be unreferenced with g_main_context_unref() when finished with it.
Increase the reference count of object, and possibly remove the
[floating][floating-ref] reference, if object has a floating reference.
In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.
Since GLib 2.56, the type of object will be propagated to the return type
under the same conditions as for g_object_ref().
Initiates refresh on the client. Finishing the method doesn't mean
that the refresh is done, backend only notifies whether it started
refreshing or not. Use e_client_check_refresh_supported() to check
whether the backend supports this method.
The call is finished by e_client_refresh_finish() from the callback.
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_refresh().
a #GAsyncResult
Initiates refresh on the client. Finishing the method doesn't mean
that the refresh is done, backend only notifies whether it started
refreshing or not. Use e_client_check_refresh_supported() to check
whether the backend supports this method.
a #GCancellable; can be %NULL
Removes the backing data for this #EClient. For example, with the file
backend this deletes the database file. You cannot get it back!
The call is finished by e_client_remove_finish() from the callback.
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_remove().
a #GAsyncResult
This function allows the removal of instances of a recurrent
appointment. By using a combination of the uid, rid and mod
arguments, you can remove specific instances. If what you want
is to remove all instances, use %NULL rid and #E_CAL_OBJ_MOD_ALL
for the mod.
The call is finished by e_cal_client_remove_object_finish() from
the callback.
UID of the object to remove
Recurrence ID of the specific recurrence to remove
Type of the removal
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_remove_object().
a #GAsyncResult
This function allows the removal of instances of a recurrent
appointment. By using a combination of the uid, rid and mod
arguments, you can remove specific instances. If what you want
is to remove all instances, use %NULL rid and #E_CAL_OBJ_MOD_ALL
for the mod.
UID of the object to remove
Recurrence ID of the specific recurrence to remove
Type of the removal
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
This function allows the removal of instances of recurrent appointments.
#ECalComponentId objects can identify specific instances (if rid is not
%NULL). If what you want is to remove all instances, use a %NULL rid in
the #ECalComponentId and #E_CAL_OBJ_MOD_ALL for the mod.
The call is finished by e_cal_client_remove_objects_finish() from
the callback.
A list of #ECalComponentId objects identifying the objects to remove
Type of the removal
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_remove_objects().
a #GAsyncResult
This function allows the removal of instances of recurrent
appointments. #ECalComponentId objects can identify specific instances
(if rid is not %NULL). If what you want is to remove all instances, use
a %NULL rid in the #ECalComponentId and #E_CAL_OBJ_MOD_ALL for the mod.
a list of #ECalComponentId objects identifying the objects to remove
Type of the removal
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
Removes the backing data for this #EClient. For example, with the file backend this deletes the database file. You cannot get it back!
a #GCancellable; can be %NULL
Initiates retrieval of capabilities on the client. This is usually
required only once, after the client is opened. The returned value
is cached and any subsequent call of e_client_get_capabilities() and
e_client_check_capability() is using the cached value.
The call is finished by e_client_retrieve_capabilities_finish()
from the callback.
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_retrieve_capabilities().
Returned value of capabilities should be freed with g_free(),
when no longer needed.
a #GAsyncResult
Initiates retrieval of capabilities on the client. This is usually
required only once, after the client is opened. The returned value
is cached and any subsequent call of e_client_get_capabilities() and
e_client_check_capability() is using the cached value. Returned value
of capabilities should be freed with g_free(), when no longer needed.
a #GCancellable; can be %NULL
Asynchronously retrieves client properties to match server-side values,
without waiting for the D-Bus property change notifications delivery.
When the operation is finished, callback will be called. You can then
call e_client_retrieve_properties_finish() to get the result of the operation.
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with e_client_retrieve_properties().
If an error occurs, the function sets error and returns %FALSE.
a #GAsyncResult
Retrieves client properties to match server-side values, without waiting
for the D-Bus property change notifications delivery.
If an error occurs, the function sets error and returns %FALSE.
optional #GCancellable object, or %NULL
Releases all references to other objects. This can be used to break reference cycles.
This function should only be called from object system implementations.
Requests a calendar backend to send meeting information stored in icalcomp.
The backend can modify this component and request a send to particular users.
The call is finished by e_cal_client_send_objects_finish() from
the callback.
An #ICalComponent to be sent
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_cal_client_send_objects() and
populates out_users with a list of users to send out_modified_icalcomp to.
The out_users list should be freed with e_client_util_free_string_slist()
and the out_modified_icalcomp should be freed with g_object_unref().
a #GAsyncResult
Requests a calendar backend to send meeting information stored in icalcomp.
The backend can modify this component and request a send to users in the
out_users list.
The out_users list should be freed with e_client_util_free_string_slist()
and the out_modified_icalcomp should be freed with g_object_unref().
An #ICalComponent to be sent
bit-or of #ECalOperationFlags
a #GCancellable; can be %NULL
Sets client's backend property of name prop_name
to value prop_value. The call is finished
by e_client_set_backend_property_finish() from the callback.
property name, whose value to change; cannot be %NULL
property value, to set; cannot be %NULL
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_set_backend_property().
a #GAsyncResult
Sets client's backend property of name prop_name
to value prop_value.
property name, whose value to change; cannot be %NULL
property value, to set; cannot be %NULL
a #GCancellable; can be %NULL
Sets a D-Bus bus name that will be used to connect the client to the backend subprocess.
a string representing a D-Bus bus name
Each object carries around a table of associations from strings to pointers. This function lets you set an association.
If the object already had an association with that name, the old association will be destroyed.
Internally, the key is converted to a #GQuark using g_quark_from_string().
This means a copy of key is kept permanently (even after object has been
finalized) — so it is recommended to only use a small, bounded set of values
for key in your program, to avoid the #GQuark storage growing unbounded.
name of the key
data to associate with that key
Sets a property on an object.
the name of the property to set
the value
Remove a specified datum from the object's data associations, without invoking the association's destroy handler.
name of the key
This function gets back user data pointers stored via
g_object_set_qdata() and removes the data from object
without invoking its destroy() function (if any was
set).
Usually, calling this function is only required to update
user data pointers with a destroy notifier, for example:
void
object_add_to_user_list (GObject *object,
const gchar *new_string)
{
// the quark, naming the object data
GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
// retrieve the old string list
GList *list = g_object_steal_qdata (object, quark_string_list);
// prepend new string
list = g_list_prepend (list, g_strdup (new_string));
// this changed 'list', so we need to set it again
g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
}
static void
free_string_list (gpointer data)
{
GList *node, *list = data;
for (node = list; node; node = node->next)
g_free (node->data);
g_list_free (list);
}
Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full().
A #GQuark, naming the user data pointer
Reverts the effect of a previous call to
g_object_freeze_notify(). The freeze count is decreased on object
and when it reaches zero, queued "notify" signals are emitted.
Duplicate notifications for each property are squashed so that at most one #GObject::notify signal is emitted for each property, in the reverse order in which they have been queued.
It is an error to call this function when the freeze count is zero.
Decreases the reference count of object. When its reference count
drops to 0, the object is finalized (i.e. its memory is freed).
If the pointer to the #GObject may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to %NULL rather than retain a dangling pointer to a potentially invalid #GObject instance. Use g_clear_object() for this.
Queries client's backend for a property of name prop_name.
The call is finished by e_client_get_backend_property_finish()
from the callback.
property name, whose value to retrieve; cannot be %NULL
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_get_backend_property().
a #GAsyncResult
Queries client's backend for a property of name prop_name.
property name, whose value to retrieve; cannot be %NULL
a #GCancellable; can be %NULL
Initializes the object implementing the interface.
This method is intended for language bindings. If writing in C, g_initable_new() should typically be used instead.
The object must be initialized before any real use after initial construction, either with this function or g_async_initable_init_async().
Implementations may also support cancellation. If cancellable is not %NULL,
then initialization can be cancelled by triggering the cancellable object
from another thread. If the operation was cancelled, the error
%G_IO_ERROR_CANCELLED will be returned. If cancellable is not %NULL and
the object doesn't support cancellable initialization the error
%G_IO_ERROR_NOT_SUPPORTED will be returned.
If the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. See the [introduction][ginitable] for more details.
Callers should not assume that a class which implements #GInitable can be initialized multiple times, unless the class explicitly documents itself as supporting this. Generally, a class’ implementation of init() can assume (and assert) that it will only be called once. Previously, this documentation recommended all #GInitable implementations should be idempotent; that recommendation was relaxed in GLib 2.54.
If a class explicitly supports being initialized multiple times, it is recommended that the method is idempotent: multiple calls with the same arguments should return the same results. Only the first call initializes the object; further calls return the result of the first call.
One reason why a class might need to support idempotent initialization is if it is designed to be used via the singleton pattern, with a #GObjectClass.constructor that sometimes returns an existing instance. In this pattern, a caller would expect to be able to call g_initable_init() on the result of g_object_new(), regardless of whether it is in fact a new instance.
optional #GCancellable object, %NULL to ignore.
Starts asynchronous initialization of the object implementing the interface. This must be done before any real use of the object after initial construction. If the object also implements #GInitable you can optionally call g_initable_init() instead.
This method is intended for language bindings. If writing in C, g_async_initable_new_async() should typically be used instead.
When the initialization is finished, callback will be called. You can
then call g_async_initable_init_finish() to get the result of the
initialization.
Implementations may also support cancellation. If cancellable is not
%NULL, then initialization can be cancelled by triggering the cancellable
object from another thread. If the operation was cancelled, the error
%G_IO_ERROR_CANCELLED will be returned. If cancellable is not %NULL, and
the object doesn't support cancellable initialization, the error
%G_IO_ERROR_NOT_SUPPORTED will be returned.
As with #GInitable, if the object is not initialized, or initialization returns with an error, then all operations on the object except g_object_ref() and g_object_unref() are considered to be invalid, and have undefined behaviour. They will often fail with g_critical() or g_warning(), but this must not be relied on.
Callers should not assume that a class which implements #GAsyncInitable can be initialized multiple times; for more information, see g_initable_init(). If a class explicitly supports being initialized multiple times, implementation requires yielding all subsequent calls to init_async() on the results of the first call.
For classes that also support the #GInitable interface, the default implementation of this method will run the g_initable_init() function in a thread, so if you want to support asynchronous initialization via threads, just implement the #GAsyncInitable interface without overriding any interface methods.
the [I/O priority][io-priority] of the operation
optional #GCancellable object, %NULL to ignore.
a #GAsyncReadyCallback to call when the request is satisfied
Finishes asynchronous initialization and returns the result. See g_async_initable_init_async().
a #GAsyncResult.
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
Opens the client, making it ready for queries and other operations.
The call is finished by e_client_open_finish() from the callback.
this parameter is not used anymore
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_open().
a #GAsyncResult
Opens the client, making it ready for queries and other operations.
this parameter is not used anymore
a #GCancellable; can be %NULL
Initiates refresh on the client. Finishing the method doesn't mean
that the refresh is done, backend only notifies whether it started
refreshing or not. Use e_client_check_refresh_supported() to check
whether the backend supports this method.
The call is finished by e_client_refresh_finish() from the callback.
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_refresh().
a #GAsyncResult
Initiates refresh on the client. Finishing the method doesn't mean
that the refresh is done, backend only notifies whether it started
refreshing or not. Use e_client_check_refresh_supported() to check
whether the backend supports this method.
a #GCancellable; can be %NULL
Removes the backing data for this #EClient. For example, with the file
backend this deletes the database file. You cannot get it back!
The call is finished by e_client_remove_finish() from the callback.
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_remove().
a #GAsyncResult
Removes the backing data for this #EClient. For example, with the file backend this deletes the database file. You cannot get it back!
a #GCancellable; can be %NULL
Initiates retrieval of capabilities on the client. This is usually
required only once, after the client is opened. The returned value
is cached and any subsequent call of e_client_get_capabilities() and
e_client_check_capability() is using the cached value.
The call is finished by e_client_retrieve_capabilities_finish()
from the callback.
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_retrieve_capabilities().
Returned value of capabilities should be freed with g_free(),
when no longer needed.
a #GAsyncResult
Initiates retrieval of capabilities on the client. This is usually
required only once, after the client is opened. The returned value
is cached and any subsequent call of e_client_get_capabilities() and
e_client_check_capability() is using the cached value. Returned value
of capabilities should be freed with g_free(), when no longer needed.
a #GCancellable; can be %NULL
Retrieves client properties to match server-side values, without waiting
for the D-Bus property change notifications delivery.
If an error occurs, the function sets error and returns %FALSE.
optional #GCancellable object, or %NULL
Sets client's backend property of name prop_name
to value prop_value. The call is finished
by e_client_set_backend_property_finish() from the callback.
property name, whose value to change; cannot be %NULL
property value, to set; cannot be %NULL
a #GCancellable; can be %NULL
callback to call when a result is ready
Finishes previous call of e_client_set_backend_property().
a #GAsyncResult
Sets client's backend property of name prop_name
to value prop_value.
property name, whose value to change; cannot be %NULL
property value, to set; cannot be %NULL
a #GCancellable; can be %NULL
Asynchronously waits until the client is connected (according
to ESource::connection-status property), but not longer than timeout_seconds.
The call is finished by e_client_wait_for_connected_finish() from
the callback.
a timeout for the wait, in seconds
a #GCancellable; or %NULL
callback to call when a result is ready
Finishes previous call of e_client_wait_for_connected().
a #GAsyncResult
Synchronously waits until the client is connected (according
to ESource::connection-status property), but not longer than timeout_seconds.
Note: This also calls e_client_retrieve_properties_sync() on success, to have up-to-date property values on the client side, without a delay due to property change notifcations delivery through D-Bus.
a timeout for the wait, in seconds
a #GCancellable; or %NULL
This function essentially limits the life time of the closure to
the life time of the object. That is, when the object is finalized,
the closure is invalidated by calling g_closure_invalidate() on
it, in order to prevent invocations of the closure with a finalized
(nonexisting) object. Also, g_object_ref() and g_object_unref() are
added as marshal guards to the closure, to ensure that an extra
reference count is held on object during invocation of the
closure. Usually, this function will be called on closures that
use this object as closure data.
#GClosure to watch
This function cleans up VEVENT, VJOURNAL, VTODO and VTIMEZONE items which are to be imported into Evolution.
Using VTIMEZONE definitions is problematic because they cannot be updated properly when timezone definitions change. They are also incomplete (for compatibility reason only one set of rules for summer saving changes can be included, even if different rules apply in different years). This function looks for matches of the used TZIDs against system timezones and replaces such TZIDs with the corresponding system timezone. This works for TZIDs containing a location (found via a fuzzy string search) and for Outlook TZIDs (via a hard-coded lookup table).
Some programs generate broken meeting invitations with TZID, but without including the corresponding VTIMEZONE. Importing such invitations unchanged causes problems later on (meeting displayed incorrectly, e_cal_component_get_as_string() fails). The situation where this occurred in the past (found by a SyncEvolution user) is now handled via the location based mapping.
If this mapping fails, this function also deals with VTIMEZONE conflicts: such conflicts occur when the calendar already contains an old VTIMEZONE definition with the same TZID, but different summer saving rules. Replacing the VTIMEZONE potentially breaks displaying of old events, whereas not replacing it breaks the new events (the behavior in Evolution <= 2.22.1).
The way this problem is resolved by renaming the new VTIMEZONE definition until the TZID is unique. A running count is appended to the TZID. All items referencing the renamed TZID are adapted accordingly.
a VCALENDAR containing a list of VTIMEZONE and arbitrary other components, in arbitrary order: these other components are modified by this call
a list of #ICalComponent instances which also have to be patched; may be %NULL
a #GCancellable to use in tzlookup function
Asynchronously creates a new #ECalClient for source and source_type.
The wait_for_connected_seconds argument had been added since 3.16,
to let the caller decide how long to wait for the backend to fully
connect to its (possibly remote) data store. This is required due
to a change in the authentication process, which is fully asynchronous
and done on the client side, while not every client is supposed to
response to authentication requests. In case the backend will not connect
within the set interval, then it is opened in an offline mode. A special
value -1 can be used to not wait for the connected state at all.
Unlike with e_cal_client_new(), there is no need to call e_client_open() after obtaining the #ECalClient.
When the operation is finished, callback will be called. You can then
call e_cal_client_connect_finish() to get the result of the operation.
an #ESource
source tpe of the calendar
timeout, in seconds, to wait for the backend to be fully connected
optional #GCancellable object, or %NULL
a #GAsyncReadyCallback to call when the request is satisfied
Finishes the operation started with e_cal_client_connect(). If an
error occurs in connecting to the D-Bus service, the function sets
error and returns %NULL.
For error handling convenience, any error message returned by this function will have a descriptive prefix that includes the display name of the #ESource passed to e_cal_client_connect().
a #GAsyncResult
Creates a new #ECalClient for source and source_type. If an error
occurs, the function will set error and return %FALSE.
The wait_for_connected_seconds argument had been added since 3.16,
to let the caller decide how long to wait for the backend to fully
connect to its (possibly remote) data store. This is required due
to a change in the authentication process, which is fully asynchronous
and done on the client side, while not every client is supposed to
response to authentication requests. In case the backend will not connect
within the set interval, then it is opened in an offline mode. A special
value -1 can be used to not wait for the connected state at all.
Unlike with e_cal_client_new(), there is no need to call e_client_open_sync() after obtaining the #ECalClient.
For error handling convenience, any error message returned by this
function will have a descriptive prefix that includes the display
name of source.
an #ESource
source type of the calendar
timeout, in seconds, to wait for the backend to be fully connected
optional #GCancellable object, or %NULL
Get localized human readable description of the given error code.
an #ECalClientError error code
Get localized human readable description of the given error code.
an #EClientError error code
Find the #GParamSpec with the given name for an
interface. Generally, the interface vtable passed in as g_iface
will be the default vtable from g_type_default_interface_ref(), or,
if you know the interface has already been loaded,
g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
name of a property to look up.
Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created #GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property.
This function is meant to be called from the interface's default
vtable initialization function (the class_init member of
#GTypeInfo.) It must not be called after after class_init has
been called for any object types implementing this interface.
If pspec is a floating reference, it will be consumed.
any interface vtable for the interface, or the default vtable for the interface.
the #GParamSpec for the new property
Lists the properties of an interface.Generally, the interface
vtable passed in as g_iface will be the default vtable from
g_type_default_interface_ref(), or, if you know the interface has
already been loaded, g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
Creates a new instance of a #GObject subtype and sets its properties.
Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values.
the type id of the #GObject subtype to instantiate
an array of #GParameter
An implementation of the #ECalRecurResolveTimezoneCb callback which clients can use. Calls e_cal_client_get_timezone_sync().
The returned timezone object, if not %NULL, is owned by the ecalclient.
ID of the timezone to lookup
a valid #ECalClient pointer
an optional #GCancellable to use, or %NULL
An implementation of the #ECalRecurResolveTimezoneCb callback which
backends can use. Searches for the timezone in an %ICalComponent
associated with the lookup_data %ECalClientTzlookupICalCompData.
The returned timezone object is owned by the lookup_data.
ID of the timezone to lookup
an #ECalClientTzlookupICalCompData strcture, created with e_cal_client_tzlookup_icalcomp_data_new()
an optional #GCancellable to use, or %NULL
Copies the #GSList of strings to the end of copy_to.
Where to copy; may be %NULL
#GSList of strings to be copied
Frees memory previously allocated by e_client_util_strv_to_slist().
a #GSList of strings (gchar *)
Parses comma-separated list of values into #GSList.
string of comma-separated values
Convert a list of strings into a %NULL-terminated array of strings.
a #GSList of strings (const gchar *)
Convert a %NULL-terminated array of strings to a list of strings.
a %NULL-terminated array of strings (const gchar *)
The function takes a dbus_error and tries to find a match in known_errors
for it, if it is a G_IO_ERROR, G_IO_ERROR_DBUS_ERROR. If it is anything else
then the dbus_error is moved to client_error.
The fail_when_none_matched influences behaviour. If it's %TRUE, and none of
known_errors matches, or this is not a G_IO_ERROR_DBUS_ERROR, then %FALSE
is returned and the client_error is left without change. Otherwise, the
fail_when_none_matched is %FALSE, the error is always processed and will
result in E_CLIENT_ERROR, E_CLIENT_ERROR_OTHER_ERROR if none of known_error
matches.
DBus #GError to unwrap
List of known errors against which try to match
How many items are stored in known_errors
Error domain for known_errors
Whether to fail when none of known_errors matches
Contains only private data that should be read and manipulated using the functions below.