Top | ![]() |
![]() |
![]() |
![]() |
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
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
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
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.
v1 |
a |
[allow-none] |
v2 |
another |
[allow-none] |
Since: 3.12
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
gint e_util_strcmp0 (const gchar *str1
,const gchar *str2
);
Compares str1
and str2
like g_strcmp0()
, except it handles NULL
and
empty strings as equal.
an integer less than 0 when str1
is before str2
; 0 when
the strings are equal and an integer greated than 0 when str1
is after str2
.
Since: 3.32
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.
gchar * e_util_unicode_get_utf8 (const gchar *text
,gunichar *out
);
Get a UTF-8 character from the beginning of text
.
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.
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.
gint e_util_utf8_strcasecmp (const gchar *s1
,const gchar *s2
);
Compares two UTF-8 strings using approximate case-insensitive ordering.
gchar *
e_util_utf8_remove_accents (const gchar *str
);
Returns a newly-allocated copy of str
with accents removed.
Since: 2.28
gchar *
e_util_utf8_decompose (const gchar *text
);
Converts the text
into a decomposed variant and strips it, which
allows also cheap case insensitive comparision afterwards. This
produces an output as being used in e_util_utf8_strstrcasedecomp()
.
A newly allocated string, a decomposed
variant of the text
. Free with g_free()
, when no longer needed.
[transfer full]
Since: 3.26
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
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
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
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; |
str |
a possibly invalid UTF-8 string, or |
|
gdbus_str |
return location for the corrected string |
Since: 3.0
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
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.
basepath |
base path of a file name; this is left unchanged |
|
fileprefix |
prefix for the filename; this is encoded |
|
filename |
file name to use; this is encoded; can be |
|
fileindex |
used when |
Full local path like g_build_filename()
except that fileprefix
and filename
are encoded to create a proper file elements for
a file system. Free returned pointer with g_free()
.
Since: 3.4
gsize e_utf8_strftime (gchar *string
,gsize max
,const gchar *fmt
,const struct tm *tm
);
The UTF-8 equivalent of 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.
gchar **
e_util_slist_to_strv (const GSList *strings
);
Convert list of strings into NULL-terminates array of strings.
Newly allocated NULL
-terminated array of strings.
Returned pointer should be freed with g_strfreev()
.
Note: Pair function for this is e_util_strv_to_slist()
.
[transfer full]
Since: 3.4
GSList *
e_util_strv_to_slist (const gchar * const *strv
);
Convert NULL-terminated array of strings to a list of strings.
Newly allocated GSList of
newly allocated strings. The returned pointer should be freed with
e_util_free_string_slist()
.
Note: Pair function for this is e_util_slist_to_strv()
.
[transfer full][element-type utf8]
Since: 3.4
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
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
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
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()
.
[skip]
Since: 3.10
void
e_weak_ref_free (GWeakRef *weak_ref
);
Frees a GWeakRef created by e_weak_ref_new()
.
[skip]
Since: 3.10
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.
file |
a GFile to delete |
|
cancellable |
optional GCancellable object, or |
|
error |
return location for a GError, or |
Since: 3.6
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.
file |
a GFile to delete |
|
io_priority |
the I/O priority of the request |
|
cancellable |
optional GCancellable object, or |
|
callback |
a GAsyncReadyCallback to call when the request is satisfied |
|
user_data |
data to pass to the callback function |
Since: 3.6
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.
file |
a GFile to delete |
|
result |
a GAsyncResult. |
[transfer full] |
error |
return location for a GError, or |
Since: 3.6
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.
source |
the source GObject. |
[type GObject.Object] |
source_property |
the property on |
|
target |
the target GObject. |
[type GObject.Object] |
target_property |
the property on |
|
flags |
flags to pass to GBinding |
Since: 3.16
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.
source |
the source GObject. |
[type GObject.Object] |
source_property |
the property on |
|
target |
the target GObject. |
[type GObject.Object] |
target_property |
the property on |
|
flags |
flags to pass to GBinding |
|
transform_to |
the transformation function
from the |
[scope notified][allow-none] |
transform_from |
the transformation function
from the |
[scope notified][allow-none] |
user_data |
custom data to be passed to the transformation functions,
or |
|
notify |
function to be called when disposing the binding, to free the resources used by the transformation functions |
the GBinding instance representing the binding between the two GObject instances. The binding is released whenever the GBinding reference count reaches zero.
[transfer none]
Since: 3.16
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]
source |
the source GObject. |
[type GObject.Object] |
source_property |
the property on |
|
target |
the target GObject. |
[type GObject.Object] |
target_property |
the property on |
|
flags |
flags to pass to GBinding |
|
transform_to |
a GClosure wrapping the transformation function
from the |
|
transform_from |
a GClosure wrapping the transformation function
from the |
the GBinding instance representing the binding between the two GObject instances. The binding is released whenever the GBinding reference count reaches zero.
[transfer none]
Since: 3.16
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.
binding |
a GBinding |
|
source_value |
a GValue whose type is derived from G_TYPE_ENUM |
|
target_value |
a GValue of type G_TYPE_STRING |
|
not_used |
not used |
Since: 3.4
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.
binding |
a GBinding |
|
source_value |
a GValue of type G_TYPE_STRING |
|
target_value |
a GValue whose type is derived from G_TYPE_ENUM |
|
not_used |
not used |
Since: 3.4
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
enum_type |
The enum type |
|
string |
The string containing the enum value or nick |
|
enum_value |
A return location to store the result |
TRUE
if the string was a valid name or nick
for the given type
, FALSE
if the conversion failed.
Since: 3.8
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
EAsyncClosure *
e_async_closure_new (void
);
Creates a new EAsyncClosure for use with asynchronous functions.
[skip]
Since: 3.6
EAsyncClosure *
e_async_closure_new_with_context (GMainContext *context
);
Creates a new EAsyncClosure for use with asynchronous functions
using the context
as the main context.
[skip]
Since: 3.40
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.
[skip]
Since: 3.6
void
e_async_closure_free (EAsyncClosure *closure
);
Frees the closure
and the resources it holds.
[skip]
Since: 3.6
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
.
[skip]
object |
a GObject or |
|
result |
a GAsyncResult |
|
closure |
Since: 3.6
gchar * e_util_replace_prefix (const gchar *configure_time_prefix
,const gchar *runtime_prefix
,const gchar *configure_time_path
);
void
e_util_win32_initialize (void
);
Initializes win32 environment. This might be called in main()
.
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
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.
strv |
NULL-terminated string array to be used as a content of a newly created ENamedParameters |
Since: 3.8
ENamedParameters *
e_named_parameters_new_string (const gchar *str
);
Creates a new instance of an ENamedParameters, 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
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.
parameters |
an ENamedParameters to be used as a content of a newly created ENamedParameters |
Since: 3.16
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
void
e_named_parameters_clear (ENamedParameters *parameters
);
Removes all stored parameters from parameters
.
Since: 3.8
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
.
parameters |
an ENamedParameters to assign values to |
|
from |
an ENamedParameters to get values from, or |
[allow-none] |
Since: 3.8
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.
parameters |
||
name |
name of a parameter to set |
|
value |
value to set, or |
[allow-none] |
Since: 3.8
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
gchar **
e_named_parameters_to_strv (const ENamedParameters *parameters
);
Since: 3.8
gchar *
e_named_parameters_to_string (const ENamedParameters *parameters
);
Since: 3.18
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.
parameters |
||
name |
name of a parameter to test |
|
value |
value to test |
|
case_sensitively |
whether to compare case sensitively |
Since: 3.8
gboolean e_named_parameters_exists (const ENamedParameters *parameters
,const gchar *name
);
Since: 3.18
guint
e_named_parameters_count (const ENamedParameters *parameters
);
Since: 3.18
gchar * e_named_parameters_get_name (const ENamedParameters *parameters
,gint index
);
The name of the parameters at index index
,
or NULL
, of the index
is out of bounds or other error. The returned
string should be freed with g_free()
when done with it.
[transfer full]
Since: 3.18
#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.
interval |
the time between calls to the function, in milliseconds (1/1000ths of a second) |
|
function |
function to call |
|
data |
data to pass to |
Since: 3.12
#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.
priority |
the priority of the timeout source, typically in the range between G_PRIORITY_DEFAULT and G_PRIORITY_HIGH |
|
interval |
the time between calls to the function, in milliseconds (1/1000ths of a second) |
|
function |
function to call |
|
data |
data to pass to |
|
notify |
function to call when the timeout is removed, or |
Since: 3.12
#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.
interval |
the time between calls to the function, in seconds |
|
function |
function to call |
|
data |
data to pass to |
Since: 3.12
#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.
priority |
the priority of the timeout source, typically in the range between G_PRIORITY_DEFAULT and G_PRIORITY_HIGH |
|
interval |
the time between calls to the function, in seconds |
|
function |
function to call |
|
data |
data to pass to |
|
notify |
function to call when the timeout is removed, or |
Since: 3.12
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.
priority |
the priority of the timeout source, typically in the range between G_PRIORITY_DEFAULT and G_PRIORITY_HIGH |
|
interval |
the time between calls to the function, in milliseconds (1/1000ths of a second) |
|
name |
debug name for the source. |
[allow-none] |
function |
function to call |
|
data |
data to pass to |
|
notify |
function to call when the timeout is removed,
or |
[allow-none] |
Since: 3.12
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.
priority |
the priority of the timeout source, typically in the range between G_PRIORITY_DEFAULT and G_PRIORITY_HIGH |
|
interval |
the time between calls to the function, in seconds |
|
name |
debug name for the source. |
[allow-none] |
function |
function to call |
|
data |
data to pass to |
|
notify |
function to call when the timeout is removed,
or |
[allow-none] |
Since: 3.12
void
e_util_free_string_slist (GSList *strings
);
e_util_free_string_slist
has been deprecated since version 3.8 and should not be used in newly-written code.
Use g_slist_free_full()
instead.
Frees memory previously allocated by e_util_strv_to_slist()
.
Since: 3.4
void
e_util_free_object_slist (GSList *objects
);
e_util_free_object_slist
has been deprecated since version 3.8 and should not be used in newly-written code.
Use g_slist_free_full()
instead.
Calls g_object_unref()
on each member of objects
and then frees
also objects
itself.
Since: 3.4
GSList * e_util_copy_string_slist (GSList *copy_to
,const GSList *strings
);
e_util_copy_string_slist
has been deprecated since version 3.8 and should not be used in newly-written code.
Use g_slist_copy_deep()
instead, and optionally
g_slist_concat()
to concatenate the copied list
to another GSList.
Copies GSList of strings at the end of copy_to
.
copy_to |
Where to copy; can be |
[element-type utf8][allow-none] |
strings |
GSList of strings to be copied. |
[element-type utf8] |
New head of copy_to
.
Returned pointer can be freed with e_util_free_string_slist()
.
[transfer full][element-type utf8]
Since: 3.4
GSList * e_util_copy_object_slist (GSList *copy_to
,const GSList *objects
);
e_util_copy_object_slist
has been deprecated since version 3.8 and should not be used in newly-written code.
Use g_slist_copy_deep()
instead, and optionally
g_slist_concat()
to concatenate the copied list
to another GSList.
Copies GSList of GObjects at the end of copy_to
.
copy_to |
Where to copy; can be |
[element-type GObject][allow-none] |
objects |
GSList of GObjects to be copied. |
[element-type GObject] |
New head of copy_to
.
Returned pointer can be freed with e_util_free_object_slist()
.
[transfer full][element-type GObject]
Since: 3.4
gint
e_data_server_util_get_dbus_call_timeout
(void
);
e_data_server_util_get_dbus_call_timeout
has been deprecated since version 3.8 and should not be used in newly-written code.
This value is not used anywhere.
Returns the value set by e_data_server_util_set_dbus_call_timeout()
.
Since: 3.0
void
e_data_server_util_set_dbus_call_timeout
(gint timeout_msec
);
e_data_server_util_set_dbus_call_timeout
has been deprecated since version 3.8 and should not be used in newly-written code.
This value is not used anywhere.
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
gboolean
e_source_registry_debug_enabled (void
);
Whether debugging is enabled, that is,
whether e_source_registry_debug_print()
will produce any output.
Since: 3.16
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
void e_util_debug_print (const gchar *domain
,const gchar *format
,...
);
Prints a text according to format
and its arguments to stdout
prefixed with domain
in brackets [] and the current date and time.
This function doesn't check whether the logging is enabled, it's up
to the caller to determine it, the function only prints the information
in a consistent format:
[domain] YYYY-MM-DD hh:mm:ss.ms - format
Since: 3.30
void e_util_debug_printv (const gchar *domain
,const gchar *format
,va_list args
);
Prints a text according to format
and its args
to stdout
prefixed with domain
in brackets [] and the current date and time.
This function doesn't check whether the logging is enabled, it's up
to the caller to determine it, the function only prints the information
in a consistent form:
[domain
] YYYY-MM-DD hh:mm:ss.ms - format
See: e_util_debug_print()
Since: 3.30
void (*ETypeFunc) (GType type
,gpointer user_data
);
Specifies the type of functions passed to e_type_traverse()
.
Since: 3.4
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
.
parent_type |
the root GType to traverse from |
|
func |
the function to call for each visited GType. |
[scope call] |
user_data |
user data to pass to the function |
Since: 3.4
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
.
void
e_util_unref_in_thread (gpointer object
);
Unrefs the given object
in a dedicated thread. This is useful when unreffing
object deep in call stack when the caller might still use the object and
this being the last reference to it.
Since: 3.26
gchar *
e_util_generate_uid (void
);
Generates a unique identificator, which can be used as part of the Message-ID header, or iCalendar component UID, or vCard UID. The resulting string doesn't contain any host name, it's a hexa-decimal string with no particular meaning.
Free the returned string with g_free()
, when no longer needed.
Since: 3.26
gboolean e_util_identity_can_send (struct _ESourceRegistry *registry
,struct _ESource *identity_source
);
Checks whether the identity_source
can be used for sending, which means
whether it has configures send mail source.
Since: 3.26
gboolean e_util_can_use_collection_as_credential_source (struct _ESource *collection_source
,struct _ESource *child_source
);
Checks whether the collection_source
can be used as a credential source
for the child_source
. The relationship is not tested in the function.
When the collection_source
is NULL
, then it simply returns FALSE
.
collection_source |
a collection ESource, or |
[nullable] |
child_source |
a children of |
whether collection_source
can be used as a credential source
for child_source
, that is, whether they share credentials.
Since: 3.28
gint e_util_source_compare_for_sort (struct _ESource *source_a
,struct _ESource *source_b
);
Compares two ESource-s in a way suitable for user interface. It can be used as a GCompareFunc.
This is also used by e_source_registry_build_display_tree()
.
an integer less than, equal to, or greater than zero,
if source_a
is <, == or > than source_b
.
Since: 3.40
GPtrArray * e_util_get_directory_variants (const gchar *main_path
,const gchar *replace_prefix
,gboolean with_modules_dir
);
The main_path
is a directory, which will be always used. It
should have as its prefix the replace_prefix
, otherwise
the function returns only the main_path
in the paths array.
When there's exported an environment variable EDS_EXTRA_PREFIXES,
it is used as a list of alternative prefixes where to look for
the main_path
(rest after the replace_prefix
).
When the with_modules_dir
is TRUE
, there's also added
g_get_user_data_dir()
+ "evolution/modules/", aka
~/.local/share/evolution/modules/, into the resulting array.
main_path |
the main path to work with |
|
replace_prefix |
path prefix to replace |
|
with_modules_dir |
whether to add also the modules directory |
a GPtrArray
with paths to use, including the main_path
. Free it with
g_ptr_array_unref()
, when no longer needed.
[element-type utf8][transfer container]
Since: 3.40
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