e_dbus_source_interface_info ()

GDBusInterfaceInfo *
e_dbus_source_interface_info (void);

Gets a machine-readable description of the org.gnome.evolution.dataserver.Source D-Bus interface.

e_dbus_source_override_properties ()

guint
e_dbus_source_override_properties (GObjectClass *klass,
                                   guint property_id_begin);

Overrides all GObject properties in the EDBusSource interface for a concrete class. The properties are overridden in the order they are defined.

e_dbus_source_complete_invoke_credentials_required ()

void
e_dbus_source_complete_invoke_credentials_required
                               (EDBusSource *object,
                                GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the InvokeCredentialsRequired() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

Since: 3.16

e_dbus_source_complete_get_last_credentials_required_arguments ()

void
e_dbus_source_complete_get_last_credentials_required_arguments
                               (EDBusSource *object,
                                GDBusMethodInvocation *invocation,
                                const gchar *reason,
                                const gchar *certificate_pem,
                                const gchar *certificate_errors,
                                const gchar *dbus_error_name,
                                const gchar *dbus_error_message);

Helper function used in service implementations to finish handling invocations of the GetLastCredentialsRequiredArguments() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

Since: 3.16

e_dbus_source_complete_unset_last_credentials_required_arguments ()

void
e_dbus_source_complete_unset_last_credentials_required_arguments
                               (EDBusSource *object,
                                GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the UnsetLastCredentialsRequiredArguments() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

Since: 3.18

e_dbus_source_complete_invoke_authenticate ()

void
e_dbus_source_complete_invoke_authenticate
                               (EDBusSource *object,
                                GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the InvokeAuthenticate() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

Since: 3.16

e_dbus_source_emit_credentials_required ()

void
e_dbus_source_emit_credentials_required
                               (EDBusSource *object,
                                const gchar *arg_reason,
                                const gchar *arg_certificate_pem,
                                const gchar *arg_certificate_errors,
                                const gchar *arg_dbus_error_name,
                                const gchar *arg_dbus_error_message);

Emits the "CredentialsRequired" D-Bus signal.

e_dbus_source_emit_authenticate ()

void
e_dbus_source_emit_authenticate (EDBusSource *object,
                                 const gchar *const *arg_credentials);

Emits the "Authenticate" D-Bus signal.

Since: 3.16

e_dbus_source_call_invoke_credentials_required ()

void
e_dbus_source_call_invoke_credentials_required
                               (EDBusSource *proxy,
                                const gchar *arg_reason,
                                const gchar *arg_certificate_pem,
                                const gchar *arg_certificate_errors,
                                const gchar *arg_dbus_error_name,
                                const gchar *arg_dbus_error_message,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously invokes the InvokeCredentialsRequired() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_call_invoke_credentials_required_finish() to get the result of the operation.

See e_dbus_source_call_invoke_credentials_required_sync() for the synchronous, blocking version of this method.

Since: 3.16

e_dbus_source_call_invoke_credentials_required_finish ()

gboolean
e_dbus_source_call_invoke_credentials_required_finish
                               (EDBusSource *proxy,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_call_invoke_credentials_required().

Since: 3.16

e_dbus_source_call_invoke_credentials_required_sync ()

gboolean
e_dbus_source_call_invoke_credentials_required_sync
                               (EDBusSource *proxy,
                                const gchar *arg_reason,
                                const gchar *arg_certificate_pem,
                                const gchar *arg_certificate_errors,
                                const gchar *arg_dbus_error_name,
                                const gchar *arg_dbus_error_message,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the InvokeCredentialsRequired() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_source_call_invoke_credentials_required() for the asynchronous version of this method.

Since: 3.16

e_dbus_source_call_get_last_credentials_required_arguments ()

void
e_dbus_source_call_get_last_credentials_required_arguments
                               (EDBusSource *proxy,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously invokes the GetLastCredentialsRequiredArguments() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_call_get_last_credentials_required_arguments_finish() to get the result of the operation.

See e_dbus_source_call_get_last_credentials_required_arguments_sync() for the synchronous, blocking version of this method.

Since: 3.16

e_dbus_source_call_get_last_credentials_required_arguments_finish ()

gboolean
e_dbus_source_call_get_last_credentials_required_arguments_finish
                               (EDBusSource *proxy,
                                gchar **out_reason,
                                gchar **out_certificate_pem,
                                gchar **out_certificate_errors,
                                gchar **out_dbus_error_name,
                                gchar **out_dbus_error_message,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_call_get_last_credentials_required_arguments().

Since: 3.16

e_dbus_source_call_get_last_credentials_required_arguments_sync ()

gboolean
e_dbus_source_call_get_last_credentials_required_arguments_sync
                               (EDBusSource *proxy,
                                gchar **out_reason,
                                gchar **out_certificate_pem,
                                gchar **out_certificate_errors,
                                gchar **out_dbus_error_name,
                                gchar **out_dbus_error_message,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the GetLastCredentialsRequiredArguments() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_source_call_get_last_credentials_required_arguments() for the asynchronous version of this method.

Since: 3.16

e_dbus_source_call_unset_last_credentials_required_arguments ()

void
e_dbus_source_call_unset_last_credentials_required_arguments
                               (EDBusSource *proxy,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously invokes the UnsetLastCredentialsRequiredArguments() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_call_unset_last_credentials_required_arguments_finish() to get the result of the operation.

See e_dbus_source_call_unset_last_credentials_required_arguments_sync() for the synchronous, blocking version of this method.

Since: 3.18

e_dbus_source_call_unset_last_credentials_required_arguments_finish ()

gboolean
e_dbus_source_call_unset_last_credentials_required_arguments_finish
                               (EDBusSource *proxy,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_call_unset_last_credentials_required_arguments().

Since: 3.18

e_dbus_source_call_unset_last_credentials_required_arguments_sync ()

gboolean
e_dbus_source_call_unset_last_credentials_required_arguments_sync
                               (EDBusSource *proxy,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the UnsetLastCredentialsRequiredArguments() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_source_call_unset_last_credentials_required_arguments() for the asynchronous version of this method.

Since: 3.18

e_dbus_source_call_invoke_authenticate ()

void
e_dbus_source_call_invoke_authenticate
                               (EDBusSource *proxy,
                                const gchar *const *arg_credentials,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously invokes the InvokeAuthenticate() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_call_invoke_authenticate_finish() to get the result of the operation.

See e_dbus_source_call_invoke_authenticate_sync() for the synchronous, blocking version of this method.

Since: 3.16

e_dbus_source_call_invoke_authenticate_finish ()

gboolean
e_dbus_source_call_invoke_authenticate_finish
                               (EDBusSource *proxy,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_call_invoke_authenticate().

Since: 3.16

e_dbus_source_call_invoke_authenticate_sync ()

gboolean
e_dbus_source_call_invoke_authenticate_sync
                               (EDBusSource *proxy,
                                const gchar *const *arg_credentials,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the InvokeAuthenticate() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_source_call_invoke_authenticate() for the asynchronous version of this method.

Since: 3.16

e_dbus_source_get_uid ()

const gchar *
e_dbus_source_get_uid (EDBusSource *object);

Gets the value of the "UID" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

[skip]

e_dbus_source_dup_uid ()

gchar *
e_dbus_source_dup_uid (EDBusSource *object);

Gets a copy of the "UID" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

[skip]

e_dbus_source_set_uid ()

void
e_dbus_source_set_uid (EDBusSource *object,
                       const gchar *value);

Sets the "UID" D-Bus property to value .

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

[skip]

e_dbus_source_get_data ()

const gchar *
e_dbus_source_get_data (EDBusSource *object);

Gets the value of the "Data" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

[skip]

e_dbus_source_dup_data ()

gchar *
e_dbus_source_dup_data (EDBusSource *object);

Gets a copy of the "Data" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

[skip]

e_dbus_source_set_data ()

void
e_dbus_source_set_data (EDBusSource *object,
                        const gchar *value);

Sets the "Data" D-Bus property to value .

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

[skip]

e_dbus_source_get_connection_status ()

const gchar *
e_dbus_source_get_connection_status (EDBusSource *object);

Gets the value of the "ConnectionStatus" D-Bus property.

Since this D-Bus property is both readable and writable, it is meaningful to use this function on both the client- and service-side.

[skip]

e_dbus_source_dup_connection_status ()

gchar *
e_dbus_source_dup_connection_status (EDBusSource *object);

Gets a copy of the "ConnectionStatus" D-Bus property.

Since this D-Bus property is both readable and writable, it is meaningful to use this function on both the client- and service-side.

[skip]

e_dbus_source_set_connection_status ()

void
e_dbus_source_set_connection_status (EDBusSource *object,
                                     const gchar *value);

Sets the "ConnectionStatus" D-Bus property to value .

Since this D-Bus property is both readable and writable, it is meaningful to use this function on both the client- and service-side.

[skip]

e_dbus_source_proxy_new ()

void
e_dbus_source_proxy_new (GDBusConnection *connection,
                         GDBusProxyFlags flags,
                         const gchar *name,
                         const gchar *object_path,
                         GCancellable *cancellable,
                         GAsyncReadyCallback callback,
                         gpointer user_data);

Asynchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source. See g_dbus_proxy_new() for more details.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_proxy_new_finish() to get the result of the operation.

See e_dbus_source_proxy_new_sync() for the synchronous, blocking version of this constructor.

e_dbus_source_proxy_new_finish ()

EDBusSource *
e_dbus_source_proxy_new_finish (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_proxy_new().

e_dbus_source_proxy_new_sync ()

EDBusSource *
e_dbus_source_proxy_new_sync (GDBusConnection *connection,
                              GDBusProxyFlags flags,
                              const gchar *name,
                              const gchar *object_path,
                              GCancellable *cancellable,
                              GError **error);

Synchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source. See g_dbus_proxy_new_sync() for more details.

The calling thread is blocked until a reply is received.

See e_dbus_source_proxy_new() for the asynchronous version of this constructor.

e_dbus_source_proxy_new_for_bus ()

void
e_dbus_source_proxy_new_for_bus (GBusType bus_type,
                                 GDBusProxyFlags flags,
                                 const gchar *name,
                                 const gchar *object_path,
                                 GCancellable *cancellable,
                                 GAsyncReadyCallback callback,
                                 gpointer user_data);

Like e_dbus_source_proxy_new() but takes a GBusType instead of a GDBusConnection.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_proxy_new_for_bus_finish() to get the result of the operation.

See e_dbus_source_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.

e_dbus_source_proxy_new_for_bus_finish ()

EDBusSource *
e_dbus_source_proxy_new_for_bus_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_proxy_new_for_bus().

e_dbus_source_proxy_new_for_bus_sync ()

EDBusSource *
e_dbus_source_proxy_new_for_bus_sync (GBusType bus_type,
                                      GDBusProxyFlags flags,
                                      const gchar *name,
                                      const gchar *object_path,
                                      GCancellable *cancellable,
                                      GError **error);

Like e_dbus_source_proxy_new_sync() but takes a GBusType instead of a GDBusConnection.

The calling thread is blocked until a reply is received.

See e_dbus_source_proxy_new_for_bus() for the asynchronous version of this constructor.

e_dbus_source_skeleton_new ()

EDBusSource *
e_dbus_source_skeleton_new (void);

Creates a skeleton object for the D-Bus interface org.gnome.evolution.dataserver.Source.

e_dbus_source_removable_interface_info ()

GDBusInterfaceInfo *
e_dbus_source_removable_interface_info
                               (void);

Gets a machine-readable description of the org.gnome.evolution.dataserver.Source.Removable D-Bus interface.

e_dbus_source_removable_override_properties ()

guint
e_dbus_source_removable_override_properties
                               (GObjectClass *klass,
                                guint property_id_begin);

Overrides all GObject properties in the EDBusSourceRemovable interface for a concrete class. The properties are overridden in the order they are defined.

e_dbus_source_removable_complete_remove ()

void
e_dbus_source_removable_complete_remove
                               (EDBusSourceRemovable *object,
                                GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the Remove() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

e_dbus_source_removable_call_remove ()

void
e_dbus_source_removable_call_remove (EDBusSourceRemovable *proxy,
                                     GCancellable *cancellable,
                                     GAsyncReadyCallback callback,
                                     gpointer user_data);

Asynchronously invokes the Remove() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_removable_call_remove_finish() to get the result of the operation.

See e_dbus_source_removable_call_remove_sync() for the synchronous, blocking version of this method.

e_dbus_source_removable_call_remove_finish ()

gboolean
e_dbus_source_removable_call_remove_finish
                               (EDBusSourceRemovable *proxy,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_removable_call_remove().

e_dbus_source_removable_call_remove_sync ()

gboolean
e_dbus_source_removable_call_remove_sync
                               (EDBusSourceRemovable *proxy,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the Remove() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_source_removable_call_remove() for the asynchronous version of this method.

e_dbus_source_removable_proxy_new ()

void
e_dbus_source_removable_proxy_new (GDBusConnection *connection,
                                   GDBusProxyFlags flags,
                                   const gchar *name,
                                   const gchar *object_path,
                                   GCancellable *cancellable,
                                   GAsyncReadyCallback callback,
                                   gpointer user_data);

Asynchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source.Removable. See g_dbus_proxy_new() for more details.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_removable_proxy_new_finish() to get the result of the operation.

See e_dbus_source_removable_proxy_new_sync() for the synchronous, blocking version of this constructor.

e_dbus_source_removable_proxy_new_finish ()

EDBusSourceRemovable *
e_dbus_source_removable_proxy_new_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_removable_proxy_new().

e_dbus_source_removable_proxy_new_sync ()

EDBusSourceRemovable *
e_dbus_source_removable_proxy_new_sync
                               (GDBusConnection *connection,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Synchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source.Removable. See g_dbus_proxy_new_sync() for more details.

The calling thread is blocked until a reply is received.

See e_dbus_source_removable_proxy_new() for the asynchronous version of this constructor.

e_dbus_source_removable_proxy_new_for_bus ()

void
e_dbus_source_removable_proxy_new_for_bus
                               (GBusType bus_type,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Like e_dbus_source_removable_proxy_new() but takes a GBusType instead of a GDBusConnection.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_removable_proxy_new_for_bus_finish() to get the result of the operation.

See e_dbus_source_removable_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.

e_dbus_source_removable_proxy_new_for_bus_finish ()

EDBusSourceRemovable *
e_dbus_source_removable_proxy_new_for_bus_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_removable_proxy_new_for_bus().

e_dbus_source_removable_proxy_new_for_bus_sync ()

EDBusSourceRemovable *
e_dbus_source_removable_proxy_new_for_bus_sync
                               (GBusType bus_type,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Like e_dbus_source_removable_proxy_new_sync() but takes a GBusType instead of a GDBusConnection.

The calling thread is blocked until a reply is received.

See e_dbus_source_removable_proxy_new_for_bus() for the asynchronous version of this constructor.

e_dbus_source_removable_skeleton_new ()

EDBusSourceRemovable *
e_dbus_source_removable_skeleton_new (void);

Creates a skeleton object for the D-Bus interface org.gnome.evolution.dataserver.Source.Removable.

e_dbus_source_writable_interface_info ()

GDBusInterfaceInfo *
e_dbus_source_writable_interface_info (void);

Gets a machine-readable description of the org.gnome.evolution.dataserver.Source.Writable D-Bus interface.

e_dbus_source_writable_override_properties ()

guint
e_dbus_source_writable_override_properties
                               (GObjectClass *klass,
                                guint property_id_begin);

Overrides all GObject properties in the EDBusSourceWritable interface for a concrete class. The properties are overridden in the order they are defined.

e_dbus_source_writable_complete_write ()

void
e_dbus_source_writable_complete_write (EDBusSourceWritable *object,
                                       GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the Write() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

e_dbus_source_writable_call_write ()

void
e_dbus_source_writable_call_write (EDBusSourceWritable *proxy,
                                   const gchar *arg_data,
                                   GCancellable *cancellable,
                                   GAsyncReadyCallback callback,
                                   gpointer user_data);

Asynchronously invokes the Write() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_writable_call_write_finish() to get the result of the operation.

See e_dbus_source_writable_call_write_sync() for the synchronous, blocking version of this method.

e_dbus_source_writable_call_write_finish ()

gboolean
e_dbus_source_writable_call_write_finish
                               (EDBusSourceWritable *proxy,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_writable_call_write().

e_dbus_source_writable_call_write_sync ()

gboolean
e_dbus_source_writable_call_write_sync
                               (EDBusSourceWritable *proxy,
                                const gchar *arg_data,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the Write() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_source_writable_call_write() for the asynchronous version of this method.

e_dbus_source_writable_proxy_new ()

void
e_dbus_source_writable_proxy_new (GDBusConnection *connection,
                                  GDBusProxyFlags flags,
                                  const gchar *name,
                                  const gchar *object_path,
                                  GCancellable *cancellable,
                                  GAsyncReadyCallback callback,
                                  gpointer user_data);

Asynchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source.Writable. See g_dbus_proxy_new() for more details.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_writable_proxy_new_finish() to get the result of the operation.

See e_dbus_source_writable_proxy_new_sync() for the synchronous, blocking version of this constructor.

e_dbus_source_writable_proxy_new_finish ()

EDBusSourceWritable *
e_dbus_source_writable_proxy_new_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_writable_proxy_new().

e_dbus_source_writable_proxy_new_sync ()

EDBusSourceWritable *
e_dbus_source_writable_proxy_new_sync (GDBusConnection *connection,
                                       GDBusProxyFlags flags,
                                       const gchar *name,
                                       const gchar *object_path,
                                       GCancellable *cancellable,
                                       GError **error);

Synchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source.Writable. See g_dbus_proxy_new_sync() for more details.

The calling thread is blocked until a reply is received.

See e_dbus_source_writable_proxy_new() for the asynchronous version of this constructor.

e_dbus_source_writable_proxy_new_for_bus ()

void
e_dbus_source_writable_proxy_new_for_bus
                               (GBusType bus_type,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Like e_dbus_source_writable_proxy_new() but takes a GBusType instead of a GDBusConnection.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_writable_proxy_new_for_bus_finish() to get the result of the operation.

See e_dbus_source_writable_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.

e_dbus_source_writable_proxy_new_for_bus_finish ()

EDBusSourceWritable *
e_dbus_source_writable_proxy_new_for_bus_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_writable_proxy_new_for_bus().

e_dbus_source_writable_proxy_new_for_bus_sync ()

EDBusSourceWritable *
e_dbus_source_writable_proxy_new_for_bus_sync
                               (GBusType bus_type,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Like e_dbus_source_writable_proxy_new_sync() but takes a GBusType instead of a GDBusConnection.

The calling thread is blocked until a reply is received.

See e_dbus_source_writable_proxy_new_for_bus() for the asynchronous version of this constructor.

e_dbus_source_writable_skeleton_new ()

EDBusSourceWritable *
e_dbus_source_writable_skeleton_new (void);

Creates a skeleton object for the D-Bus interface org.gnome.evolution.dataserver.Source.Writable.

e_dbus_source_remote_creatable_interface_info ()

GDBusInterfaceInfo *
e_dbus_source_remote_creatable_interface_info
                               (void);

Gets a machine-readable description of the org.gnome.evolution.dataserver.Source.RemoteCreatable D-Bus interface.

e_dbus_source_remote_creatable_override_properties ()

guint
e_dbus_source_remote_creatable_override_properties
                               (GObjectClass *klass,
                                guint property_id_begin);

Overrides all GObject properties in the EDBusSourceRemoteCreatable interface for a concrete class. The properties are overridden in the order they are defined.

e_dbus_source_remote_creatable_complete_create ()

void
e_dbus_source_remote_creatable_complete_create
                               (EDBusSourceRemoteCreatable *object,
                                GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the Create() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

e_dbus_source_remote_creatable_call_create ()

void
e_dbus_source_remote_creatable_call_create
                               (EDBusSourceRemoteCreatable *proxy,
                                const gchar *arg_uid,
                                const gchar *arg_data,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously invokes the Create() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_remote_creatable_call_create_finish() to get the result of the operation.

See e_dbus_source_remote_creatable_call_create_sync() for the synchronous, blocking version of this method.

e_dbus_source_remote_creatable_call_create_finish ()

gboolean
e_dbus_source_remote_creatable_call_create_finish
                               (EDBusSourceRemoteCreatable *proxy,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_remote_creatable_call_create().

e_dbus_source_remote_creatable_call_create_sync ()

gboolean
e_dbus_source_remote_creatable_call_create_sync
                               (EDBusSourceRemoteCreatable *proxy,
                                const gchar *arg_uid,
                                const gchar *arg_data,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the Create() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_source_remote_creatable_call_create() for the asynchronous version of this method.

e_dbus_source_remote_creatable_proxy_new ()

void
e_dbus_source_remote_creatable_proxy_new
                               (GDBusConnection *connection,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source.RemoteCreatable. See g_dbus_proxy_new() for more details.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_remote_creatable_proxy_new_finish() to get the result of the operation.

See e_dbus_source_remote_creatable_proxy_new_sync() for the synchronous, blocking version of this constructor.

e_dbus_source_remote_creatable_proxy_new_finish ()

EDBusSourceRemoteCreatable *
e_dbus_source_remote_creatable_proxy_new_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_remote_creatable_proxy_new().

e_dbus_source_remote_creatable_proxy_new_sync ()

EDBusSourceRemoteCreatable *
e_dbus_source_remote_creatable_proxy_new_sync
                               (GDBusConnection *connection,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Synchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source.RemoteCreatable. See g_dbus_proxy_new_sync() for more details.

The calling thread is blocked until a reply is received.

See e_dbus_source_remote_creatable_proxy_new() for the asynchronous version of this constructor.

e_dbus_source_remote_creatable_proxy_new_for_bus ()

void
e_dbus_source_remote_creatable_proxy_new_for_bus
                               (GBusType bus_type,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Like e_dbus_source_remote_creatable_proxy_new() but takes a GBusType instead of a GDBusConnection.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_remote_creatable_proxy_new_for_bus_finish() to get the result of the operation.

See e_dbus_source_remote_creatable_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.

e_dbus_source_remote_creatable_proxy_new_for_bus_finish ()

EDBusSourceRemoteCreatable *
e_dbus_source_remote_creatable_proxy_new_for_bus_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_remote_creatable_proxy_new_for_bus().

e_dbus_source_remote_creatable_proxy_new_for_bus_sync ()

EDBusSourceRemoteCreatable *
e_dbus_source_remote_creatable_proxy_new_for_bus_sync
                               (GBusType bus_type,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Like e_dbus_source_remote_creatable_proxy_new_sync() but takes a GBusType instead of a GDBusConnection.

The calling thread is blocked until a reply is received.

See e_dbus_source_remote_creatable_proxy_new_for_bus() for the asynchronous version of this constructor.

e_dbus_source_remote_creatable_skeleton_new ()

EDBusSourceRemoteCreatable *
e_dbus_source_remote_creatable_skeleton_new
                               (void);

Creates a skeleton object for the D-Bus interface org.gnome.evolution.dataserver.Source.RemoteCreatable.

e_dbus_source_remote_deletable_interface_info ()

GDBusInterfaceInfo *
e_dbus_source_remote_deletable_interface_info
                               (void);

Gets a machine-readable description of the org.gnome.evolution.dataserver.Source.RemoteDeletable D-Bus interface.

e_dbus_source_remote_deletable_override_properties ()

guint
e_dbus_source_remote_deletable_override_properties
                               (GObjectClass *klass,
                                guint property_id_begin);

Overrides all GObject properties in the EDBusSourceRemoteDeletable interface for a concrete class. The properties are overridden in the order they are defined.

e_dbus_source_remote_deletable_complete_delete ()

void
e_dbus_source_remote_deletable_complete_delete
                               (EDBusSourceRemoteDeletable *object,
                                GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the Delete() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

e_dbus_source_remote_deletable_call_delete ()

void
e_dbus_source_remote_deletable_call_delete
                               (EDBusSourceRemoteDeletable *proxy,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously invokes the Delete() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_remote_deletable_call_delete_finish() to get the result of the operation.

See e_dbus_source_remote_deletable_call_delete_sync() for the synchronous, blocking version of this method.

e_dbus_source_remote_deletable_call_delete_finish ()

gboolean
e_dbus_source_remote_deletable_call_delete_finish
                               (EDBusSourceRemoteDeletable *proxy,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_remote_deletable_call_delete().

e_dbus_source_remote_deletable_call_delete_sync ()

gboolean
e_dbus_source_remote_deletable_call_delete_sync
                               (EDBusSourceRemoteDeletable *proxy,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the Delete() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_source_remote_deletable_call_delete() for the asynchronous version of this method.

e_dbus_source_remote_deletable_proxy_new ()

void
e_dbus_source_remote_deletable_proxy_new
                               (GDBusConnection *connection,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source.RemoteDeletable. See g_dbus_proxy_new() for more details.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_remote_deletable_proxy_new_finish() to get the result of the operation.

See e_dbus_source_remote_deletable_proxy_new_sync() for the synchronous, blocking version of this constructor.

e_dbus_source_remote_deletable_proxy_new_finish ()

EDBusSourceRemoteDeletable *
e_dbus_source_remote_deletable_proxy_new_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_source_remote_deletable_proxy_new().

e_dbus_source_remote_deletable_proxy_new_sync ()

EDBusSourceRemoteDeletable *
e_dbus_source_remote_deletable_proxy_new_sync
                               (GDBusConnection *connection,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Synchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Source.RemoteDeletable. See g_dbus_proxy_new_sync() for more details.

The calling thread is blocked until a reply is received.

See e_dbus_source_remote_deletable_proxy_new() for the asynchronous version of this constructor.

e_dbus_source_remote_deletable_proxy_new_for_bus ()

void
e_dbus_source_remote_deletable_proxy_new_for_bus
                               (GBusType bus_type,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Like e_dbus_source_remote_deletable_proxy_new() but takes a GBusType instead of a GDBusConnection.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_source_remote_deletable_proxy_new_for_bus_finish() to get the result of the operation.