EClient

EClient

Synopsis

#define             E_CLIENT_ERROR
enum                EClientError;
const gchar *       e_client_error_to_string            (EClientError code);
GError *            e_client_error_create               (EClientError code,
                                                         const gchar *custom_msg);
#define             CLIENT_BACKEND_PROPERTY_OPENED
#define             CLIENT_BACKEND_PROPERTY_OPENING
#define             CLIENT_BACKEND_PROPERTY_ONLINE
#define             CLIENT_BACKEND_PROPERTY_READONLY
#define             CLIENT_BACKEND_PROPERTY_CACHE_DIR
#define             CLIENT_BACKEND_PROPERTY_CAPABILITIES
#define             CLIENT_BACKEND_PROPERTY_REVISION
struct              EClient;
ESource *           e_client_get_source                 (EClient *client);
const GSList *      e_client_get_capabilities           (EClient *client);
gboolean            e_client_check_capability           (EClient *client,
                                                         const gchar *capability);
gboolean            e_client_check_refresh_supported    (EClient *client);
gboolean            e_client_is_readonly                (EClient *client);
gboolean            e_client_is_online                  (EClient *client);
gboolean            e_client_is_opened                  (EClient *client);
void                e_client_unwrap_dbus_error          (EClient *client,
                                                         GError *dbus_error,
                                                         GError **out_error);
void                e_client_cancel_all                 (EClient *client);
void                e_client_get_backend_property       (EClient *client,
                                                         const gchar *prop_name,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_client_get_backend_property_finish
                                                        (EClient *client,
                                                         GAsyncResult *result,
                                                         gchar **prop_value,
                                                         GError **error);
gboolean            e_client_get_backend_property_sync  (EClient *client,
                                                         const gchar *prop_name,
                                                         gchar **prop_value,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_client_set_backend_property       (EClient *client,
                                                         const gchar *prop_name,
                                                         const gchar *prop_value,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_client_set_backend_property_finish
                                                        (EClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_client_set_backend_property_sync  (EClient *client,
                                                         const gchar *prop_name,
                                                         const gchar *prop_value,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_client_open                       (EClient *client,
                                                         gboolean only_if_exists,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_client_open_finish                (EClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_client_open_sync                  (EClient *client,
                                                         gboolean only_if_exists,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_client_refresh                    (EClient *client,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_client_refresh_finish             (EClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_client_refresh_sync               (EClient *client,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                e_client_retrieve_capabilities      (EClient *client,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_client_retrieve_capabilities_finish
                                                        (EClient *client,
                                                         GAsyncResult *result,
                                                         gchar **capabilities,
                                                         GError **error);
gboolean            e_client_retrieve_capabilities_sync (EClient *client,
                                                         gchar **capabilities,
                                                         GCancellable *cancellable,
                                                         GError **error);
gchar **            e_client_util_slist_to_strv         (const GSList *strings);
GSList *            e_client_util_strv_to_slist         (const gchar * const *strv);
GSList *            e_client_util_copy_string_slist     (GSList *copy_to,
                                                         const GSList *strings);
GSList *            e_client_util_copy_object_slist     (GSList *copy_to,
                                                         const GSList *objects);
void                e_client_util_free_string_slist     (GSList *strings);
void                e_client_util_free_object_slist     (GSList *objects);
GSList *            e_client_util_parse_comma_strings   (const gchar *strings);
struct              EClientErrorsList;
gboolean            e_client_util_unwrap_dbus_error     (GError *dbus_error,
                                                         GError **client_error,
                                                         const EClientErrorsList *known_errors,
                                                         guint known_errors_count,
                                                         GQuark known_errors_domain,
                                                         gboolean fail_when_none_matched);
void                e_client_remove                     (EClient *client,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            e_client_remove_finish              (EClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            e_client_remove_sync                (EClient *client,
                                                         GCancellable *cancellable,
                                                         GError **error);

Object Hierarchy

  GObject
   +----EClient

Properties

  "capabilities"             gpointer              : Read
  "online"                   gboolean              : Read / Write
  "opened"                   gboolean              : Read
  "readonly"                 gboolean              : Read
  "source"                   ESource*              : Read / Write / Construct Only

Signals

  "backend-died"                                   : Run Last
  "backend-error"                                  : Run First
  "backend-property-changed"                       : Run Last
  "opened"                                         : Run Last

Description

Details

E_CLIENT_ERROR

#define E_CLIENT_ERROR		e_client_error_quark ()

Error domain for EClient operations. Errors in this domain will be from the EClientError enumeration. See GError for more information on error domains.

Since 3.2


enum EClientError

typedef enum {
	E_CLIENT_ERROR_INVALID_ARG,
	E_CLIENT_ERROR_BUSY,
	E_CLIENT_ERROR_SOURCE_NOT_LOADED,
	E_CLIENT_ERROR_SOURCE_ALREADY_LOADED,
	E_CLIENT_ERROR_AUTHENTICATION_FAILED,
	E_CLIENT_ERROR_AUTHENTICATION_REQUIRED,
	E_CLIENT_ERROR_REPOSITORY_OFFLINE,
	E_CLIENT_ERROR_OFFLINE_UNAVAILABLE,
	E_CLIENT_ERROR_PERMISSION_DENIED,
	E_CLIENT_ERROR_CANCELLED,
	E_CLIENT_ERROR_COULD_NOT_CANCEL,
	E_CLIENT_ERROR_NOT_SUPPORTED,
	E_CLIENT_ERROR_TLS_NOT_AVAILABLE,
	E_CLIENT_ERROR_UNSUPPORTED_AUTHENTICATION_METHOD,
	E_CLIENT_ERROR_SEARCH_SIZE_LIMIT_EXCEEDED,
	E_CLIENT_ERROR_SEARCH_TIME_LIMIT_EXCEEDED,
	E_CLIENT_ERROR_INVALID_QUERY,
	E_CLIENT_ERROR_QUERY_REFUSED,
	E_CLIENT_ERROR_DBUS_ERROR,
	E_CLIENT_ERROR_OTHER_ERROR,
	E_CLIENT_ERROR_NOT_OPENED
} EClientError;

FIXME Document each code.

Error codes for EClient operations.

Since 3.2


e_client_error_to_string ()

const gchar *       e_client_error_to_string            (EClientError code);

FIXME: Document me.

Since 3.2


e_client_error_create ()

GError *            e_client_error_create               (EClientError code,
                                                         const gchar *custom_msg);

code :

an EClientError code to create

custom_msg :

custom message to use for the error; can be NULL

Returns :

a new GError containing an E_CLIENT_ERROR of the given code. If the custom_msg is NULL, then the error message is the one returned from e_client_error_to_string() for the code, otherwise the given message is used. Returned pointer should be freed with g_error_free().

Since 3.2


CLIENT_BACKEND_PROPERTY_OPENED

#define CLIENT_BACKEND_PROPERTY_OPENED			"opened"

The "opened" property is "TRUE" when the client is fully opened, "FALSE" at all other times.

Since 3.2


CLIENT_BACKEND_PROPERTY_OPENING

#define CLIENT_BACKEND_PROPERTY_OPENING			"opening"

The "opening" property is "TRUE" when the client is in the process of opening, "FALSE" at all other times.

Since 3.2


CLIENT_BACKEND_PROPERTY_ONLINE

#define CLIENT_BACKEND_PROPERTY_ONLINE			"online"

The "online" property is "TRUE" when the client is fully opened and online, "FALSE" at all other times. See also e_client_is_online().

Since 3.2


CLIENT_BACKEND_PROPERTY_READONLY

#define CLIENT_BACKEND_PROPERTY_READONLY		"readonly"

The "online" property is "TRUE" if the backend has only read access to its data, "FALSE" if the backend can modify its data. See also e_client_is_readonly().

Since 3.2


CLIENT_BACKEND_PROPERTY_CACHE_DIR

#define CLIENT_BACKEND_PROPERTY_CACHE_DIR		"cache-dir"

The "cache-dir" property indicates the backend's local directory for cached data.

Since 3.2


CLIENT_BACKEND_PROPERTY_CAPABILITIES

#define CLIENT_BACKEND_PROPERTY_CAPABILITIES		"capabilities"

The "capabilities" property is a comma-separated list of capabilities supported by the backend. The preferred method of retrieving and working with capabilities is e_client_get_capabilities() and e_client_check_capability().

Since 3.2


CLIENT_BACKEND_PROPERTY_REVISION

#define CLIENT_BACKEND_PROPERTY_REVISION		"revision"

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

Since 3.4


struct EClient

struct EClient;

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

Since 3.2


e_client_get_source ()

ESource *           e_client_get_source                 (EClient *client);

Get the ESource that this client has assigned.

client :

an EClient

Returns :

The source. [transfer none]

Since 3.2


e_client_get_capabilities ()

const GSList *      e_client_get_capabilities           (EClient *client);

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().

client :

an EClient

Returns :

GSList of const strings of capabilities. [element-type utf8][transfer none]

Since 3.2


e_client_check_capability ()

gboolean            e_client_check_capability           (EClient *client,
                                                         const gchar *capability);

Check if backend supports particular capability. To get all capabilities use e_client_get_capabilities().

client :

an EClient

capability :

a capability

Returns :

GSList of const strings of capabilities

Since 3.2


e_client_check_refresh_supported ()

gboolean            e_client_check_refresh_supported    (EClient *client);

Checks whether a client supports explicit refreshing (see e_client_refresh()).

client :

A client.

Returns :

TRUE if the client supports refreshing, FALSE otherwise.

Since 3.2


e_client_is_readonly ()

gboolean            e_client_is_readonly                (EClient *client);

Check if this client is read-only.

client :

an EClient

Returns :

TRUE if this client is read-only, otherwise FALSE.

Since 3.2


e_client_is_online ()

gboolean            e_client_is_online                  (EClient *client);

Check if this client is connected.

client :

an EClient

Returns :

TRUE if this client is connected, otherwise FALSE.

Since 3.2


e_client_is_opened ()

gboolean            e_client_is_opened                  (EClient *client);

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.

client :

an EClient

Returns :

TRUE if this client is fully opened, otherwise FALSE.

Since 3.2.


e_client_unwrap_dbus_error ()

void                e_client_unwrap_dbus_error          (EClient *client,
                                                         GError *dbus_error,
                                                         GError **out_error);

Unwraps D-Bus error to local error. dbus_error is automatically freed. dbus_erorr and out_error can point to the same variable.

client :

an EClient

dbus_error :

a GError returned bu D-Bus

out_error :

a GError variable where to store the result

Since 3.2


e_client_cancel_all ()

void                e_client_cancel_all                 (EClient *client);

Cancels all pending operations started on client.

client :

an EClient

Since 3.2


e_client_get_backend_property ()

void                e_client_get_backend_property       (EClient *client,
                                                         const gchar *prop_name,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

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.

client :

an EClient

prop_name :

property name, whose value to retrieve; cannot be NULL

cancellable :

a GCancellable; can be NULL

callback :

callback to call when a result is ready

user_data :

user data for the callback

Since 3.2


e_client_get_backend_property_finish ()

gboolean            e_client_get_backend_property_finish
                                                        (EClient *client,
                                                         GAsyncResult *result,
                                                         gchar **prop_value,
                                                         GError **error);

Finishes previous call of e_client_get_backend_property().

client :

an EClient

result :

a GAsyncResult

prop_value :

Retrieved backend property value; cannot be NULL. [out]

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_get_backend_property_sync ()

gboolean            e_client_get_backend_property_sync  (EClient *client,
                                                         const gchar *prop_name,
                                                         gchar **prop_value,
                                                         GCancellable *cancellable,
                                                         GError **error);

Queries client's backend for a property of name prop_name.

client :

an EClient

prop_name :

property name, whose value to retrieve; cannot be NULL

prop_value :

Retrieved backend property value; cannot be NULL. [out]

cancellable :

a GCancellable; can be NULL

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_set_backend_property ()

void                e_client_set_backend_property       (EClient *client,
                                                         const gchar *prop_name,
                                                         const gchar *prop_value,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

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.

client :

an EClient

prop_name :

property name, whose value to change; cannot be NULL

prop_value :

property value, to set; cannot be NULL

cancellable :

a GCancellable; can be NULL

callback :

callback to call when a result is ready

user_data :

user data for the callback

Since 3.2


e_client_set_backend_property_finish ()

gboolean            e_client_set_backend_property_finish
                                                        (EClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes previous call of e_client_set_backend_property().

client :

an EClient

result :

a GAsyncResult

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_set_backend_property_sync ()

gboolean            e_client_set_backend_property_sync  (EClient *client,
                                                         const gchar *prop_name,
                                                         const gchar *prop_value,
                                                         GCancellable *cancellable,
                                                         GError **error);

Sets client's backend property of name prop_name to value prop_value.

client :

an EClient

prop_name :

property name, whose value to change; cannot be NULL

prop_value :

property value, to set; cannot be NULL

cancellable :

a GCancellable; can be NULL

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_open ()

void                e_client_open                       (EClient *client,
                                                         gboolean only_if_exists,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Opens the client, making it ready for queries and other operations. The call is finished by e_client_open_finish() from the callback.

client :

an EClient

only_if_exists :

if TRUE, fail if this book doesn't already exist, otherwise create it first

cancellable :

a GCancellable; can be NULL

callback :

callback to call when a result is ready

user_data :

user data for the callback

Since 3.2


e_client_open_finish ()

gboolean            e_client_open_finish                (EClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes previous call of e_client_open().

client :

an EClient

result :

a GAsyncResult

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_open_sync ()

gboolean            e_client_open_sync                  (EClient *client,
                                                         gboolean only_if_exists,
                                                         GCancellable *cancellable,
                                                         GError **error);

Opens the client, making it ready for queries and other operations.

client :

an EClient

only_if_exists :

if TRUE, fail if this book doesn't already exist, otherwise create it first

cancellable :

a GCancellable; can be NULL

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_refresh ()

void                e_client_refresh                    (EClient *client,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

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.

client :

an EClient

cancellable :

a GCancellable; can be NULL

callback :

callback to call when a result is ready

user_data :

user data for the callback

Since 3.2


e_client_refresh_finish ()

gboolean            e_client_refresh_finish             (EClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Finishes previous call of e_client_refresh().

client :

an EClient

result :

a GAsyncResult

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_refresh_sync ()

gboolean            e_client_refresh_sync               (EClient *client,
                                                         GCancellable *cancellable,
                                                         GError **error);

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.

client :

an EClient

cancellable :

a GCancellable; can be NULL

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_retrieve_capabilities ()

void                e_client_retrieve_capabilities      (EClient *client,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

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.

client :

an EClient

cancellable :

a GCancellable; can be NULL

callback :

callback to call when a result is ready

user_data :

user data for the callback

Since 3.2


e_client_retrieve_capabilities_finish ()

gboolean            e_client_retrieve_capabilities_finish
                                                        (EClient *client,
                                                         GAsyncResult *result,
                                                         gchar **capabilities,
                                                         GError **error);

Finishes previous call of e_client_retrieve_capabilities(). Returned value of capabilities should be freed with g_free(), when no longer needed.

client :

an EClient

result :

a GAsyncResult

capabilities :

Comma-separated list of capabilities of the client. [out]

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_retrieve_capabilities_sync ()

gboolean            e_client_retrieve_capabilities_sync (EClient *client,
                                                         gchar **capabilities,
                                                         GCancellable *cancellable,
                                                         GError **error);

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.

client :

an EClient

capabilities :

Comma-separated list of capabilities of the client. [out]

cancellable :

a GCancellable; can be NULL

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_util_slist_to_strv ()

gchar **            e_client_util_slist_to_strv         (const GSList *strings);

Convert a list of strings into a NULL-terminated array of strings.

strings :

a GSList of strings (const gchar *). [element-type utf8]

Returns :

Newly allocated NULL-terminated array of strings. The returned pointer should be freed with g_strfreev(). Note: Paired function for this is e_client_util_strv_to_slist(). [transfer full]

Since 3.2


e_client_util_strv_to_slist ()

GSList *            e_client_util_strv_to_slist         (const gchar * const *strv);

Convert a NULL-terminated array of strings to a list of strings.

strv :

a NULL-terminated array of strings (const gchar *)

Returns :

Newly allocated GSList of newly allocated strings. The returned pointer should be freed with e_client_util_free_string_slist(). Note: Paired function for this is e_client_util_slist_to_strv(). [transfer full][element-type utf8]

Since 3.2


e_client_util_copy_string_slist ()

GSList *            e_client_util_copy_string_slist     (GSList *copy_to,
                                                         const GSList *strings);

Copies the GSList of strings to the end of copy_to.

copy_to :

Where to copy; may be NULL. [element-type utf8][allow-none]

strings :

GSList of strings to be copied. [element-type utf8]

Returns :

New head of copy_to. The returned pointer can be freed with e_client_util_free_string_slist(). [transfer full][element-type utf8]

Since 3.2


e_client_util_copy_object_slist ()

GSList *            e_client_util_copy_object_slist     (GSList *copy_to,
                                                         const GSList *objects);

Copies a GSList of GObject<!-- -->s to the end of copy_to.

copy_to :

Where to copy; may be NULL. [element-type GObject][allow-none]

objects :

GSList of GObject<!-- -->s to be copied. [element-type GObject]

Returns :

New head of copy_to. The returned pointer can be freed with e_client_util_free_object_slist(). [transfer full][element-type GObject]

Since 3.2


e_client_util_free_string_slist ()

void                e_client_util_free_string_slist     (GSList *strings);

Frees memory previously allocated by e_client_util_strv_to_slist().

strings :

a GSList of strings (gchar *). [element-type utf8]

Since 3.2


e_client_util_free_object_slist ()

void                e_client_util_free_object_slist     (GSList *objects);

Calls g_object_unref() on each member of objects and then frees objects itself.

objects :

a GSList of GObject<!-- -->s. [element-type GObject]

Since 3.2


e_client_util_parse_comma_strings ()

GSList *            e_client_util_parse_comma_strings   (const gchar *strings);

Parses comma-separated list of values into GSList.

strings :

string of comma-separated values

Returns :

Newly allocated GSList of newly allocated strings corresponding to values parsed from strings. Free the returned pointer with e_client_util_free_string_slist(). [transfer full][element-type utf8]

Since 3.2


struct EClientErrorsList

struct EClientErrorsList {
	const gchar *name;
	gint err_code;
};

Since 3.2


e_client_util_unwrap_dbus_error ()

gboolean            e_client_util_unwrap_dbus_error     (GError *dbus_error,
                                                         GError **client_error,
                                                         const EClientErrorsList *known_errors,
                                                         guint known_errors_count,
                                                         GQuark known_errors_domain,
                                                         gboolean fail_when_none_matched);

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_error :

DBus GError to unwrap

client_error :

Resulting GError; can be NULL. [out]

known_errors :

List of known errors against which try to match

known_errors_count :

How many items are stored in known_errors

known_errors_domain :

Error domain for known_errors

fail_when_none_matched :

Whether to fail when none of known_errors matches

Returns :

Whether was dbus_error processed into client_error. Note: The dbus_error is automatically freed if returned TRUE.

Since 3.2


e_client_remove ()

void                e_client_remove                     (EClient *client,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Warning

e_client_remove has been deprecated since version 3.6 and should not be used in newly-written code. Use e_source_remove() instead.

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.

client :

an EClient

cancellable :

a GCancellable; can be NULL

callback :

callback to call when a result is ready

user_data :

user data for the callback

Since 3.2


e_client_remove_finish ()

gboolean            e_client_remove_finish              (EClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Warning

e_client_remove_finish has been deprecated since version 3.6 and should not be used in newly-written code. Use e_source_remove_finish() instead.

Finishes previous call of e_client_remove().

client :

an EClient

result :

a GAsyncResult

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2


e_client_remove_sync ()

gboolean            e_client_remove_sync                (EClient *client,
                                                         GCancellable *cancellable,
                                                         GError **error);

Warning

e_client_remove_sync has been deprecated since version 3.6 and should not be used in newly-written code. Use e_source_remove_sync() instead.

Removes the backing data for this EClient. For example, with the file backend this deletes the database file. You cannot get it back!

client :

an EClient

cancellable :

a GCancellable; can be NULL

error :

a GError to set an error, if any. [out]

Returns :

TRUE if successful, FALSE otherwise.

Since 3.2

Property Details

The "capabilities" property

  "capabilities"             gpointer              : Read


The "online" property

  "online"                   gboolean              : Read / Write

Default value: FALSE


The "opened" property

  "opened"                   gboolean              : Read

Default value: FALSE


The "readonly" property

  "readonly"                 gboolean              : Read

Default value: FALSE


The "source" property

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

Signal Details

The "backend-died" signal

void                user_function                      (EClient *eclient,
                                                        gpointer user_data)      : Run Last

The "backend-error" signal

void                user_function                      (EClient *eclient,
                                                        gchar   *arg1,
                                                        gpointer user_data)      : Run First

The "backend-property-changed" signal

void                user_function                      (EClient *eclient,
                                                        gchar   *arg1,
                                                        gchar   *arg2,
                                                        gpointer user_data)      : Run Last

The "opened" signal

void                user_function                      (EClient *eclient,
                                                        GError  *arg1,
                                                        gpointer user_data)      : Run Last