e_get_user_cache_dir ()

const gchar *
e_get_user_cache_dir (void);

Returns a base directory in which to store user-specific, non-essential cached data for Evolution or Evolution-Data-Server.

The returned string is owned by libedataserver and must not be modified or freed.

Since: 2.32

e_get_user_config_dir ()

const gchar *
e_get_user_config_dir (void);

Returns a base directory in which to store user-specific configuration information for Evolution or Evolution-Data-Server.

The returned string is owned by libedataserver and must not be modified or freed.

Since: 2.32

e_get_user_data_dir ()

const gchar *
e_get_user_data_dir (void);

Returns a base directory in which to store user-specific data for Evolution or Evolution-Data-Server.

The returned string is owned by libedataserver and must not be modified or freed.

Since: 2.32

e_util_strv_equal ()

gboolean
e_util_strv_equal (gconstpointer v1,
                   gconstpointer v2);

Compares v1 and v2 for equality, handling NULL gracefully.

The arguments types are generic for compatibility with GEqualFunc.

Since: 3.12

e_util_strdup_strip ()

gchar *
e_util_strdup_strip (const gchar *string);

Duplicates string and strips off any leading or trailing whitespace. The resulting string is returned unless it is empty or NULL, in which case the function returns NULL.

Free the returned string with g_free().

Since: 3.6

e_util_strstrcase ()

gchar *
e_util_strstrcase (const gchar *haystack,
                   const gchar *needle);

Find the first instance of needle in haystack , ignoring case for bytes that are ASCII characters.

e_util_unicode_get_utf8 ()

gchar *
e_util_unicode_get_utf8 (const gchar *text,
                         gunichar *out);

Get a UTF-8 character from the beginning of text .

e_util_utf8_strstrcase ()

const gchar *
e_util_utf8_strstrcase (const gchar *haystack,
                        const gchar *needle);

Find the first instance of needle in haystack , ignoring case. (No proper case folding or decomposing is done.) Both needle and haystack are UTF-8 strings.

e_util_utf8_strstrcasedecomp ()

const gchar *
e_util_utf8_strstrcasedecomp (const gchar *haystack,
                              const gchar *needle);

Find the first instance of needle in haystack , where both needle and haystack are UTF-8 strings. Both strings are stripped and decomposed for comparison, and case is ignored.

e_util_utf8_strcasecmp ()

gint
e_util_utf8_strcasecmp (const gchar *s1,
                        const gchar *s2);

Compares two UTF-8 strings using approximate case-insensitive ordering.

e_util_utf8_remove_accents ()

gchar *
e_util_utf8_remove_accents (const gchar *str);

Returns a newly-allocated copy of str with accents removed.

Since: 2.28

e_util_utf8_make_valid ()

gchar *
e_util_utf8_make_valid (const gchar *str);

Returns a newly-allocated copy of str , with invalid characters replaced by Unicode replacement characters (U+FFFD). For NULL str returns newly allocated empty string ("").

Since: 3.0

e_util_utf8_data_make_valid ()

gchar *
e_util_utf8_data_make_valid (const gchar *data,
                             gsize data_bytes);

Returns a newly-allocated NULL-terminated string with invalid characters replaced by Unicode replacement characters (U+FFFD). For NULL data returns newly allocated empty string ("").

Since: 3.6

e_util_utf8_normalize ()

gchar *
e_util_utf8_normalize (const gchar *str);

Normalizes str by making it all lower case and removing any accents from it.

Since: 3.8

e_util_ensure_gdbus_string ()

const gchar *
e_util_ensure_gdbus_string (const gchar *str,
                            gchar **gdbus_str);

If str is a valid UTF-8 string, the function returns str and does not set gdbus_str .

If str is an invalid UTF-8 string, the function calls e_util_utf8_make_valid() and points gdbus_str to the newly-allocated, valid UTF-8 string, and also returns it. The caller should free the string pointed to by gdbus_str with g_free().

If str is NULL, the function returns an empty string and does not set gdbus_str .

Admittedly, the function semantics are a little awkward. The example below illustrates the easiest way to cope with the gdbus_str argument:

1
2
3
4
5
6
7
8
9
10
11

const gchar *trusted_utf8;
gchar *allocated = NULL;

trusted_utf8 = e_util_ensure_gdbus_string (untrusted_utf8, &allocated);

Do stuff with trusted_utf8, then clear it.

trusted_utf8 = NULL;

g_free (allocated);
allocated = NULL;

Since: 3.0

e_util_gthread_id ()

guint64
e_util_gthread_id (GThread *thread);

Returns a 64-bit integer hopefully uniquely identifying the thread. To be used in debugging output and logging only. The returned value is just a cast of a pointer to the 64-bit integer.

There is no guarantee that calling e_util_gthread_id() on one thread first and later after that thread has dies on another won't return the same integer.

On Linux and Win32, known to really return a unique id for each thread existing at a certain time. No guarantee that ids won't be reused after a thread has terminated, though.

Since: 2.32

e_filename_make_safe ()

void
e_filename_make_safe (gchar *string);

e_filename_mkdir_encoded ()

gchar *
e_filename_mkdir_encoded (const gchar *basepath,
                          const gchar *fileprefix,
                          const gchar *filename,
                          gint fileindex);

Creates a local path constructed from basepath / fileprefix + "-" + filename , and makes sure the path basepath exists. If creation of the path fails, then NULL is returned.

Since: 3.4

e_utf8_strftime ()

gsize
e_utf8_strftime (gchar *string,
                 gsize max,
                 const gchar *fmt,
                 const struct tm *tm);

The UTF-8 equivalent of e_strftime().

e_strftime ()

gsize
e_strftime (gchar *string,
            gsize max,
            const gchar *fmt,
            const struct tm *tm);

This function is a wrapper around the strftime (3) function, which converts the %l and %k (12h and 24h) format variables if necessary.

e_util_slist_to_strv ()

gchar **
e_util_slist_to_strv (const GSList *strings);

Convert list of strings into NULL-terminates array of strings.

Since: 3.4

e_util_strv_to_slist ()

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

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

Since: 3.4

e_util_free_nullable_object_slist ()

void
e_util_free_nullable_object_slist (GSList *objects);

Calls g_object_unref() on each member of objects if non-NULL and then frees also objects itself.

Since: 3.6

e_util_safe_free_string ()

void
e_util_safe_free_string (gchar *str);

Calls g_free() on string , but before it rewrites its content with zeros. This is suitable to free strings with passwords.

Since: 3.16

e_queue_transfer ()

void
e_queue_transfer (GQueue *src_queue,
                  GQueue *dst_queue);

Transfers the contents of src_queue to the tail of dst_queue . When the operation is complete, src_queue will be empty.

Since: 3.8

e_weak_ref_new ()

GWeakRef *
e_weak_ref_new (gpointer object);

Allocates a new GWeakRef and calls g_weak_ref_set() with object .

Free the returned GWeakRef with e_weak_ref_free().

Since: 3.10

e_weak_ref_free ()

void
e_weak_ref_free (GWeakRef *weak_ref);

Frees a GWeakRef created by e_weak_ref_new().

Since: 3.10

e_file_recursive_delete_sync ()

gboolean
e_file_recursive_delete_sync (GFile *file,
                              GCancellable *cancellable,
                              GError **error);

Deletes file . If file is a directory, its contents are deleted recursively before file itself is deleted. The recursive delete operation will stop on the first error.

If cancellable is not NULL, then the operation 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.

Since: 3.6

e_file_recursive_delete ()

void
e_file_recursive_delete (GFile *file,
                         gint io_priority,
                         GCancellable *cancellable,
                         GAsyncReadyCallback callback,
                         gpointer user_data);

Asynchronously deletes file . If file is a directory, its contents are deleted recursively before file itself is deleted. The recursive delete operation will stop on the first error.

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object before the operation finishes.

When the operation is finished, callback will be called. You can then call e_file_recursive_delete_finish() to get the result of the operation.

Since: 3.6

e_file_recursive_delete_finish ()

gboolean
e_file_recursive_delete_finish (GFile *file,
                                GAsyncResult *result,
                                GError **error);

Finishes the operation started with e_file_recursive_delete().

If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be returned.

Since: 3.6

e_binding_bind_property ()

GBinding *
e_binding_bind_property (gpointer source,
                         const gchar *source_property,
                         gpointer target,
                         const gchar *target_property,
                         GBindingFlags flags);

Thread safe variant of g_object_bind_property(). See its documentation for more information on arguments and return value.

Since: 3.16

e_binding_bind_property_full ()

GBinding *
e_binding_bind_property_full (gpointer source,
                              const gchar *source_property,
                              gpointer target,
                              const gchar *target_property,
                              GBindingFlags flags,
                              GBindingTransformFunc transform_to,
                              GBindingTransformFunc transform_from,
                              gpointer user_data,
                              GDestroyNotify notify);

Thread safe variant of g_object_bind_property_full(). See its documentation for more information on arguments and return value.

Since: 3.16

e_binding_bind_property_with_closures ()

GBinding *
e_binding_bind_property_with_closures (gpointer source,
                                       const gchar *source_property,
                                       gpointer target,
                                       const gchar *target_property,
                                       GBindingFlags flags,
                                       GClosure *transform_to,
                                       GClosure *transform_from);

Thread safe variant of g_object_bind_property_with_closures(). See its documentation for more information on arguments and return value.

[rename-to e_binding_bind_property_full]

Since: 3.16

e_binding_transform_enum_value_to_nick ()

gboolean
e_binding_transform_enum_value_to_nick
                               (GBinding *binding,
                                const GValue *source_value,
                                GValue *target_value,
                                gpointer not_used);

Transforms an enumeration value to its corresponding nickname.

Since: 3.4

e_binding_transform_enum_nick_to_value ()

gboolean
e_binding_transform_enum_nick_to_value
                               (GBinding *binding,
                                const GValue *source_value,
                                GValue *target_value,
                                gpointer not_used);

Transforms an enumeration nickname to its corresponding value.

Since: 3.4

e_enum_from_string ()

gboolean
e_enum_from_string (GType enum_type,
                    const gchar *string,
                    gint *enum_value);

Fetches the appropriate enumeration value for string in the given enum type type and stores the result in enum_value

Since: 3.8

e_enum_to_string ()

const gchar *
e_enum_to_string (GType enum_type,
                  gint enum_value);

Converts an enum value to a string using strings from the GType system.

Since: 3.8

e_async_closure_new ()

EAsyncClosure *
e_async_closure_new (void);

Creates a new EAsyncClosure for use with asynchronous functions.

Since: 3.6

e_async_closure_wait ()

GAsyncResult *
e_async_closure_wait (EAsyncClosure *closure);

Call this function immediately after starting an asynchronous operation. The function waits for the asynchronous operation to complete and returns its GAsyncResult to be passed to the operation's "finish" function.

This function can be called repeatedly on the same EAsyncClosure to easily string together multiple asynchronous operations.

Since: 3.6

e_async_closure_free ()

void
e_async_closure_free (EAsyncClosure *closure);

Frees the closure and the resources it holds.

Since: 3.6

e_async_closure_callback ()

void
e_async_closure_callback (GObject *object,
                          GAsyncResult *result,
                          gpointer closure);

Pass this function as the GAsyncReadyCallback argument of an asynchronous function, and the EAsyncClosure as the data argument.

This causes e_async_closure_wait() to terminate and return result .

Since: 3.6

e_util_get_prefix ()

const gchar *
e_util_get_prefix (void);

e_util_get_cp_prefix ()

const gchar *
e_util_get_cp_prefix (void);

e_util_get_localedir ()

const gchar *
e_util_get_localedir (void);

e_util_replace_prefix ()

gchar *
e_util_replace_prefix (const gchar *configure_time_prefix,
                       const gchar *runtime_prefix,
                       const gchar *configure_time_path);

e_util_win32_initialize ()

void
e_util_win32_initialize (void);

Initializes win32 environment. This might be called in main().

e_named_parameters_new ()

ENamedParameters *
e_named_parameters_new (void);

Creates a new instance of an ENamedParameters. This should be freed with e_named_parameters_free(), when no longer needed. Names are compared case insensitively.

The structure is not thread safe, if the caller requires thread safety, then it should provide it on its own.

Since: 3.8

e_named_parameters_new_strv ()

ENamedParameters *
e_named_parameters_new_strv (const gchar * const *strv);

Creates a new instance of an ENamedParameters, with initial content being taken from strv . This should be freed with e_named_parameters_free(), when no longer needed. Names are compared case insensitively.

The structure is not thread safe, if the caller requires thread safety, then it should provide it on its own.

Since: 3.8

e_named_parameters_new_string ()

ENamedParameters *
e_named_parameters_new_string (const gchar *str);

Creates a new instance of an ENamedParamters, with initial content being taken from str . This should be freed with e_named_parameters_free(), when no longer needed. Names are compared case insensitively.

The str should be created with e_named_parameters_to_string(), to be properly encoded.

The structure is not thread safe, if the caller requires thread safety, then it should provide it on its own.

Since: 3.18

e_named_parameters_new_clone ()

ENamedParameters *
e_named_parameters_new_clone (const ENamedParameters *parameters);

Creates a new instance of an ENamedParameters, with initial content being taken from parameters . This should be freed with e_named_parameters_free(), when no longer needed. Names are compared case insensitively.

The structure is not thread safe, if the caller requires thread safety, then it should provide it on its own.

Since: 3.16

e_named_parameters_free ()

void
e_named_parameters_free (ENamedParameters *parameters);

Frees an instance of ENamedParameters, previously allocated with e_named_parameters_new(). Function does nothing, if parameters is NULL.

Since: 3.8

e_named_parameters_clear ()

void
e_named_parameters_clear (ENamedParameters *parameters);

Removes all stored parameters from parameters .

Since: 3.8

e_named_parameters_assign ()

void
e_named_parameters_assign (ENamedParameters *parameters,
                           const ENamedParameters *from);

Makes content of the parameters the same as from . Functions clears content of parameters if from is NULL.

Since: 3.8

e_named_parameters_set ()

void
e_named_parameters_set (ENamedParameters *parameters,
                        const gchar *name,
                        const gchar *value);

Sets parameter named name to value value . If value is NULL, then the parameter is removed. value can be an empty string.

Note: There is a restriction on parameter names, it cannot be empty or contain a colon character (':'), otherwise it can be pretty much anything.

Since: 3.8

e_named_parameters_get ()

const gchar *
e_named_parameters_get (const ENamedParameters *parameters,
                        const gchar *name);

Returns current value of a parameter with name name . If not such exists, then returns NULL.

Since: 3.8

e_named_parameters_to_strv ()

gchar **
e_named_parameters_to_strv (const ENamedParameters *parameters);

Since: 3.8

e_named_parameters_to_string ()

gchar *
e_named_parameters_to_string (const ENamedParameters *parameters);

Since: 3.18

e_named_parameters_test ()

gboolean
e_named_parameters_test (const ENamedParameters *parameters,
                         const gchar *name,
                         const gchar *value,
                         gboolean case_sensitively);

Compares current value of parameter named name with given value and returns whether they are equal, either case sensitively or insensitively, based on case_sensitively argument. Function returns FALSE, if no such parameter exists.

Since: 3.8

e_named_parameters_exists ()

gboolean
e_named_parameters_exists (const ENamedParameters *parameters,
                           const gchar *name);

Since: 3.18

e_named_parameters_count ()

guint
e_named_parameters_count (const ENamedParameters *parameters);

Since: 3.18

e_named_parameters_get_name ()

gchar *
e_named_parameters_get_name (const ENamedParameters *parameters,
                             gint index);

Since: 3.18

e_named_timeout_add()

#define             e_named_timeout_add(interval, function, data)

Similar to g_timeout_add(), but also names the GSource for use in debugging and profiling. The name is formed from function and the PACKAGE definintion from a <config.h> file.

Since: 3.12

e_named_timeout_add_full()

#define             e_named_timeout_add_full(priority, interval, function, data, notify)

Similar to g_timeout_add_full(), but also names the GSource for use in debugging and profiling. The name is formed from function and the PACKAGE definition from a <config.h> file.

Since: 3.12

e_named_timeout_add_seconds()

#define             e_named_timeout_add_seconds(interval, function, data)

Similar to g_timeout_add_seconds(), but also names the GSource for use in debugging and profiling. The name is formed from function and the PACKAGE definition from a <config.h> file.

Since: 3.12

e_named_timeout_add_seconds_full()

#define             e_named_timeout_add_seconds_full(priority, interval, function, data, notify)

Similar to g_timeout_add_seconds_full(), but also names the GSource for use in debugging and profiling. The name is formed from function and the PACKAGE definition from a <config.h> file.

Since: 3.12

e_timeout_add_with_name ()

guint
e_timeout_add_with_name (gint priority,
                         guint interval,
                         const gchar *name,
                         GSourceFunc function,
                         gpointer data,
                         GDestroyNotify notify);

Similar to g_timeout_add_full(), but also names the GSource as name .

You might find e_named_timeout_add() or e_named_timeout_add_full() more convenient. Those macros name the GSource implicitly.

Since: 3.12

e_timeout_add_seconds_with_name ()

guint
e_timeout_add_seconds_with_name (gint priority,
                                 guint interval,
                                 const gchar *name,
                                 GSourceFunc function,
                                 gpointer data,
                                 GDestroyNotify notify);

Similar to g_timeout_add_seconds_full(), but also names the GSource as name.

You might find e_named_timeout_add_seconds() or e_named_timeout_add_seconds_full() more convenient. Those macros name the GSource implicitly.

Since: 3.12

e_util_free_string_slist ()

void
e_util_free_string_slist (GSList *strings);

Frees memory previously allocated by e_util_strv_to_slist().

Since: 3.4

e_util_free_object_slist ()

void
e_util_free_object_slist (GSList *objects);

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

Since: 3.4

e_util_copy_string_slist ()

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

Copies GSList of strings at the end of copy_to .

Since: 3.4

e_util_copy_object_slist ()

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

Copies GSList of GObjects at the end of copy_to .

Since: 3.4

e_data_server_util_get_dbus_call_timeout ()

gint
e_data_server_util_get_dbus_call_timeout
                               (void);

Returns the value set by e_data_server_util_set_dbus_call_timeout().

Since: 3.0

e_data_server_util_set_dbus_call_timeout ()

void
e_data_server_util_set_dbus_call_timeout
                               (gint timeout_msec);

Sets default timeout, in milliseconds, for calls of g_dbus_proxy_call() family functions.

-1 means the default value as set by D-Bus itself. G_MAXINT means no timeout at all.

Default value is set also by configure option --with-dbus-call-timeout=ms and -1 is used when not set.

Since: 3.0

e_source_registry_debug_enabled ()

gboolean
e_source_registry_debug_enabled (void);

Since: 3.16

e_source_registry_debug_print ()

void
e_source_registry_debug_print (const gchar *format,
                               ...);

Prints the text only if a debugging is enabled with an environment variable ESR_DEBUG=1.

Since: 3.16

ETypeFunc ()

void
(*ETypeFunc) (GType type,
              gpointer user_data);

Specifies the type of functions passed to e_type_traverse().

Since: 3.4

e_type_traverse ()

void
e_type_traverse (GType parent_type,
                 ETypeFunc func,
                 gpointer user_data);

Calls func for all instantiable subtypes of parent_type .

This is often useful for extending functionality by way of EModule. A module may register a subtype of parent_type in its e_module_load() function. Then later on the application will call e_type_traverse() to instantiate all registered subtypes of parent_type .

Since: 3.4

e_util_get_source_full_name ()

gchar *
e_util_get_source_full_name (struct _ESourceRegistry *registry,
                             struct _ESource *source);

Constructs a full name of the source with all of its parents of the form: "<account-name> : <parent>/<source>" where the "<parent>/" part can be repeated zero or more times, depending on the deep level of the source .

e_util_get_source_oauth2_access_token_sync ()

gboolean
e_util_get_source_oauth2_access_token_sync
                               (struct _ESource *source,
                                const ENamedParameters *credentials,
                                gchar **out_access_token,
                                gint *out_expires_in_seconds,
                                GCancellable *cancellable,
                                GError **error);

Obtains the OAuth 2.0 access token for source along with its expiry in seconds from the current time (or 0 if unknown).

Free the returned access token with g_free() when finished with it. If an error occurs, the function will set error and return FALSE.

EAsyncClosure

typedef struct _EAsyncClosure EAsyncClosure;

EAsyncClosure provides a simple way to run an asynchronous function synchronously without blocking a running GMainLoop or using threads.

1) Create an EAsyncClosure with e_async_closure_new().

2) Call the asynchronous function passing e_async_closure_callback() as the GAsyncReadyCallback argument and the EAsyncClosure as the data argument.

3) Call e_async_closure_wait() and collect the GAsyncResult.

4) Call the corresponding asynchronous "finish" function, passing the GAsyncResult returned by e_async_closure_wait().

5) If needed, repeat steps 2-4 for additional asynchronous functions using the same EAsyncClosure.

6) Finally, free the EAsyncClosure with e_async_closure_free().

Since: 3.6

ENamedParameters

typedef struct _ENamedParameters ENamedParameters;

Since: 3.8

struct tm

struct tm;