<root>
<function name="g_str_hash">
<description>
Converts a string to a hash value.
It can be passed to g_hash_table_new() as the @hash_func 
parameter, when using strings as keys in a #GHashTable.


</description>
<parameters>
<parameter name="v">
<parameter_description> a string key
</parameter_description>
</parameter>
</parameters>
<return> a hash value corresponding to the key
</return>
</function>

<function name="g_shell_unquote">
<description>
Unquotes a string as the shell (/bin/sh) would. Only handles
quotes; if a string contains file globs, arithmetic operators,
variables, backticks, redirections, or other special-to-the-shell
features, the result will be different from the result a real shell
would produce (the variables, backticks, etc. will be passed
through literally instead of being expanded). This function is
guaranteed to succeed if applied to the result of
g_shell_quote(). If it fails, it returns %NULL and sets the
error. The @quoted_string need not actually contain quoted or
escaped text; g_shell_unquote() simply goes through the string and
unquotes/unescapes anything that the shell would. Both single and
double quotes are handled, as are escapes including escaped
newlines. The return value must be freed with g_free(). Possible
errors are in the #G_SHELL_ERROR domain.

Shell quoting rules are a bit strange. Single quotes preserve the
literal string exactly. escape sequences are not allowed; not even
\' - if you want a ' in the quoted text, you have to do something
like 'foo'\''bar'.  Double quotes allow $, `, &quot;, \, and newline to
be escaped with backslash. Otherwise double quotes preserve things
literally.


</description>
<parameters>
<parameter name="quoted_string">
<parameter_description> shell-quoted string
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> error return location or NULL
</parameter_description>
</parameter>
</parameters>
<return> an unquoted string
</return>
</function>

<function name="g_type_remove_class_cache_func">
<description>
Removes a previously installed #GTypeClassCacheFunc. The cache
maintained by @cache_func has to be empty when calling
g_type_remove_class_cache_func() to avoid leaks.

</description>
<parameters>
<parameter name="cache_data">
<parameter_description> data that was given when adding @cache_func
</parameter_description>
</parameter>
<parameter name="cache_func">
<parameter_description> a #GTypeClassCacheFunc
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_build_pathv">
<description>
Behaves exactly like g_build_path(), but takes the path elements 
as a string array, instead of varargs. This function is mainly
meant for language bindings.

Since: 2.8

</description>
<parameters>
<parameter name="separator">
<parameter_description> a string used to separator the elements of the path.
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> %NULL-terminated array of strings containing the path elements.
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string that must be freed with g_free().

</return>
</function>

<function name="g_thread_pool_get_num_threads">
<description>
Returns the number of threads currently running in @pool.


</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GThreadPool
</parameter_description>
</parameter>
</parameters>
<return> the number of threads currently running
</return>
</function>

<function name="g_bookmark_file_get_applications">
<description>
Retrieves the names of the applications that have registered the
bookmark for @uri.

In the event the URI cannot be found, %NULL is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> return location of the length of the returned list, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated %NULL-terminated array of strings.
Use g_strfreev() to free it.

</return>
</function>

<function name="g_atomic_pointer_get">
<description>
Reads the value of the pointer pointed to by @atomic.
Also acts as a memory barrier.

Since: 2.4

</description>
<parameters>
<parameter name="atomic">
<parameter_description> a pointer to a #gpointer.
</parameter_description>
</parameter>
</parameters>
<return> the value to add to *@atomic.

</return>
</function>

<function name="g_variant_equal">
<description>
Checks if @one and @two have the same type and value.

The types of @one and @two are #gconstpointer only to allow use of
this function with #GHashTable.  They must each be a #GVariant.

Since: 2.24

</description>
<parameters>
<parameter name="one">
<parameter_description> a #GVariant instance
</parameter_description>
</parameter>
<parameter name="two">
<parameter_description> a #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @one and @two are equal
</return>
</function>

<function name="g_intern_string">
<description>
Returns a canonical representation for @string. Interned strings can
be compared for equality by comparing the pointers, instead of using strcmp().

Since: 2.10

</description>
<parameters>
<parameter name="string">
<parameter_description> a string
</parameter_description>
</parameter>
</parameters>
<return> a canonical representation for the string

</return>
</function>

<function name="g_type_add_class_private">
<description>
Registers a private class structure for a classed type;
when the class is allocated, the private structures for
the class and all of its parent types are allocated
sequentially in the same memory block as the public
structures. This function should be called in the
type's get_type() function after the type is registered.
The private structure can be retrieved using the
G_TYPE_CLASS_GET_PRIVATE() macro.

Since: 2.24

</description>
<parameters>
<parameter name="class_type">
<parameter_description> GType of an classed type.
</parameter_description>
</parameter>
<parameter name="private_size">
<parameter_description> size of private structure.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cclosure_new">
<description>
Creates a new closure which invokes @callback_func with @user_data as
the last parameter.


</description>
<parameters>
<parameter name="callback_func">
<parameter_description> the function to invoke
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to @callback_func
</parameter_description>
</parameter>
<parameter name="destroy_data">
<parameter_description> destroy notify to be called when @user_data is no longer used
</parameter_description>
</parameter>
</parameters>
<return> a new #GCClosure
</return>
</function>

<function name="g_source_new">
<description>
Creates a new #GSource structure. The size is specified to
allow creating structures derived from #GSource that contain
additional data. The size passed in must be at least
&lt;literal&gt;sizeof (GSource)&lt;/literal&gt;.

The source will not initially be associated with any #GMainContext
and must be added to one with g_source_attach() before it will be
executed.


</description>
<parameters>
<parameter name="source_funcs">
<parameter_description> structure containing functions that implement
the sources behavior.
</parameter_description>
</parameter>
<parameter name="struct_size">
<parameter_description> size of the #GSource structure to create.
</parameter_description>
</parameter>
</parameters>
<return> the newly-created #GSource.
</return>
</function>

<function name="g_param_spec_sink">
<description>
The initial reference count of a newly created #GParamSpec is 1,
even though no one has explicitly called g_param_spec_ref() on it
yet. So the initial reference count is flagged as &quot;floating&quot;, until
someone calls &lt;literal&gt;g_param_spec_ref (pspec); g_param_spec_sink
(pspec);&lt;/literal&gt; in sequence on it, taking over the initial
reference count (thus ending up with a @pspec that has a reference
count of 1 still, but is not flagged &quot;floating&quot; anymore).

</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_n_children">
<description>
Gets the number of children of a #GNode.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
</parameters>
<return> the number of children of @node
</return>
</function>

<function name="g_string_chunk_new">
<description>
Creates a new #GStringChunk. 


</description>
<parameters>
<parameter name="size">
<parameter_description> the default size of the blocks of memory which are 
allocated to store the strings. If a particular string 
is larger than this default size, a larger block of 
memory will be allocated for it.
</parameter_description>
</parameter>
</parameters>
<return> a new #GStringChunk
</return>
</function>

<function name="g_chunk_new">
<description>
A convenience macro to allocate an atom of memory from a #GMemChunk.
It calls g_mem_chunk_alloc() and casts the returned atom to a
pointer to the given type, avoiding a type cast in the source code.

Deprecated:2.10: Use g_slice_new() instead

</description>
<parameters>
<parameter name="type">
<parameter_description> the type of the #GMemChunk atoms, typically a structure name.
</parameter_description>
</parameter>
<parameter name="chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the allocated atom, cast to a pointer to
@type.
</return>
</function>

<function name="g_signal_add_emission_hook">
<description>
Adds an emission hook for a signal, which will get called for any emission
of that signal, independent of the instance. This is possible only
for signals which don't have #G_SIGNAL_NO_HOOKS flag set.


</description>
<parameters>
<parameter name="signal_id">
<parameter_description> the signal identifier, as returned by g_signal_lookup().
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> the detail on which to call the hook.
</parameter_description>
</parameter>
<parameter name="hook_func">
<parameter_description> a #GSignalEmissionHook function.
</parameter_description>
</parameter>
<parameter name="hook_data">
<parameter_description> user data for @hook_func.
</parameter_description>
</parameter>
<parameter name="data_destroy">
<parameter_description> a #GDestroyNotify for @hook_data.
</parameter_description>
</parameter>
</parameters>
<return> the hook id, for later use with g_signal_remove_emission_hook().
</return>
</function>

<function name="g_dir_read_name">
<description>
Retrieves the name of the next entry in the directory.  The '.' and
'..' entries are omitted. On Windows, the returned name is in
UTF-8. On Unix, it is in the on-disk encoding.


</description>
<parameters>
<parameter name="dir">
<parameter_description> a #GDir* created by g_dir_open()
</parameter_description>
</parameter>
</parameters>
<return> The entry's name or %NULL if there are no 
more entries. The return value is owned by GLib and
must not be modified or freed.
</return>
</function>

<function name="g_main_context_wakeup">
<description>
If @context is currently waiting in a poll(), interrupt
the poll(), and continue the iteration process.

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_closure_set_meta_marshal">
<description>
Sets the meta marshaller of @closure.  A meta marshaller wraps
@closure-&gt;marshal and modifies the way it is called in some
fashion. The most common use of this facility is for C callbacks.
The same marshallers (generated by &lt;link
linkend=&quot;glib-genmarshal&quot;&gt;glib-genmarshal&lt;/link&gt;) are used
everywhere, but the way that we get the callback function
differs. In most cases we want to use @closure-&gt;callback, but in
other cases we want to use some different technique to retrieve the
callback function.

For example, class closures for signals (see
g_signal_type_cclosure_new()) retrieve the callback function from a
fixed offset in the class structure.  The meta marshaller retrieves
the right callback and passes it to the marshaller as the
@marshal_data argument.

</description>
<parameters>
<parameter name="closure">
<parameter_description> a #GClosure
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> context-dependent data to pass to @meta_marshal
</parameter_description>
</parameter>
<parameter name="meta_marshal">
<parameter_description> a #GClosureMarshal function
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_get_byte">
<description>
Returns the byte value of @value.

It is an error to call this function with a @value of any type
other than %G_VARIANT_TYPE_BYTE.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a byte #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> a #guchar
</return>
</function>

<function name="g_get_tmp_dir">
<description>
Gets the directory to use for temporary files. This is found from 
inspecting the environment variables &lt;envar&gt;TMPDIR&lt;/envar&gt;, 
&lt;envar&gt;TMP&lt;/envar&gt;, and &lt;envar&gt;TEMP&lt;/envar&gt; in that order. If none 
of those are defined &quot;/tmp&quot; is returned on UNIX and &quot;C:\&quot; on Windows. 
The encoding of the returned string is system-defined. On Windows, 
it is always UTF-8. The return value is never %NULL.


</description>
<parameters>
</parameters>
<return> the directory to use for temporary files.
</return>
</function>

<function name="g_node_copy_deep">
<description>
Recursively copies a #GNode and its data.

Since: 2.4

</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
<parameter name="copy_func">
<parameter_description> the function which is called to copy the data inside each node,
or %NULL to use the original data.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to pass to @copy_func
</parameter_description>
</parameter>
</parameters>
<return> a new #GNode containing copies of the data in @node.

</return>
</function>

<function name="g_variant_ref_sink">
<description>
#GVariant uses a floating reference count system.  All functions with
names starting with &lt;literal&gt;g_variant_new_&lt;/literal&gt; return floating
references.

Calling g_variant_ref_sink() on a #GVariant with a floating reference
will convert the floating reference into a full reference.  Calling
g_variant_ref_sink() on a non-floating #GVariant results in an
additional normal reference being added.

In other words, if the @value is floating, then this call &quot;assumes
ownership&quot; of the floating reference, converting it to a normal
reference.  If the @value is not floating, then this call adds a
new normal reference increasing the reference count by one.

All calls that result in a #GVariant instance being inserted into a
container will call g_variant_ref_sink() on the instance.  This means
that if the value was just created (and has only its floating
reference) then the container will assume sole ownership of the value
at that point and the caller will not need to unreference it.  This
makes certain common styles of programming much easier while still
maintaining normal refcounting semantics in situations where values
are not floating.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return> the same @value
</return>
</function>

<function name="g_match_info_get_string">
<description>
Returns the string searched with @match_info. This is the
string passed to g_regex_match() or g_regex_replace() so
you may not free it before calling this function.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> a #GMatchInfo
</parameter_description>
</parameter>
</parameters>
<return> the string searched with @match_info

</return>
</function>

<function name="g_sequence_iter_compare">
<description>
Returns a negative number if @a comes before @b, 0 if they are equal,
and a positive number if @a comes after @b.

The @a and @b iterators must point into the same sequence.

Since: 2.14

</description>
<parameters>
<parameter name="a">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="b">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return> A negative number if @a comes before @b, 0 if they are
equal, and a positive number if @a comes after @b.

</return>
</function>

<function name="g_idle_add_full">
<description>
Adds a function to be called whenever there are no higher priority
events pending.  If the function returns %FALSE it is automatically
removed from the list of event sources and will not be called again.

This internally creates a main loop source using g_idle_source_new()
and attaches it to the main loop context using g_source_attach(). 
You can do these steps manually if you need greater control.


</description>
<parameters>
<parameter name="priority">
<parameter_description> the priority of the idle source. Typically this will be in the
range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
</parameter_description>
</parameter>
<parameter name="function">
<parameter_description> function to call
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description>     data to pass to @function
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description>   function to call when the idle is removed, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) of the event source.
</return>
</function>

<function name="g_variant_type_is_definite">
<description>
Determines if the given @type is definite (ie: not indefinite).

A type is definite if its type string does not contain any indefinite
type characters ('*', '?', or 'r').

A #GVariant instance may not have an indefinite type, so calling
this function on the result of g_variant_get_type() will always
result in %TRUE being returned.  Calling this function on an
indefinite type like %G_VARIANT_TYPE_ARRAY, however, will result in
%FALSE being returned.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is definite
</return>
</function>

<function name="g_queue_pop_nth">
<description>
Removes the @n'th element of @queue.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position of the element.
</parameter_description>
</parameter>
</parameters>
<return> the element's data, or %NULL if @n is off the end of @queue.

</return>
</function>

<function name="g_timer_destroy">
<description>
Destroys a timer, freeing associated resources.

</description>
<parameters>
<parameter name="timer">
<parameter_description> a #GTimer to destroy.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_prepend">
<description>
Adds a new element on to the start of the list.

&lt;note&gt;&lt;para&gt;
The return value is the new start of the list, which 
may have changed, so make sure you store the new value.
&lt;/para&gt;&lt;/note&gt;

|[
/ * Notice that it is initialized to the empty list. * /
GSList *list = NULL;
list = g_slist_prepend (list, &quot;last&quot;);
list = g_slist_prepend (list, &quot;first&quot;);
]|


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GSList
</return>
</function>

<function name="g_rand_double">
<description>
Returns the next random #gdouble from @rand_ equally distributed over
the range [0..1).


</description>
<parameters>
<parameter name="rand_">
<parameter_description> a #GRand.
</parameter_description>
</parameter>
</parameters>
<return> A random number.
</return>
</function>

<function name="g_dataset_foreach">
<description>
Calls the given function for each data element which is associated
with the given location. Note that this function is NOT thread-safe.
So unless @datalist can be protected from any modifications during
invocation of this function, it should not be called.

</description>
<parameters>
<parameter name="dataset_location">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each data element.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_is_container">
<description>
Determines if the given @type is a container type.

Container types are any array, maybe, tuple, or dictionary
entry types plus the variant type.

This function returns %TRUE for any indefinite type for which every
definite subtype is a container -- %G_VARIANT_TYPE_ARRAY, for
example.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is a container type
</return>
</function>

<function name="g_signal_emit_valist">
<description>
Emits a signal.

Note that g_signal_emit_valist() resets the return value to the default
if no handlers are connected, in contrast to g_signal_emitv().

</description>
<parameters>
<parameter name="instance">
<parameter_description> the instance the signal is being emitted on.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> the signal id
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> the detail
</parameter_description>
</parameter>
<parameter name="var_args">
<parameter_description> a list of parameters to be passed to the signal, followed by a
location for the return value. If the return type of the signal
is #G_TYPE_NONE, the return value location can be omitted.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ptr_array_ref">
<description>
Atomically increments the reference count of @array by one. This
function is MT-safe and may be called from any thread.

Since: 2.22

</description>
<parameters>
<parameter name="array">
<parameter_description> A #GArray.
</parameter_description>
</parameter>
</parameters>
<return> The passed in #GPtrArray.

</return>
</function>

<function name="g_bookmark_file_load_from_data_dirs">
<description>
This function looks for a desktop bookmark file named @file in the
paths returned from g_get_user_data_dir() and g_get_system_data_dirs(), 
loads the file into @bookmark and returns the file's full path in 
@full_path.  If the file could not be loaded then an %error is
set to either a #GFileError or #GBookmarkFileError.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="file">
<parameter_description> a relative path to a filename to open and parse
</parameter_description>
</parameter>
<parameter name="full_path">
<parameter_description> return location for a string containing the full path
of the file, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a key file could be loaded, %FALSE othewise

</return>
</function>

<function name="g_option_context_get_main_group">
<description>
Returns a pointer to the main group of @context.

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
</parameters>
<return> the main group of @context, or %NULL if @context doesn't
have a main group. Note that group belongs to @context and should
not be modified or freed.

</return>
</function>

<function name="g_ascii_strdown">
<description>
Converts all upper case ASCII letters to lower case ASCII letters.


</description>
<parameters>
<parameter name="str">
<parameter_description> a string.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> length of @str in bytes, or -1 if @str is nul-terminated.
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string, with all the upper case
characters in @str converted to lower case, with
semantics that exactly match g_ascii_tolower(). (Note
that this is unlike the old g_strdown(), which modified
the string in place.)
</return>
</function>

<function name="g_bookmark_file_get_groups">
<description>
Retrieves the list of group names of the bookmark for @uri.

In the event the URI cannot be found, %NULL is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

The returned array is %NULL terminated, so @length may optionally
be %NULL.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> return location for the length of the returned string, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated %NULL-terminated array of group names.
Use g_strfreev() to free it.

</return>
</function>

<function name="g_static_private_set">
<description>
Sets the pointer keyed to @private_key for the current thread and
the function @notify to be called with that pointer (%NULL or
non-%NULL), whenever the pointer is set again or whenever the
current thread ends.

This function works even if g_thread_init() has not yet been called.
If g_thread_init() is called later, the @data keyed to @private_key
will be inherited only by the main thread, i.e. the one that called
g_thread_init().

&lt;note&gt;&lt;para&gt;@notify is used quite differently from @destructor in
g_private_new().&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="private_key">
<parameter_description> a #GStaticPrivate.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the new pointer.
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description> a function to be called with the pointer whenever the
current thread ends or sets this pointer again.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_get_start_group">
<description>
Returns the name of the start group of the file. 

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
</parameters>
<return> The start group of the key file.

</return>
</function>

<function name="g_thread_pool_get_max_idle_time">
<description>
This function will return the maximum @interval that a thread will
wait in the thread pool for new tasks before being stopped.

If this function returns 0, threads waiting in the thread pool for
new work are not stopped.

Since: 2.10

</description>
<parameters>
</parameters>
<return> the maximum @interval to wait for new tasks in the
thread pool before stopping the thread (1/1000ths of a second).

</return>
</function>

<function name="g_string_erase">
<description>
Removes @len bytes from a #GString, starting at position @pos.
The rest of the #GString is shifted down to fill the gap.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="pos">
<parameter_description> the position of the content to remove
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the number of bytes to remove, or -1 to remove all
following bytes
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_type_set_qdata">
<description>
Attaches arbitrary data to a type.

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GType
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> a #GQuark id to identify the data
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_find_custom">
<description>
Finds an element in a #GSList, using a supplied function to 
find the desired element. It iterates over the list, calling 
the given function which should return 0 when the desired 
element is found. The function takes two #gconstpointer arguments, 
the #GSList element's data as the first argument and the 
given user data.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> user data passed to the function
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each element. 
It should return 0 when the desired element is found
</parameter_description>
</parameter>
</parameters>
<return> the found #GSList element, or %NULL if it is not found
</return>
</function>

<function name="g_get_user_data_dir">
<description>
Returns a base directory in which to access application data such
as icons that is customized for a particular user.  

On UNIX platforms this is determined using the mechanisms described in
the &lt;ulink url=&quot;http://www.freedesktop.org/Standards/basedir-spec&quot;&gt;
XDG Base Directory Specification&lt;/ulink&gt;.
In this case the directory retrieved will be XDG_DATA_HOME.

On Windows is the virtual folder that represents the My Documents
desktop item. See documentation for CSIDL_PERSONAL.

Since: 2.6

</description>
<parameters>
</parameters>
<return> a string owned by GLib that must not be modified 
or freed.
</return>
</function>

<function name="g_dgettext">
<description>
This function is a wrapper of dgettext() which does not translate
the message if the default domain as set with textdomain() has no
translations for the current locale.

The advantage of using this function over dgettext() proper is that
libraries using this function (like GTK+) will not use translations
if the application using the library does not have translations for
the current locale.  This results in a consistent English-only
interface instead of one having partial translations.  For this
feature to work, the call to textdomain() and setlocale() should
precede any g_dgettext() invocations.  For GTK+, it means calling
textdomain() before gtk_init or its variants.

This function disables translations if and only if upon its first
call all the following conditions hold:
&lt;itemizedlist&gt;
&lt;listitem&gt;@domain is not %NULL&lt;/listitem&gt;
&lt;listitem&gt;textdomain() has been called to set a default text domain&lt;/listitem&gt;
&lt;listitem&gt;there is no translations available for the default text domain
and the current locale&lt;/listitem&gt;
&lt;listitem&gt;current locale is not &quot;C&quot; or any English locales (those
starting with &quot;en_&quot;)&lt;/listitem&gt;
&lt;/itemizedlist&gt;

Note that this behavior may not be desired for example if an application
has its untranslated messages in a language other than English.  In those
cases the application should call textdomain() after initializing GTK+.

Applications should normally not use this function directly,
but use the _() macro for translations.

Since: 2.18

</description>
<parameters>
<parameter name="domain">
<parameter_description> the translation domain to use, or %NULL to use
the domain set with textdomain()
</parameter_description>
</parameter>
<parameter name="msgid">
<parameter_description> message to translate
</parameter_description>
</parameter>
</parameters>
<return> The translated string

</return>
</function>

<function name="g_ascii_strncasecmp">
<description>
Compare @s1 and @s2, ignoring the case of ASCII characters and any
characters after the first @n in each string.

Unlike the BSD strcasecmp() function, this only recognizes standard
ASCII letters and ignores the locale, treating all non-ASCII
characters as if they are not letters.

The same warning as in g_ascii_strcasecmp() applies: Use this
function only on strings known to be in encodings where bytes
corresponding to ASCII letters always represent themselves.


</description>
<parameters>
<parameter name="s1">
<parameter_description> string to compare with @s2.
</parameter_description>
</parameter>
<parameter name="s2">
<parameter_description> string to compare with @s1.
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description>  number of characters to compare.
</parameter_description>
</parameter>
</parameters>
<return> 0 if the strings match, a negative value if @s1 &lt; @s2, 
or a positive value if @s1 &gt; @s2.
</return>
</function>

<function name="g_hash_table_ref">
<description>
Atomically increments the reference count of @hash_table by one.
This function is MT-safe and may be called from any thread.

Since: 2.10

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a valid #GHashTable.
</parameter_description>
</parameter>
</parameters>
<return> the passed in #GHashTable.

</return>
</function>

<function name="g_main_loop_run">
<description>
Runs a main loop until g_main_loop_quit() is called on the loop.
If this is called for the thread of the loop's #GMainContext,
it will process events from the loop, otherwise it will
simply wait.

</description>
<parameters>
<parameter name="loop">
<parameter_description> a #GMainLoop
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_push_head_link">
<description>
Adds a new element at the head of the queue.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
<parameter name="link_">
<parameter_description> a single #GList element, &lt;emphasis&gt;not&lt;/emphasis&gt; a list with
more than one element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_strdown">
<description>
Converts a string to lower case.  

Deprecated:2.2: This function is totally broken for the reasons discussed 
in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown() 
instead.

</description>
<parameters>
<parameter name="string">
<parameter_description> the string to convert.
</parameter_description>
</parameter>
</parameters>
<return> the string 

</return>
</function>

<function name="g_queue_find_custom">
<description>
Finds an element in a #GQueue, using a supplied function to find the
desired element. It iterates over the queue, calling the given function
which should return 0 when the desired element is found. The function
takes two gconstpointer arguments, the #GQueue element's data as the
first argument and the given user data as the second argument.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> user data passed to @func
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> a #GCompareFunc to call for each element. It should return 0
when the desired element is found
</parameter_description>
</parameter>
</parameters>
<return> The found link, or %NULL if it wasn't found

</return>
</function>

<function name="g_option_group_set_error_hook">
<description>
Associates a function with @group which will be called 
from g_option_context_parse() when an error occurs.

Note that the user data to be passed to @error_func can be
specified when constructing the group with g_option_group_new().

Since: 2.6

</description>
<parameters>
<parameter name="group">
<parameter_description> a #GOptionGroup
</parameter_description>
</parameter>
<parameter name="error_func">
<parameter_description> a function to call when an error occurs
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_children">
<description>
Return a newly allocated and 0-terminated array of type IDs, listing the
child types of @type. The return value has to be g_free()ed after use.


</description>
<parameters>
<parameter name="type">
<parameter_description> The parent type.
</parameter_description>
</parameter>
<parameter name="n_children">
<parameter_description> Optional #guint pointer to contain the number of child types.
</parameter_description>
</parameter>
</parameters>
<return> Newly allocated and 0-terminated array of child types.
</return>
</function>

<function name="g_hash_table_iter_init">
<description>
Initializes a key/value pair iterator and associates it with
@hash_table. Modifying the hash table after calling this function
invalidates the returned iterator.
|[
GHashTableIter iter;
gpointer key, value;

g_hash_table_iter_init (&amp;iter, hash_table);
while (g_hash_table_iter_next (&amp;iter, &amp;key, &amp;value)) 
{
/ * do something with key and value * /
}
]|

Since: 2.16

</description>
<parameters>
<parameter name="iter">
<parameter_description> an uninitialized #GHashTableIter.
</parameter_description>
</parameter>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_pool_free">
<description>
Frees all resources allocated for @pool.

If @immediate is %TRUE, no new task is processed for
@pool. Otherwise @pool is not freed before the last task is
processed. Note however, that no thread of this pool is
interrupted, while processing a task. Instead at least all still
running threads can finish their tasks before the @pool is freed.

If @wait_ is %TRUE, the functions does not return before all tasks
to be processed (dependent on @immediate, whether all or only the
currently running) are ready. Otherwise the function returns immediately.

After calling this function @pool must not be used anymore. 

</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GThreadPool
</parameter_description>
</parameter>
<parameter name="immediate">
<parameter_description> should @pool shut down immediately?
</parameter_description>
</parameter>
<parameter name="wait_">
<parameter_description> should the function wait for all tasks to be finished?
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_flags_get_value_by_nick">
<description>
Looks up a #GFlagsValue by nickname.


</description>
<parameters>
<parameter name="flags_class">
<parameter_description> a #GFlagsClass
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> the nickname to look up
</parameter_description>
</parameter>
</parameters>
<return> the #GFlagsValue with nickname @nick, or %NULL if there is
no flag with that nickname
</return>
</function>

<function name="g_type_free_instance">
<description>
Frees an instance of a type, returning it to the instance pool for
the type, if there is one.

Like g_type_create_instance(), this function is reserved for
implementors of fundamental types.

</description>
<parameters>
<parameter name="instance">
<parameter_description> an instance of a type.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hash_table_lookup">
<description>
Looks up a key in a #GHashTable. Note that this function cannot
distinguish between a key that is not present and one which is present
and has the value %NULL. If you need this distinction, use
g_hash_table_lookup_extended().


</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the key to look up.
</parameter_description>
</parameter>
</parameters>
<return> the associated value, or %NULL if the key is not found.
</return>
</function>

<function name="g_path_get_basename">
<description>
Gets the last component of the filename. If @file_name ends with a 
directory separator it gets the component before the last slash. If 
@file_name consists only of directory separators (and on Windows, 
possibly a drive letter), a single separator is returned. If
@file_name is empty, it gets &quot;.&quot;.


</description>
<parameters>
<parameter name="file_name">
<parameter_description> the name of the file.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string containing the last component of 
the filename.
</return>
</function>

<function name="g_dataset_id_remove_no_notify">
<description>
Removes an element, without calling its destroy notification
function.

</description>
<parameters>
<parameter name="dataset_location">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="key_id">
<parameter_description> the #GQuark ID identifying the data element.
</parameter_description>
</parameter>
</parameters>
<return> the data previously stored at @key_id, or %NULL if none.
</return>
</function>

<function name="g_base64_encode">
<description>
Encode a sequence of binary data into its Base-64 stringified
representation.

Since: 2.12

</description>
<parameters>
<parameter name="data">
<parameter_description> the binary data to encode
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the length of @data
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated, zero-terminated Base-64 encoded
string representing @data. The returned string must 
be freed with g_free().

</return>
</function>

<function name="g_closure_new_object">
<description>
A variant of g_closure_new_simple() which stores @object in the
@data field of the closure and calls g_object_watch_closure() on
@object and the created closure. This function is mainly useful
when implementing new types of closures.


</description>
<parameters>
<parameter name="sizeof_closure">
<parameter_description> the size of the structure to allocate, must be at least
&lt;literal&gt;sizeof (GClosure)&lt;/literal&gt;
</parameter_description>
</parameter>
<parameter name="object">
<parameter_description> a #GObject pointer to store in the @data field of the newly
allocated #GClosure
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated #GClosure
</return>
</function>

<function name="g_string_chunk_insert">
<description>
Adds a copy of @string to the #GStringChunk.
It returns a pointer to the new copy of the string 
in the #GStringChunk. The characters in the string 
can be changed, if necessary, though you should not 
change anything after the end of the string.

Unlike g_string_chunk_insert_const(), this function 
does not check for duplicates. Also strings added 
with g_string_chunk_insert() will not be searched 
by g_string_chunk_insert_const() when looking for 
duplicates.


</description>
<parameters>
<parameter name="chunk">
<parameter_description> a #GStringChunk
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to add
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the copy of @string within 
the #GStringChunk
</return>
</function>

<function name="g_node_destroy">
<description>
Removes @root and its children from the tree, freeing any memory
allocated.

</description>
<parameters>
<parameter name="root">
<parameter_description> the root of the tree/subtree to destroy
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_mem_chunk_clean">
<description>
Frees any blocks in a #GMemChunk which are no longer being used.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
<parameter name="mem_chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_match_info_next">
<description>
Scans for the next match using the same parameters of the previous
call to g_regex_match_full() or g_regex_match() that returned
@match_info.

The match is done on the string passed to the match function, so you
cannot free it before calling this function.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> a #GMatchInfo structure
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore errors
</parameter_description>
</parameter>
</parameters>
<return> %TRUE is the string matched, %FALSE otherwise

</return>
</function>

<function name="g_find_program_in_path">
<description>
Locates the first executable named @program in the user's path, in the
same way that execvp() would locate it. Returns an allocated string
with the absolute path name, or %NULL if the program is not found in
the path. If @program is already an absolute path, returns a copy of
@program if @program exists and is executable, and %NULL otherwise.

On Windows, if @program does not have a file type suffix, tries
with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
the &lt;envar&gt;PATHEXT&lt;/envar&gt; environment variable. 

On Windows, it looks for the file in the same way as CreateProcess() 
would. This means first in the directory where the executing
program was loaded from, then in the current directory, then in the
Windows 32-bit system directory, then in the Windows directory, and
finally in the directories in the &lt;envar&gt;PATH&lt;/envar&gt; environment 
variable. If the program is found, the return value contains the 
full name including the type suffix.


</description>
<parameters>
<parameter name="program">
<parameter_description> a program name in the GLib file name encoding
</parameter_description>
</parameter>
</parameters>
<return> absolute path, or %NULL
</return>
</function>

<function name="g_markup_printf_escaped">
<description>
Formats arguments according to @format, escaping
all string and character arguments in the fashion
of g_markup_escape_text(). This is useful when you
want to insert literal strings into XML-style markup
output, without having to worry that the strings
might themselves contain markup.

|[
const char *store = &quot;Fortnum &amp; Mason&quot;;
const char *item = &quot;Tea&quot;;
char *output;
&#160;
output = g_markup_printf_escaped (&quot;&lt;purchase&gt;&quot;
&quot;&lt;store&gt;%s&lt;/store&gt;&quot;
&quot;&lt;item&gt;%s&lt;/item&gt;&quot;
&quot;&lt;/purchase&gt;&quot;,
store, item);
]|

Since: 2.4

</description>
<parameters>
<parameter name="format">
<parameter_description> printf() style format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the arguments to insert in the format string
</parameter_description>
</parameter>
</parameters>
<return> newly allocated result from formatting
operation. Free with g_free().

</return>
</function>

<function name="g_static_private_get">
<description>
Works like g_private_get() only for a #GStaticPrivate.

This function works even if g_thread_init() has not yet been called.

</description>
<parameters>
<parameter name="private_key">
<parameter_description> a #GStaticPrivate.
</parameter_description>
</parameter>
</parameters>
<return> the corresponding pointer.
</return>
</function>

<function name="g_param_spec_ulong">
<description>
Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_string_vprintf">
<description>
Writes a formatted string into a #GString. 
This function is similar to g_string_printf() except that 
the arguments to the format string are passed as a va_list.

Since: 2.14

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> the string format. See the printf() documentation
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> the parameters to insert into the format string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_listenv">
<description>
Gets the names of all variables set in the environment.

Since: 2.8

</description>
<parameters>
</parameters>
<return> a %NULL-terminated list of strings which must be freed
with g_strfreev().

Programs that want to be portable to Windows should typically use
this function and g_getenv() instead of using the environ array
from the C library directly. On Windows, the strings in the environ
array are in system codepage encoding, while in most of the typical
use cases for environment variables in GLib-using programs you want
the UTF-8 encoding that this function and g_getenv() provide.

</return>
</function>

<function name="g_sequence_set">
<description>
Changes the data for the item pointed to by @iter to be @data. If
the sequence has a data destroy function associated with it, that
function is called on the existing data that @iter pointed to.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> new data for the item
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_static_rec_mutex_init">
<description>
A #GStaticRecMutex must be initialized with this function before it
can be used. Alternatively you can initialize it with
#G_STATIC_REC_MUTEX_INIT.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticRecMutex to be initialized.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_random_int">
<description>
Return a random #guint32 equally distributed over the range
[0..2^32-1].


</description>
<parameters>
</parameters>
<return> A random number.
</return>
</function>

<function name="g_get_application_name">
<description>
Gets a human-readable name for the application, as set by
g_set_application_name(). This name should be localized if
possible, and is intended for display to the user.  Contrast with
g_get_prgname(), which gets a non-localized name. If
g_set_application_name() has not been called, returns the result of
g_get_prgname() (which may be %NULL if g_set_prgname() has also not
been called).

Since: 2.2

</description>
<parameters>
</parameters>
<return> human-readable application name. may return %NULL

</return>
</function>

<function name="g_sequence_get_length">
<description>
Returns the length of @seq

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
</parameters>
<return> the length of @seq

</return>
</function>

<function name="g_date_set_time">
<description>
Sets the value of a date from a #GTime value.
The time to date conversion is done using the user's current timezone.

Deprecated: 2.10: Use g_date_set_time_t() instead.

</description>
<parameters>
<parameter name="date">
<parameter_description> a #GDate.
</parameter_description>
</parameter>
<parameter name="time_">
<parameter_description> #GTime value to set.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_test_timer_elapsed">
<description>
Get the time since the last start of the timer with g_test_timer_start().

Since: 2.16

</description>
<parameters>
</parameters>
<return> the time since the last start of the timer, as a double

</return>
</function>

<function name="g_static_rw_lock_reader_lock">
<description>
Locks @lock for reading. There may be unlimited concurrent locks for
reading of a #GStaticRWLock at the same time.  If @lock is already
locked for writing by another thread or if another thread is already
waiting to lock @lock for writing, this function will block until
@lock is unlocked by the other writing thread and no other writing
threads want to lock @lock. This lock has to be unlocked by
g_static_rw_lock_reader_unlock().

#GStaticRWLock is not recursive. It might seem to be possible to
recursively lock for reading, but that can result in a deadlock, due
to writer preference.

</description>
<parameters>
<parameter name="lock">
<parameter_description> a #GStaticRWLock to lock for reading.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_markup_vprintf_escaped">
<description>
Formats the data in @args according to @format, escaping
all string and character arguments in the fashion
of g_markup_escape_text(). See g_markup_printf_escaped().

Since: 2.4

</description>
<parameters>
<parameter name="format">
<parameter_description> printf() style format string
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> variable argument list, similar to vprintf()
</parameter_description>
</parameter>
</parameters>
<return> newly allocated result from formatting
operation. Free with g_free().

</return>
</function>

<function name="g_param_spec_gtype">
<description>
Creates a new #GParamSpecGType instance specifying a
%G_TYPE_GTYPE property.

See g_param_spec_internal() for details on property names.

Since: 2.10


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="is_a_type">
<parameter_description> a #GType whose subtypes are allowed as values
of the property (use %G_TYPE_NONE for any type)
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_slist_copy">
<description>
Copies a #GSList.

&lt;note&gt;&lt;para&gt;
Note that this is a &quot;shallow&quot; copy. If the list elements 
consist of pointers to data, the pointers are copied but 
the actual data isn't.
&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
</parameters>
<return> a copy of @list
</return>
</function>

<function name="g_match_info_free">
<description>
Frees all the memory associated with the #GMatchInfo structure.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> a #GMatchInfo
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_dup_bytestring_array">
<description>
Gets the contents of an array of array of bytes #GVariant.  This call
makes a deep copy; the return result should be released with
g_strfreev().

If @length is non-%NULL then the number of elements in the result is
stored there.  In any case, the resulting array will be
%NULL-terminated.

For an empty array, @length will be set to 0 and a pointer to a
%NULL pointer will be returned.

Since: 2.26

</description>
<parameters>
<parameter name="value">
<parameter_description> an array of array of bytes #GVariant ('aay')
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of the result, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> an array of strings
</return>
</function>

<function name="g_variant_type_new_tuple">
<description>
Constructs a new tuple type, from @items.

@length is the number of items in @items, or -1 to indicate that
@items is %NULL-terminated.

It is appropriate to call g_variant_type_free() on the return value.

Since 2.24

</description>
<parameters>
<parameter name="items">
<parameter_description> an array of #GVariantTypes, one for each item
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of @items, or -1
</parameter_description>
</parameter>
</parameters>
<return> a new tuple #GVariantType
</return>
</function>

<function name="g_queue_peek_head">
<description>
Returns the first element of the queue.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
</parameters>
<return> the data of the first element in the queue, or %NULL if the queue
is empty.
</return>
</function>

<function name="g_get_system_data_dirs">
<description>
Returns an ordered list of base directories in which to access 
system-wide application data.

On UNIX platforms this is determined using the mechanisms described in
the &lt;ulink url=&quot;http://www.freedesktop.org/Standards/basedir-spec&quot;&gt;
XDG Base Directory Specification&lt;/ulink&gt;
In this case the list of directories retrieved will be XDG_DATA_DIRS.

On Windows the first elements in the list are the Application Data
and Documents folders for All Users. (These can be determined only
on Windows 2000 or later and are not present in the list on other
Windows versions.) See documentation for CSIDL_COMMON_APPDATA and
CSIDL_COMMON_DOCUMENTS.

Then follows the &quot;share&quot; subfolder in the installation folder for
the package containing the DLL that calls this function, if it can
be determined.

Finally the list contains the &quot;share&quot; subfolder in the installation
folder for GLib, and in the installation folder for the package the
application's .exe file belongs to.

The installation folders above are determined by looking up the
folder where the module (DLL or EXE) in question is located. If the
folder's name is &quot;bin&quot;, its parent is used, otherwise the folder
itself.

Note that on Windows the returned list can vary depending on where
this function is called.

Since: 2.6

</description>
<parameters>
</parameters>
<return> a %NULL-terminated array of strings owned by GLib that must 
not be modified or freed.
</return>
</function>

<function name="g_object_class_list_properties">
<description>
Get an array of #GParamSpec* for all properties of a class.


</description>
<parameters>
<parameter name="oclass">
<parameter_description> a #GObjectClass
</parameter_description>
</parameter>
<parameter name="n_properties">
<parameter_description> return location for the length of the returned array
</parameter_description>
</parameter>
</parameters>
<return> an array of #GParamSpec* which should be freed after use
</return>
</function>

<function name="g_cclosure_marshal_VOID__BOXED">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, GBoxed *arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #GBoxed* parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_pool_lookup">
<description>
Looks up a #GParamSpec in the pool.


</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GParamSpecPool
</parameter_description>
</parameter>
<parameter name="param_name">
<parameter_description> the name to look for
</parameter_description>
</parameter>
<parameter name="owner_type">
<parameter_description> the owner to look for
</parameter_description>
</parameter>
<parameter name="walk_ancestors">
<parameter_description> If %TRUE, also try to find a #GParamSpec with @param_name
owned by an ancestor of @owner_type.
</parameter_description>
</parameter>
</parameters>
<return> The found #GParamSpec, or %NULL if no matching #GParamSpec was found.
</return>
</function>

<function name="g_unichar_combining_class">
<description>
Determines the canonical combining class of a Unicode character.

Since: 2.14

</description>
<parameters>
<parameter name="uc">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> the combining class of the character

</return>
</function>

<function name="g_signal_query">
<description>
Queries the signal system for in-depth information about a
specific signal. This function will fill in a user-provided
structure to hold signal-specific information. If an invalid
signal id is passed in, the @signal_id member of the #GSignalQuery
is 0. All members filled into the #GSignalQuery structure should
be considered constant and have to be left untouched.

</description>
<parameters>
<parameter name="signal_id">
<parameter_description> The signal id of the signal to query information for.
</parameter_description>
</parameter>
<parameter name="query">
<parameter_description> A user provided structure that is filled in with constant
values upon success.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_push_nth">
<description>
Inserts a new element into @queue at the given position

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position to insert the new element. If @n is negative or
larger than the number of elements in the @queue, the element is
added to the end of the queue.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_insert_after">
<description>
Inserts @data into @queue after @sibling

@sibling must be part of @queue

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="sibling">
<parameter_description> a #GList link that &lt;emphasis&gt;must&lt;/emphasis&gt; be part of @queue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to insert
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_find">
<description>
Finds the element in a #GList which 
contains the given data.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the element data to find
</parameter_description>
</parameter>
</parameters>
<return> the found #GList element, 
or %NULL if it is not found
</return>
</function>

<function name="g_base64_encode_step">
<description>
Incrementally encode a sequence of binary data into its Base-64 stringified
representation. By calling this function multiple times you can convert 
data in chunks to avoid having to have the full encoded data in memory.

When all of the data has been converted you must call 
g_base64_encode_close() to flush the saved state.

The output buffer must be large enough to fit all the data that will
be written to it. Due to the way base64 encodes you will need
at least: (@len / 3 + 1) * 4 + 4 bytes (+ 4 may be needed in case of
non-zero state). If you enable line-breaking you will need at least:
((@len / 3 + 1) * 4 + 4) / 72 + 1 bytes of extra space.

@break_lines is typically used when putting base64-encoded data in emails.
It breaks the lines at 72 columns instead of putting all of the text on 
the same line. This avoids problems with long lines in the email system.

Since: 2.12

</description>
<parameters>
<parameter name="in">
<parameter_description> the binary data to encode
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the length of @in
</parameter_description>
</parameter>
<parameter name="break_lines">
<parameter_description> whether to break long lines
</parameter_description>
</parameter>
<parameter name="out">
<parameter_description> pointer to destination buffer
</parameter_description>
</parameter>
<parameter name="state">
<parameter_description> Saved state between steps, initialize to 0
</parameter_description>
</parameter>
<parameter name="save">
<parameter_description> Saved state between steps, initialize to 0
</parameter_description>
</parameter>
</parameters>
<return> The number of bytes of output that was written

</return>
</function>

<function name="g_slist_pop_allocator">
<description>
Restores the previous #GAllocator, used when allocating #GSList
elements.

Note that this function is not available if GLib has been compiled
with &lt;option&gt;--disable-mem-pools&lt;/option&gt;

Deprecated: 2.10: It does nothing, since #GSList has been converted
to the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt;

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_ptr_array_sort">
<description>
Sorts the array, using @compare_func which should be a qsort()-style
comparison function (returns less than zero for first arg is less
than second arg, zero for equal, greater than zero if irst arg is
greater than second arg).

If two array elements compare equal, their order in the sorted array
is undefined.

&lt;note&gt;&lt;para&gt;The comparison function for g_ptr_array_sort() doesn't
take the pointers from the array as arguments, it takes pointers to
the pointers in the array.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> comparison function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_mapped_file_ref">
<description>
Increments the reference count of @file by one.  It is safe to call
this function from any thread.

Since: 2.22

</description>
<parameters>
<parameter name="file">
<parameter_description> a #GMappedFile
</parameter_description>
</parameter>
</parameters>
<return> the passed in #GMappedFile.

</return>
</function>

<function name="g_slist_sort_with_data">
<description>
Like g_slist_sort(), but the sort function accepts a user data argument.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> comparison function
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> data to pass to comparison function
</parameter_description>
</parameter>
</parameters>
<return> new head of the list
</return>
</function>

<function name="g_strtod">
<description>
Converts a string to a #gdouble value.
It calls the standard strtod() function to handle the conversion, but
if the string is not completely converted it attempts the conversion
again with g_ascii_strtod(), and returns the best match.

This function should seldomly be used. The normal situation when reading
numbers not for human consumption is to use g_ascii_strtod(). Only when
you know that you must expect both locale formatted and C formatted numbers
should you use this. Make sure that you don't pass strings such as comma
separated lists of values, since the commas may be interpreted as a decimal
point in some locales, causing unexpected results.


</description>
<parameters>
<parameter name="nptr">
<parameter_description>    the string to convert to a numeric value.
</parameter_description>
</parameter>
<parameter name="endptr">
<parameter_description>  if non-%NULL, it returns the character after
the last character used in the conversion.
</parameter_description>
</parameter>
</parameters>
<return> the #gdouble value.
</return>
</function>

<function name="g_type_qname">
<description>
Get the corresponding quark of the type IDs name.


</description>
<parameters>
<parameter name="type">
<parameter_description> Type to return quark of type name for.
</parameter_description>
</parameter>
</parameters>
<return> The type names quark or 0.
</return>
</function>

<function name="g_variant_get_strv">
<description>
Gets the contents of an array of strings #GVariant.  This call
makes a shallow copy; the return result should be released with
g_free(), but the individual strings must not be modified.

If @length is non-%NULL then the number of elements in the result
is stored there.  In any case, the resulting array will be
%NULL-terminated.

For an empty array, @length will be set to 0 and a pointer to a
%NULL pointer will be returned.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> an array of strings #GVariant
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of the result, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> an array of constant
strings
</return>
</function>

<function name="g_param_spec_boxed">
<description>
Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED
derived property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="boxed_type">
<parameter_description> %G_TYPE_BOXED derived type of this property
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_key_file_get_locale_string">
<description>
Returns the value associated with @key under @group_name
translated in the given @locale if available.  If @locale is
%NULL then the current locale is assumed. 

If @key cannot be found then %NULL is returned and @error is set 
to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the value associated
with @key cannot be interpreted or no suitable translation can
be found then the untranslated value is returned.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="locale">
<parameter_description> a locale identifier or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string or %NULL if the specified 
key cannot be found.

</return>
</function>

<function name="g_param_spec_pointer">
<description>
Creates a new #GParamSpecPoiner instance specifying a pointer property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_int_hash">
<description>
Converts a pointer to a #gint to a hash value.
It can be passed to g_hash_table_new() as the @hash_func parameter, 
when using pointers to integers values as keys in a #GHashTable.


</description>
<parameters>
<parameter name="v">
<parameter_description> a pointer to a #gint key
</parameter_description>
</parameter>
</parameters>
<return> a hash value corresponding to the key.
</return>
</function>

<function name="g_strdup_vprintf">
<description>
Similar to the standard C vsprintf() function but safer, since it 
calculates the maximum space required and allocates memory to hold 
the result. The returned string should be freed with g_free() when 
no longer needed.

See also g_vasprintf(), which offers the same functionality, but 
additionally returns the length of the allocated string.


</description>
<parameters>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> the list of parameters to insert into the format string
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string holding the result
</return>
</function>

<function name="g_bookmark_file_remove_item">
<description>
Removes the bookmark for @uri from the bookmark file @bookmark.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the bookmark was removed successfully.

</return>
</function>

<function name="g_completion_complete_utf8">
<description>
Attempts to complete the string @prefix using the #GCompletion target items.
In contrast to g_completion_complete(), this function returns the largest common
prefix that is a valid UTF-8 string, omitting a possible common partial 
character.

You should use this function instead of g_completion_complete() if your 
items are UTF-8 strings.

Since: 2.4

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="cmp">
<parameter_description> the #GCompletion
</parameter_description>
</parameter>
<parameter name="prefix">
<parameter_description> the prefix string, typically used by the user, which is compared
with each of the items
</parameter_description>
</parameter>
<parameter name="new_prefix">
<parameter_description> if non-%NULL, returns the longest prefix which is common to all
items that matched @prefix, or %NULL if no items matched @prefix.
This string should be freed when no longer needed.
</parameter_description>
</parameter>
</parameters>
<return> the list of items whose strings begin with @prefix. This should
not be changed.

</return>
</function>

<function name="g_node_find">
<description>
Finds a #GNode in a tree.


</description>
<parameters>
<parameter name="root">
<parameter_description> the root #GNode of the tree to search
</parameter_description>
</parameter>
<parameter name="order">
<parameter_description> the order in which nodes are visited - %G_IN_ORDER, 
%G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> which types of children are to be searched, one of 
%G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to find
</parameter_description>
</parameter>
</parameters>
<return> the found #GNode, or %NULL if the data is not found
</return>
</function>

<function name="g_queue_push_nth_link">
<description>
Inserts @link into @queue at the given position.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position to insert the link. If this is negative or larger than
the number of elements in @queue, the link is added to the end of
@queue.
</parameter_description>
</parameter>
<parameter name="link_">
<parameter_description> the link to add to @queue
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_foreach">
<description>
Call @thread_func on all existing #GThread structures. Note that
threads may decide to exit while @thread_func is running, so
without intimate knowledge about the lifetime of foreign threads,
@thread_func shouldn't access the GThread* pointer passed in as
first argument. However, @thread_func will not be called for threads
which are known to have exited already.

Due to thread lifetime checks, this function has an execution complexity
which is quadratic in the number of existing threads.

Since: 2.10

</description>
<parameters>
<parameter name="thread_func">
<parameter_description> function to call for all GThread structures
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description>   second argument to @thread_func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_str_has_prefix">
<description>
Looks whether the string @str begins with @prefix.

Since: 2.2

</description>
<parameters>
<parameter name="str">
<parameter_description> a nul-terminated string.
</parameter_description>
</parameter>
<parameter name="prefix">
<parameter_description> the nul-terminated prefix to look for.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @str begins with @prefix, %FALSE otherwise.

</return>
</function>

<function name="g_queue_push_head">
<description>
Adds a new element at the head of the queue.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_get_prgname">
<description>
Gets the name of the program. This name should &lt;emphasis&gt;not&lt;/emphasis&gt; 
be localized, contrast with g_get_application_name().
(If you are using GDK or GTK+ the program name is set in gdk_init(), 
which is called by gtk_init(). The program name is found by taking 
the last component of &lt;literal&gt;argv[0]&lt;/literal&gt;.)


</description>
<parameters>
</parameters>
<return> the name of the program. The returned string belongs 
to GLib and must not be modified or freed.
</return>
</function>

<function name="g_sequence_iter_is_begin">
<description>
Returns whether @iter is the begin iterator

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return> whether @iter is the begin iterator

</return>
</function>

<function name="g_signal_override_class_handler">
<description>
Overrides the class closure (i.e. the default handler) for the
given signal for emissions on instances of @instance_type with
callabck @class_handler. @instance_type must be derived from the
type to which the signal belongs.

See g_signal_chain_from_overridden() and
g_signal_chain_from_overridden_handler() for how to chain up to the
parent class closure from inside the overridden one.

Since: 2.18

</description>
<parameters>
<parameter name="signal_name">
<parameter_description> the name for the signal
</parameter_description>
</parameter>
<parameter name="instance_type">
<parameter_description> the instance type on which to override the class handler
for the signal.
</parameter_description>
</parameter>
<parameter name="class_handler">
<parameter_description> the handler.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_pattern_match">
<description>
Matches a string against a compiled pattern. Passing the correct
length of the string given is mandatory. The reversed string can be
omitted by passing %NULL, this is more efficient if the reversed
version of the string to be matched is not at hand, as
g_pattern_match() will only construct it if the compiled pattern
requires reverse matches.

Note that, if the user code will (possibly) match a string against a
multitude of patterns containing wildcards, chances are high that
some patterns will require a reversed string. In this case, it's
more efficient to provide the reversed string to avoid multiple
constructions thereof in the various calls to g_pattern_match().

Note also that the reverse of a UTF-8 encoded string can in general
&lt;emphasis&gt;not&lt;/emphasis&gt; be obtained by g_strreverse(). This works
only if the string doesn't contain any multibyte characters. GLib
offers the g_utf8_strreverse() function to reverse UTF-8 encoded
strings.

</description>
<parameters>
<parameter name="pspec">
<parameter_description> a #GPatternSpec
</parameter_description>
</parameter>
<parameter name="string_length">
<parameter_description> the length of @string (in bytes, i.e. strlen(),
&lt;emphasis&gt;not&lt;/emphasis&gt; g_utf8_strlen())
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the UTF-8 encoded string to match
</parameter_description>
</parameter>
<parameter name="string_reversed">
<parameter_description> the reverse of @string or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @string matches @pspec
</return>
</function>

<function name="g_strnfill">
<description>
Creates a new string @length bytes long filled with @fill_char.
The returned string should be freed when no longer needed.


</description>
<parameters>
<parameter name="length">
<parameter_description> the length of the new string
</parameter_description>
</parameter>
<parameter name="fill_char">
<parameter_description> the byte to fill the string with
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string filled the @fill_char
</return>
</function>

<function name="g_build_filename">
<description>
Creates a filename from a series of elements using the correct
separator for filenames.

On Unix, this function behaves identically to &lt;literal&gt;g_build_path
(G_DIR_SEPARATOR_S, first_element, ....)&lt;/literal&gt;.

On Windows, it takes into account that either the backslash
(&lt;literal&gt;\&lt;/literal&gt; or slash (&lt;literal&gt;/&lt;/literal&gt;) can be used
as separator in filenames, but otherwise behaves as on Unix. When
file pathname separators need to be inserted, the one that last
previously occurred in the parameters (reading from left to right)
is used.

No attempt is made to force the resulting filename to be an absolute
path. If the first element is a relative path, the result will
be a relative path. 


</description>
<parameters>
<parameter name="first_element">
<parameter_description> the first element in the path
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> remaining elements in path, terminated by %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string that must be freed with g_free().
</return>
</function>

<function name="g_flags_get_first_value">
<description>
Returns the first #GFlagsValue which is set in @value.


</description>
<parameters>
<parameter name="flags_class">
<parameter_description> a #GFlagsClass
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> the value
</parameter_description>
</parameter>
</parameters>
<return> the first #GFlagsValue which is set in @value, or %NULL if
none is set
</return>
</function>

<function name="g_list_first">
<description>
Gets the first element in a #GList.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
</parameters>
<return> the first element in the #GList, 
or %NULL if the #GList has no elements
</return>
</function>

<function name="g_relation_delete">
<description>
Deletes any records from a #GRelation that have the given key value
in the given field.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="relation">
<parameter_description> a #GRelation.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the value to compare with.
</parameter_description>
</parameter>
<parameter name="field">
<parameter_description> the field of each record to match.
</parameter_description>
</parameter>
</parameters>
<return> the number of records deleted.
</return>
</function>

<function name="g_cache_remove">
<description>
Decreases the reference count of the given value. If it drops to 0
then the value and its corresponding key are destroyed, using the
@value_destroy_func and @key_destroy_func passed to g_cache_new().

</description>
<parameters>
<parameter name="cache">
<parameter_description> a #GCache.
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> the value to remove.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_write">
<description>
Writes data to a #GIOChannel. 

Deprecated:2.2: Use g_io_channel_write_chars() instead.

</description>
<parameters>
<parameter name="channel">
<parameter_description>  a #GIOChannel
</parameter_description>
</parameter>
<parameter name="buf">
<parameter_description> the buffer containing the data to write
</parameter_description>
</parameter>
<parameter name="count">
<parameter_description> the number of bytes to write
</parameter_description>
</parameter>
<parameter name="bytes_written">
<parameter_description> the number of bytes actually written
</parameter_description>
</parameter>
</parameters>
<return>  %G_IO_ERROR_NONE if the operation was successful.

</return>
</function>

<function name="g_key_file_load_from_data_dirs">
<description>
This function looks for a key file named @file in the paths 
returned from g_get_user_data_dir() and g_get_system_data_dirs(), 
loads the file into @key_file and returns the file's full path in 
@full_path.  If the file could not be loaded then an %error is
set to either a #GFileError or #GKeyFileError.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> an empty #GKeyFile struct
</parameter_description>
</parameter>
<parameter name="file">
<parameter_description> a relative path to a filename to open and parse
</parameter_description>
</parameter>
<parameter name="full_path">
<parameter_description> return location for a string containing the full path
of the file, or %NULL
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags from #GKeyFileFlags 
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a key file could be loaded, %FALSE othewise
</return>
</function>

<function name="g_test_bug">
<description>
This function adds a message to test reports that
associates a bug URI with a test case.
Bug URIs are constructed from a base URI set with g_test_bug_base()
and @bug_uri_snippet.

Since: 2.16

</description>
<parameters>
<parameter name="bug_uri_snippet">
<parameter_description> Bug specific bug tracker URI portion.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_dataset_id_remove_data">
<description>
Removes a data element from a dataset. The data element's destroy
function is called if it has been set.

</description>
<parameters>
<parameter name="l">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the #GQuark id identifying the data element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_string_hash">
<description>
Creates a hash code for @str; for use with #GHashTable.


</description>
<parameters>
<parameter name="str">
<parameter_description> a string to hash
</parameter_description>
</parameter>
</parameters>
<return> hash code for @str
</return>
</function>

<function name="g_vsprintf">
<description>
An implementation of the standard vsprintf() function which supports 
positional parameters, as specified in the Single Unix Specification.

Since: 2.2

</description>
<parameters>
<parameter name="string">
<parameter_description> the buffer to hold the output.
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice 
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;.
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> the list of arguments to insert in the output.
</parameter_description>
</parameter>
</parameters>
<return> the number of bytes printed.

</return>
</function>

<function name="g_async_queue_try_pop">
<description>
Tries to pop data from the @queue. If no data is available, %NULL is
returned.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return> data from the queue or %NULL, when no data is
available immediately.
</return>
</function>

<function name="g_value_take_param">
<description>
Sets the contents of a %G_TYPE_PARAM #GValue to @param and takes
over the ownership of the callers reference to @param; the caller
doesn't have to unref it any more.

Since: 2.4

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_PARAM
</parameter_description>
</parameter>
<parameter name="param">
<parameter_description> the #GParamSpec to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_read_line_string">
<description>
Reads a line from a #GIOChannel, using a #GString as a buffer.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="buffer">
<parameter_description> a #GString into which the line will be written.
If @buffer already contains data, the old data will
be overwritten.
</parameter_description>
</parameter>
<parameter name="terminator_pos">
<parameter_description> location to store position of line terminator, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> a location to store an error of type #GConvertError
or #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> the status of the operation.
</return>
</function>

<function name="g_set_error">
<description>
Does nothing if @err is %NULL; if @err is non-%NULL, then *@err
must be %NULL. A new #GError is created and assigned to *@err.

</description>
<parameters>
<parameter name="err">
<parameter_description> a return location for a #GError, or %NULL
</parameter_description>
</parameter>
<parameter name="domain">
<parameter_description> error domain
</parameter_description>
</parameter>
<parameter name="code">
<parameter_description> error code
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> printf()-style format
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> args for @format
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_peek_head_link">
<description>
Returns the first link in @queue

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
</parameters>
<return> the first link in @queue, or %NULL if @queue is empty

</return>
</function>

<function name="g_list_alloc">
<description>
Allocates space for one #GList element. It is called by
g_list_append(), g_list_prepend(), g_list_insert() and
g_list_insert_sorted() and so is rarely used on its own.

</description>
<parameters>
</parameters>
<return> a pointer to the newly-allocated #GList element.
</return>
</function>

<function name="g_slist_insert_before">
<description>
Inserts a node before @sibling containing @data. 


</description>
<parameters>
<parameter name="slist">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="sibling">
<parameter_description> node to insert @data before
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to put in the newly-inserted node
</parameter_description>
</parameter>
</parameters>
<return> the new head of the list.
</return>
</function>

<function name="g_mapped_file_free">
<description>
This call existed before #GMappedFile had refcounting and is currently
exactly the same as g_mapped_file_unref().

Since: 2.8
Deprecated:2.22: Use g_mapped_file_unref() instead.

</description>
<parameters>
<parameter name="file">
<parameter_description> a #GMappedFile
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_mem_chunk_destroy">
<description>
Frees all of the memory allocated for a #GMemChunk.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
<parameter name="mem_chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_iter_init">
<description>
Initialises (without allocating) a #GVariantIter.  @iter may be
completely uninitialised prior to this call; its old value is
ignored.

The iterator remains valid for as long as @value exists, and need not
be freed in any way.

Since: 2.24

</description>
<parameters>
<parameter name="iter">
<parameter_description> a pointer to a #GVariantIter
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> a container #GVariant
</parameter_description>
</parameter>
</parameters>
<return> the number of items in @value
</return>
</function>

<function name="g_cond_new">
<description>
Creates a new #GCond. This function will abort, if g_thread_init()
has not been called yet.

</description>
<parameters>
</parameters>
<return> a new #GCond.
</return>
</function>

<function name="g_array_prepend_val">
<description>
Adds the value on to the start of the array. The array will grow in
size automatically if necessary.

This operation is slower than g_array_append_val() since the
existing elements in the array have to be moved to make space for
the new element.

&lt;note&gt;&lt;para&gt;g_array_prepend_val() is a macro which uses a reference
to the value parameter @v. This means that you cannot use it with
literal values such as &quot;27&quot;. You must use variables.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="a">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="v">
<parameter_description> the value to prepend to the #GArray.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_bookmark_file_get_title">
<description>
Returns the title of the bookmark for @uri.

If @uri is %NULL, the title of @bookmark is returned.

In the event the URI cannot be found, %NULL is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string or %NULL if the specified
URI cannot be found.

</return>
</function>

<function name="g_option_group_free">
<description>
Frees a #GOptionGroup. Note that you must &lt;emphasis&gt;not&lt;/emphasis&gt;
free groups which have been added to a #GOptionContext.

Since: 2.6

</description>
<parameters>
<parameter name="group">
<parameter_description> a #GOptionGroup
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_set_param">
<description>
Set the contents of a %G_TYPE_PARAM #GValue to @param.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_PARAM
</parameter_description>
</parameter>
<parameter name="param">
<parameter_description> the #GParamSpec to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_pool_stop_unused_threads">
<description>
Stops all currently unused threads. This does not change the
maximal number of unused threads. This function can be used to
regularly stop all unused threads e.g. from g_timeout_add().

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_static_rw_lock_reader_unlock">
<description>
Unlocks @lock. If a thread waits to lock @lock for writing and all
locks for reading have been unlocked, the waiting thread is woken up
and can lock @lock for writing.

</description>
<parameters>
<parameter name="lock">
<parameter_description> a #GStaticRWLock to unlock after reading.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_source_get_priority">
<description>
Gets the priority of a source.


</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
</parameters>
<return> the priority of the source
</return>
</function>

<function name="g_signal_new_valist">
<description>
Creates a new signal. (This is usually done in the class initializer.)

See g_signal_new() for details on allowed signal names.


</description>
<parameters>
<parameter name="signal_name">
<parameter_description> the name for the signal
</parameter_description>
</parameter>
<parameter name="itype">
<parameter_description> the type this signal pertains to. It will also pertain to
types which are derived from this type.
</parameter_description>
</parameter>
<parameter name="signal_flags">
<parameter_description> a combination of #GSignalFlags specifying detail of when
the default handler is to be invoked. You should at least specify
%G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST.
</parameter_description>
</parameter>
<parameter name="class_closure">
<parameter_description> The closure to invoke on signal emission; may be %NULL.
</parameter_description>
</parameter>
<parameter name="accumulator">
<parameter_description> the accumulator for this signal; may be %NULL.
</parameter_description>
</parameter>
<parameter name="accu_data">
<parameter_description> user data for the @accumulator.
</parameter_description>
</parameter>
<parameter name="c_marshaller">
<parameter_description> the function to translate arrays of parameter values to
signal emissions into C language callback invocations.
</parameter_description>
</parameter>
<parameter name="return_type">
<parameter_description> the type of return value, or #G_TYPE_NONE for a signal
without a return value.
</parameter_description>
</parameter>
<parameter name="n_params">
<parameter_description> the number of parameter types in @args.
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> va_list of #GType, one for each parameter.
</parameter_description>
</parameter>
</parameters>
<return> the signal id
</return>
</function>

<function name="g_regex_replace_literal">
<description>
Replaces all occurrences of the pattern in @regex with the
replacement text. @replacement is replaced literally, to
include backreferences use g_regex_replace().

Setting @start_position differs from just passing over a
shortened string and setting #G_REGEX_MATCH_NOTBOL in the
case of a pattern that begins with any kind of lookbehind
assertion, such as &quot;\b&quot;.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to perform matches against
</parameter_description>
</parameter>
<parameter name="string_len">
<parameter_description> the length of @string, or -1 if @string is nul-terminated
</parameter_description>
</parameter>
<parameter name="start_position">
<parameter_description> starting index of the string to match
</parameter_description>
</parameter>
<parameter name="replacement">
<parameter_description> text to replace each match with
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> options for the match
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore errors
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string containing the replacements

</return>
</function>

<function name="g_variant_new_handle">
<description>
Creates a new handle #GVariant instance.

By convention, handles are indexes into an array of file descriptors
that are sent alongside a DBus message.  If you're not interacting
with DBus, you probably don't need them.

Since: 2.24

</description>
<parameters>
<parameter name="handle">
<parameter_description> a #gint32 value
</parameter_description>
</parameter>
</parameters>
<return> a new handle #GVariant instance
</return>
</function>

<function name="g_param_spec_pool_list_owned">
<description>
Gets an #GList of all #GParamSpec&lt;!-- --&gt;s owned by @owner_type in
the pool.


</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GParamSpecPool
</parameter_description>
</parameter>
<parameter name="owner_type">
<parameter_description> the owner to look for
</parameter_description>
</parameter>
</parameters>
<return> a #GList of all #GParamSpec&lt;!-- --&gt;s owned by @owner_type
in the pool#GParamSpec&lt;!-- --&gt;s.
</return>
</function>

<function name="g_variant_new_tuple">
<description>
Creates a new tuple #GVariant out of the items in @children.  The
type is determined from the types of @children.  No entry in the
@children array may be %NULL.

If @n_children is 0 then the unit tuple is constructed.

Since: 2.24

</description>
<parameters>
<parameter name="children">
<parameter_description> the items to make the tuple out of
</parameter_description>
</parameter>
<parameter name="n_children">
<parameter_description> the length of @children
</parameter_description>
</parameter>
</parameters>
<return> a new #GVariant tuple
</return>
</function>

<function name="glib_gettext">
<description>
Returns the translated string from the glib translations.
This is an internal function and should only be used by
the internals of glib (such as libgio).


</description>
<parameters>
<parameter name="str">
<parameter_description> The string to be translated
</parameter_description>
</parameter>
</parameters>
<return> the transation of @str to the current locale
</return>
</function>

<function name="g_variant_get_int32">
<description>
Returns the 32-bit signed integer value of @value.

It is an error to call this function with a @value of any type
other than %G_VARIANT_TYPE_INT32.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a int32 #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> a #gint32
</return>
</function>

<function name="g_variant_new_bytestring_array">
<description>
Constructs an array of bytestring #GVariant from the given array of
strings.

If @length is -1 then @strv is %NULL-terminated.

Since: 2.26

</description>
<parameters>
<parameter name="strv">
<parameter_description> an array of strings
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of @strv, or -1
</parameter_description>
</parameter>
</parameters>
<return> a new floating #GVariant instance
</return>
</function>

<function name="g_byte_array_sort_with_data">
<description>
Like g_byte_array_sort(), but the comparison function takes an extra
user data argument.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GByteArray.
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> comparison function.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> data to pass to @compare_func.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_enum_get_value_by_name">
<description>
Looks up a #GEnumValue by name.


</description>
<parameters>
<parameter name="enum_class">
<parameter_description> a #GEnumClass
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> the name to look up
</parameter_description>
</parameter>
</parameters>
<return> the #GEnumValue with name @name, or %NULL if the
enumeration doesn't have a member with that name
</return>
</function>

<function name="g_mkstemp">
<description>
Opens a temporary file. See the mkstemp() documentation
on most UNIX-like systems. 

The parameter is a string that should follow the rules for
mkstemp() templates, i.e. contain the string &quot;XXXXXX&quot;. 
g_mkstemp() is slightly more flexible than mkstemp()
in that the sequence does not have to occur at the very end of the 
template. The X string will 
be modified to form the name of a file that didn't exist.
The string should be in the GLib file name encoding. Most importantly, 
on Windows it should be in UTF-8.


</description>
<parameters>
<parameter name="tmpl">
<parameter_description> template filename
</parameter_description>
</parameter>
</parameters>
<return> A file handle (as from open()) to the file
opened for reading and writing. The file is opened in binary mode
on platforms where there is a difference. The file handle should be
closed with close(). In case of errors, -1 is returned.  
</return>
</function>

<function name="g_utf8_to_ucs4_fast">
<description>
Convert a string from UTF-8 to a 32-bit fixed width
representation as UCS-4, assuming valid UTF-8 input.
This function is roughly twice as fast as g_utf8_to_ucs4()
but does no error checking on the input.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length of @str to use, in bytes. If @len &lt; 0,
then the string is nul-terminated.
</parameter_description>
</parameter>
<parameter name="items_written">
<parameter_description> location to store the number of characters in the
result, or %NULL.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to a newly allocated UCS-4 string.
This value must be freed with g_free().
</return>
</function>

<function name="g_hash_table_replace">
<description>
Inserts a new key and value into a #GHashTable similar to
g_hash_table_insert(). The difference is that if the key already exists
in the #GHashTable, it gets replaced by the new key. If you supplied a
@value_destroy_func when creating the #GHashTable, the old value is freed
using that function. If you supplied a @key_destroy_func when creating the
#GHashTable, the old key is freed using that function.

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key to insert.
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> the value to associate with the key.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_module_add_interface">
<description>
Registers an additional interface for a type, whose interface lives
in the given type plugin. If the interface was already registered
for the type in this plugin, nothing will be done.

As long as any instances of the type exist, the type plugin will
not be unloaded.

</description>
<parameters>
<parameter name="module">
<parameter_description> a #GTypeModule
</parameter_description>
</parameter>
<parameter name="instance_type">
<parameter_description> type to which to add the interface.
</parameter_description>
</parameter>
<parameter name="interface_type">
<parameter_description> interface type to add
</parameter_description>
</parameter>
<parameter name="interface_info">
<parameter_description> type information structure
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_register_static">
<description>
Registers @type_name as the name of a new static type derived from
@parent_type.  The type system uses the information contained in the
#GTypeInfo structure pointed to by @info to manage the type and its
instances (if not abstract).  The value of @flags determines the nature
(e.g. abstract or not) of the type.


</description>
<parameters>
<parameter name="parent_type">
<parameter_description> Type from which this type will be derived.
</parameter_description>
</parameter>
<parameter name="type_name">
<parameter_description> 0-terminated string used as the name of the new type.
</parameter_description>
</parameter>
<parameter name="info">
<parameter_description> The #GTypeInfo structure for this type.
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> Bitwise combination of #GTypeFlags values.
</parameter_description>
</parameter>
</parameters>
<return> The new type identifier.
</return>
</function>

<function name="g_error_new_literal">
<description>
Creates a new #GError; unlike g_error_new(), @message is
not a printf()-style format string. Use this function if
@message contains text you don't have control over,
that could include printf() escape sequences.


</description>
<parameters>
<parameter name="domain">
<parameter_description> error domain
</parameter_description>
</parameter>
<parameter name="code">
<parameter_description> error code
</parameter_description>
</parameter>
<parameter name="message">
<parameter_description> error message
</parameter_description>
</parameter>
</parameters>
<return> a new #GError
</return>
</function>

<function name="g_slist_free1">
<description>
A macro which does the same as g_slist_free_1().

Since: 2.10

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_queue_link_index">
<description>
Returns the position of @link_ in @queue.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #Gqueue
</parameter_description>
</parameter>
<parameter name="link_">
<parameter_description> A #GList link
</parameter_description>
</parameter>
</parameters>
<return> The position of @link_, or -1 if the link is
not part of @queue

</return>
</function>

<function name="g_mutex_free">
<description>
Destroys @mutex.

&lt;note&gt;&lt;para&gt;Calling g_mutex_free() on a locked mutex may result in
undefined behaviour.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GMutex.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_yield">
<description>
Gives way to other threads waiting to be scheduled.

This function is often used as a method to make busy wait less evil.
But in most cases you will encounter, there are better methods to do
that. So in general you shouldn't use this function.

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_value_get_uint64">
<description>
Get the contents of a %G_TYPE_UINT64 #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_UINT64
</parameter_description>
</parameter>
</parameters>
<return> unsigned 64bit integer contents of @value
</return>
</function>

<function name="g_test_rand_double">
<description>
Get a reproducible random floating point number,
see g_test_rand_int() for details on test case random numbers.

Since: 2.16

</description>
<parameters>
</parameters>
<return> a random number from the seeded random number generator.

</return>
</function>

<function name="g_int64_equal">
<description>
Compares the two #gint64 values being pointed to and returns 
%TRUE if they are equal.
It can be passed to g_hash_table_new() as the @key_equal_func
parameter, when using pointers to 64-bit integers as keys in a #GHashTable.

Since: 2.22

</description>
<parameters>
<parameter name="v1">
<parameter_description> a pointer to a #gint64 key.
</parameter_description>
</parameter>
<parameter name="v2">
<parameter_description> a pointer to a #gint64 key to compare with @v1.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the two keys match.

</return>
</function>

<function name="g_option_group_add_entries">
<description>
Adds the options specified in @entries to @group.

Since: 2.6

</description>
<parameters>
<parameter name="group">
<parameter_description> a #GOptionGroup
</parameter_description>
</parameter>
<parameter name="entries">
<parameter_description> a %NULL-terminated array of #GOptionEntry&lt;!-- --&gt;s
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_byte_array_remove_index">
<description>
Removes the byte at the given index from a #GByteArray. The
following bytes are moved down one place.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GByteArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the byte to remove.
</parameter_description>
</parameter>
</parameters>
<return> the #GByteArray.
</return>
</function>

<function name="g_filename_to_utf8">
<description>
Converts a string which is in the encoding used by GLib for
filenames into a UTF-8 string. Note that on Windows GLib uses UTF-8
for filenames; on other platforms, this function indirectly depends on 
the &lt;link linkend=&quot;setlocale&quot;&gt;current locale&lt;/link&gt;.


</description>
<parameters>
<parameter name="opsysstring">
<parameter_description>   a string in the encoding for filenames
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description>           the length of the string, or -1 if the string is
nul-terminated&lt;footnoteref linkend=&quot;nul-unsafe&quot;/&gt;. 
</parameter_description>
</parameter>
<parameter name="bytes_read">
<parameter_description>    location to store the number of bytes in the
input string that were successfully converted, or %NULL.
Even if the conversion was successful, this may be 
less than @len if there were partial characters
at the end of the input. If the error
#G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
stored will the byte offset after the last valid
input sequence.
</parameter_description>
</parameter>
<parameter name="bytes_written">
<parameter_description> the number of bytes stored in the output buffer (not 
including the terminating nul).
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description>         location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError may occur.
</parameter_description>
</parameter>
</parameters>
<return> The converted string, or %NULL on an error.
</return>
</function>

<function name="g_strrstr">
<description>
Searches the string @haystack for the last occurrence
of the string @needle.


</description>
<parameters>
<parameter name="haystack">
<parameter_description> a nul-terminated string.
</parameter_description>
</parameter>
<parameter name="needle">
<parameter_description> the nul-terminated string to search for.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the found occurrence, or
%NULL if not found.
</return>
</function>

<function name="g_param_spec_ref">
<description>
Increments the reference count of @pspec.


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
</parameters>
<return> the #GParamSpec that was passed into this function
</return>
</function>

<function name="g_get_host_name">
<description>
Return a name for the machine. 

The returned name is not necessarily a fully-qualified domain name,
or even present in DNS or some other name service at all. It need
not even be unique on your local network or site, but usually it
is. Callers should not rely on the return value having any specific
properties like uniqueness for security purposes. Even if the name
of the machine is changed while an application is running, the
return value from this function does not change. The returned
string is owned by GLib and should not be modified or freed. If no
name can be determined, a default fixed string &quot;localhost&quot; is
returned.

Since: 2.8

</description>
<parameters>
</parameters>
<return> the host name of the machine.

</return>
</function>

<function name="g_date_set_time_t">
<description>
Sets the value of a date to the date corresponding to a time 
specified as a time_t. The time to date conversion is done using 
the user's current timezone.

To set the value of a date to the current day, you could write:
|[
g_date_set_time_t (date, time (NULL)); 
]|

Since: 2.10

</description>
<parameters>
<parameter name="date">
<parameter_description> a #GDate 
</parameter_description>
</parameter>
<parameter name="timet">
<parameter_description> &lt;type&gt;time_t&lt;/type&gt; value to set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hostname_is_non_ascii">
<description>
Tests if @hostname contains Unicode characters. If this returns
%TRUE, you need to encode the hostname with g_hostname_to_ascii()
before using it in non-IDN-aware contexts.

Note that a hostname might contain a mix of encoded and unencoded
segments, and so it is possible for g_hostname_is_non_ascii() and
g_hostname_is_ascii_encoded() to both return %TRUE for a name.

Since: 2.22

</description>
<parameters>
<parameter name="hostname">
<parameter_description> a hostname
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @hostname contains any non-ASCII characters

</return>
</function>

<function name="g_variant_get_size">
<description>
Determines the number of bytes that would be required to store @value
with g_variant_store().

If @value has a fixed-sized type then this function always returned
that fixed size.

In the case that @value is already in serialised form or the size has
already been calculated (ie: this function has been called before)
then this function is O(1).  Otherwise, the size is calculated, an
operation which is approximately O(n) in the number of values
involved.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> the serialised size of @value
</return>
</function>

<function name="g_static_rec_mutex_unlock">
<description>
Unlocks @mutex. Another thread will be allowed to lock @mutex only
when it has been unlocked as many times as it had been locked
before. If @mutex is completely unlocked and another thread is
blocked in a g_static_rec_mutex_lock() call for @mutex, it will be
woken and can lock @mutex itself.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticRecMutex to unlock.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_next">
<description>
A convenience macro to get the next element in a #GSList.

</description>
<parameters>
<parameter name="slist">
<parameter_description> an element in a #GSList.
</parameter_description>
</parameter>
</parameters>
<return> the next element, or %NULL if there are no more elements.
</return>
</function>

<function name="g_atomic_pointer_compare_and_exchange">
<description>
Compares @oldval with the pointer pointed to by @atomic and
if they are equal, atomically exchanges *@atomic with @newval.
Also acts as a memory barrier.

Since: 2.4

</description>
<parameters>
<parameter name="atomic">
<parameter_description> a pointer to a #gpointer
</parameter_description>
</parameter>
<parameter name="oldval">
<parameter_description> the assumed old value of *@atomic
</parameter_description>
</parameter>
<parameter name="newval">
<parameter_description> the new value of *@atomic
</parameter_description>
</parameter>
</parameters>
<return> %TRUE, if *@atomic was equal @oldval. %FALSE otherwise.

</return>
</function>

<function name="g_strndup">
<description>
Duplicates the first @n bytes of a string, returning a newly-allocated
buffer @n + 1 bytes long which will always be nul-terminated.
If @str is less than @n bytes long the buffer is padded with nuls.
If @str is %NULL it returns %NULL.
The returned value should be freed when no longer needed.

&lt;note&gt;&lt;para&gt;
To copy a number of characters from a UTF-8 encoded string, use
g_utf8_strncpy() instead.
&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="str">
<parameter_description> the string to duplicate
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the maximum number of bytes to copy from @str
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated buffer containing the first @n bytes 
of @str, nul-terminated 
</return>
</function>

<function name="g_param_spec_steal_qdata">
<description>
Gets back user data pointers stored via g_param_spec_set_qdata()
and removes the @data from @pspec without invoking its destroy()
function (if any was set).  Usually, calling this function is only
required to update user data pointers with a destroy notifier.


</description>
<parameters>
<parameter name="pspec">
<parameter_description> the #GParamSpec to get a stored user data pointer from
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> a #GQuark, naming the user data pointer
</parameter_description>
</parameter>
</parameters>
<return> the user data pointer set, or %NULL
</return>
</function>

<function name="g_relation_index">
<description>
Creates an index on the given field. Note that this must be called
before any records are added to the #GRelation.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="relation">
<parameter_description> a #GRelation.
</parameter_description>
</parameter>
<parameter name="field">
<parameter_description> the field to index, counting from 0.
</parameter_description>
</parameter>
<parameter name="hash_func">
<parameter_description> a function to produce a hash value from the field data.
</parameter_description>
</parameter>
<parameter name="key_equal_func">
<parameter_description> a function to compare two values of the given field.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_test_log_buffer_free">
<description>
Internal function for gtester to free test log messages, no ABI guarantees provided.

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_key_file_get_string">
<description>
Returns the string value associated with @key under @group_name.
Unlike g_key_file_get_value(), this function handles escape sequences
like \s.

In the event the key cannot be found, %NULL is returned and 
@error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the 
event that the @group_name cannot be found, %NULL is returned 
and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string or %NULL if the specified 
key cannot be found.

</return>
</function>

<function name="g_unsetenv">
<description>
Removes an environment variable from the environment.

Note that on some systems, when variables are overwritten, the memory 
used for the previous variables and its value isn't reclaimed.
Furthermore, this function can't be guaranteed to operate in a 
threadsafe way.

Since: 2.4 

</description>
<parameters>
<parameter name="variable">
<parameter_description> the environment variable to remove, must not contain '='.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_regex_match_all_full">
<description>
Using the standard algorithm for regular expression matching only
the longest match in the string is retrieved, it is not possibile
to obtain all the available matches. For instance matching
&quot;&lt;a&gt; &lt;b&gt; &lt;c&gt;&quot; against the pattern &quot;&lt;.*&gt;&quot;
you get &quot;&lt;a&gt; &lt;b&gt; &lt;c&gt;&quot;.

This function uses a different algorithm (called DFA, i.e. deterministic
finite automaton), so it can retrieve all the possible matches, all
starting at the same point in the string. For instance matching
&quot;&lt;a&gt; &lt;b&gt; &lt;c&gt;&quot; against the pattern &quot;&lt;.*&gt;&quot;
you would obtain three matches: &quot;&lt;a&gt; &lt;b&gt; &lt;c&gt;&quot;,
&quot;&lt;a&gt; &lt;b&gt;&quot; and &quot;&lt;a&gt;&quot;.

The number of matched strings is retrieved using
g_match_info_get_match_count(). To obtain the matched strings and
their position you can use, respectively, g_match_info_fetch() and
g_match_info_fetch_pos(). Note that the strings are returned in
reverse order of length; that is, the longest matching string is
given first.

Note that the DFA algorithm is slower than the standard one and it
is not able to capture substrings, so backreferences do not work.

Setting @start_position differs from just passing over a shortened
string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
that begins with any kind of lookbehind assertion, such as &quot;\b&quot;.

A #GMatchInfo structure, used to get information on the match, is
stored in @match_info if not %NULL. Note that if @match_info is
not %NULL then it is created even if the function returns %FALSE,
i.e. you must free it regardless if regular expression actually
matched.

@string is not copied and is used in #GMatchInfo internally. If
you use any #GMatchInfo method (except g_match_info_free()) after
freeing or modifying @string then the behaviour is undefined.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure from g_regex_new()
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to scan for matches
</parameter_description>
</parameter>
<parameter name="string_len">
<parameter_description> the length of @string, or -1 if @string is nul-terminated
</parameter_description>
</parameter>
<parameter name="start_position">
<parameter_description> starting index of the string to match
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> match options
</parameter_description>
</parameter>
<parameter name="match_info">
<parameter_description> pointer to location where to store
the #GMatchInfo, or %NULL if you do not need it
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore errors
</parameter_description>
</parameter>
</parameters>
<return> %TRUE is the string matched, %FALSE otherwise

</return>
</function>

<function name="g_get_real_name">
<description>
Gets the real name of the user. This usually comes from the user's entry 
in the &lt;filename&gt;passwd&lt;/filename&gt; file. The encoding of the returned 
string is system-defined. (On Windows, it is, however, always UTF-8.) 
If the real user name cannot be determined, the string &quot;Unknown&quot; is 
returned.


</description>
<parameters>
</parameters>
<return> the user's real name.
</return>
</function>

<function name="g_unichar_type">
<description>
Classifies a Unicode character by type.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> the type of the character.
</return>
</function>

<function name="g_key_file_set_value">
<description>
Associates a new value with @key under @group_name.  

If @key cannot be found then it is created. If @group_name cannot 
be found then it is created. To set an UTF-8 string which may contain 
characters that need escaping (such as newlines or spaces), use 
g_key_file_set_string().

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> a string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_depth">
<description>
Gets the depth of a #GNode.

If @node is %NULL the depth is 0. The root node has a depth of 1.
For the children of the root node the depth is 2. And so on.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
</parameters>
<return> the depth of the #GNode
</return>
</function>

<function name="g_value_dup_variant">
<description>
Get the contents of a variant #GValue, increasing its refcount.

Since: 2.26

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_VARIANT
</parameter_description>
</parameter>
</parameters>
<return> variant contents of @value, should be unrefed using
g_variant_unref() when no longer needed

</return>
</function>

<function name="g_value_get_long">
<description>
Get the contents of a %G_TYPE_LONG #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_LONG
</parameter_description>
</parameter>
</parameters>
<return> long integer contents of @value
</return>
</function>

<function name="g_async_queue_push_sorted_unlocked">
<description>
Inserts @data into @queue using @func to determine the new
position.

This function requires that the @queue is sorted before pushing on
new elements.

This function is called while holding the @queue's lock.

For an example of @func see g_async_queue_sort(). 

Since: 2.10

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the @data to push into the @queue
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the #GCompareDataFunc is used to sort @queue. This function
is passed two elements of the @queue. The function should return
0 if they are equal, a negative value if the first element
should be higher in the @queue or a positive value if the first
element should be lower in the @queue than the second element.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data passed to @func.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_init">
<description>
If you use GLib from more than one thread, you must initialize the
thread system by calling g_thread_init(). Most of the time you will
only have to call &lt;literal&gt;g_thread_init (NULL)&lt;/literal&gt;.

&lt;note&gt;&lt;para&gt;Do not call g_thread_init() with a non-%NULL parameter unless
you really know what you are doing.&lt;/para&gt;&lt;/note&gt;

&lt;note&gt;&lt;para&gt;g_thread_init() must not be called directly or indirectly as a
callback from GLib. Also no mutexes may be currently locked while
calling g_thread_init().&lt;/para&gt;&lt;/note&gt;

&lt;note&gt;&lt;para&gt;g_thread_init() changes the way in which #GTimer measures
elapsed time. As a consequence, timers that are running while
g_thread_init() is called may report unreliable times.&lt;/para&gt;&lt;/note&gt;

Calling g_thread_init() multiple times is allowed (since version
2.24), but nothing happens except for the first call. If the
argument is non-%NULL on such a call a warning will be printed, but
otherwise the argument is ignored.

If no thread system is available and @vtable is %NULL or if not all
elements of @vtable are non-%NULL, then g_thread_init() will abort.

&lt;note&gt;&lt;para&gt;To use g_thread_init() in your program, you have to link with
the libraries that the command &lt;command&gt;pkg-config --libs
gthread-2.0&lt;/command&gt; outputs. This is not the case for all the
other thread related functions of GLib. Those can be used without
having to link with the thread libraries.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="vtable">
<parameter_description> a function table of type #GThreadFunctions, that provides
the entry points to the thread system to be used.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_get_boolean">
<description>
Get the contents of a %G_TYPE_BOOLEAN #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_BOOLEAN
</parameter_description>
</parameter>
</parameters>
<return> boolean contents of @value
</return>
</function>

<function name="g_cclosure_marshal_VOID__VARIANT">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, GVariant *arg1, gpointer user_data)&lt;/literal&gt;.

Since: 2.26

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #GVariant* parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_free">
<description>
Frees a #GKeyFile.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_tree_traverse">
<description>
Calls the given function for each node in the #GTree. 

Deprecated:2.2: The order of a balanced tree is somewhat arbitrary. If you 
just want to visit all nodes in sorted order, use g_tree_foreach() 
instead. If you really need to visit nodes in a different order, consider
using an &lt;link linkend=&quot;glib-N-ary-Trees&quot;&gt;N-ary Tree&lt;/link&gt;.

</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
<parameter name="traverse_func">
<parameter_description> the function to call for each node visited. If this 
function returns %TRUE, the traversal is stopped.
</parameter_description>
</parameter>
<parameter name="traverse_type">
<parameter_description> the order in which nodes are visited, one of %G_IN_ORDER,
%G_PRE_ORDER and %G_POST_ORDER.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_once_init_enter">
<description>
Function to be called when starting a critical initialization
section. The argument @value_location must point to a static
0-initialized variable that will be set to a value other than 0 at
the end of the initialization section. In combination with
g_once_init_leave() and the unique address @value_location, it can
be ensured that an initialization section will be executed only once
during a program's life time, and that concurrent threads are
blocked until initialization completed. To be used in constructs
like this:

&lt;informalexample&gt;
&lt;programlisting&gt;
static gsize initialization_value = 0;

if (g_once_init_enter (&amp;initialization_value))
{
gsize setup_value = 42; /&lt;!-- --&gt;* initialization code here *&lt;!-- --&gt;/

g_once_init_leave (&amp;initialization_value, setup_value);
}

/&lt;!-- --&gt;* use initialization_value here *&lt;!-- --&gt;/
&lt;/programlisting&gt;
&lt;/informalexample&gt;

Since: 2.14

</description>
<parameters>
<parameter name="value_location">
<parameter_description> location of a static initializable variable
containing 0.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the initialization section should be entered,
%FALSE and blocks otherwise
</return>
</function>

<function name="g_value_array_prepend">
<description>
Insert a copy of @value as first element of @value_array. If @value is
%NULL, an uninitialized value is prepended.



</description>
<parameters>
<parameter name="value_array">
<parameter_description> #GValueArray to add an element to
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> #GValue to copy into #GValueArray, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> the #GValueArray passed in as @value_array
</return>
</function>

<function name="g_markup_parse_context_push">
<description>
Temporarily redirects markup data to a sub-parser.

This function may only be called from the start_element handler of
a #GMarkupParser.  It must be matched with a corresponding call to
g_markup_parse_context_pop() in the matching end_element handler
(except in the case that the parser aborts due to an error).

All tags, text and other data between the matching tags is
redirected to the subparser given by @parser.  @user_data is used
as the user_data for that parser.  @user_data is also passed to the
error callback in the event that an error occurs.  This includes
errors that occur in subparsers of the subparser.

The end tag matching the start tag for which this call was made is
handled by the previous parser (which is given its own user_data)
which is why g_markup_parse_context_pop() is provided to allow &quot;one
last access&quot; to the @user_data provided to this function.  In the
case of error, the @user_data provided here is passed directly to
the error callback of the subparser and g_markup_parse_context()
should not be called.  In either case, if @user_data was allocated
then it ought to be freed from both of these locations.

This function is not intended to be directly called by users
interested in invoking subparsers.  Instead, it is intended to be
used by the subparsers themselves to implement a higher-level
interface.

As an example, see the following implementation of a simple
parser that counts the number of tags encountered.

|[
typedef struct
{
gint tag_count;
} CounterData;

static void
counter_start_element (GMarkupParseContext  *context,
const gchar          *element_name,
const gchar         **attribute_names,
const gchar         **attribute_values,
gpointer              user_data,
GError              **error)
{
CounterData *data = user_data;

data-&gt;tag_count++;
}

static void
counter_error (GMarkupParseContext *context,
GError              *error,
gpointer             user_data)
{
CounterData *data = user_data;

g_slice_free (CounterData, data);
}

static GMarkupParser counter_subparser =
{
counter_start_element,
NULL,
NULL,
NULL,
counter_error
};
]|

In order to allow this parser to be easily used as a subparser, the
following interface is provided:

|[
void
start_counting (GMarkupParseContext *context)
{
CounterData *data = g_slice_new (CounterData);

data-&gt;tag_count = 0;
g_markup_parse_context_push (context, &amp;counter_subparser, data);
}

gint
end_counting (GMarkupParseContext *context)
{
CounterData *data = g_markup_parse_context_pop (context);
int result;

result = data-&gt;tag_count;
g_slice_free (CounterData, data);

return result;
}
]|

The subparser would then be used as follows:

|[
static void start_element (context, element_name, ...)
{
if (strcmp (element_name, &quot;count-these&quot;) == 0)
start_counting (context);

/ * else, handle other tags... * /
}

static void end_element (context, element_name, ...)
{
if (strcmp (element_name, &quot;count-these&quot;) == 0)
g_print (&quot;Counted %d tags\n&quot;, end_counting (context));

/ * else, handle other tags... * /
}
]|

Since: 2.18

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMarkupParseContext
</parameter_description>
</parameter>
<parameter name="parser">
<parameter_description> a #GMarkupParser
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to #GMarkupParser functions
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_get_filename_charsets">
<description>
Determines the preferred character sets used for filenames.
The first character set from the @charsets is the filename encoding, the
subsequent character sets are used when trying to generate a displayable
representation of a filename, see g_filename_display_name().

On Unix, the character sets are determined by consulting the
environment variables &lt;envar&gt;G_FILENAME_ENCODING&lt;/envar&gt; and
&lt;envar&gt;G_BROKEN_FILENAMES&lt;/envar&gt;. On Windows, the character set
used in the GLib API is always UTF-8 and said environment variables
have no effect.

&lt;envar&gt;G_FILENAME_ENCODING&lt;/envar&gt; may be set to a comma-separated list 
of character set names. The special token &quot;@locale&quot; is taken to 
mean the character set for the &lt;link linkend=&quot;setlocale&quot;&gt;current 
locale&lt;/link&gt;. If &lt;envar&gt;G_FILENAME_ENCODING&lt;/envar&gt; is not set, but 
&lt;envar&gt;G_BROKEN_FILENAMES&lt;/envar&gt; is, the character set of the current 
locale is taken as the filename encoding. If neither environment variable 
is set, UTF-8 is taken as the filename encoding, but the character
set of the current locale is also put in the list of encodings.

The returned @charsets belong to GLib and must not be freed.

Note that on Unix, regardless of the locale character set or
&lt;envar&gt;G_FILENAME_ENCODING&lt;/envar&gt; value, the actual file names present 
on a system might be in any random encoding or just gibberish.

Since: 2.6

</description>
<parameters>
<parameter name="charsets">
<parameter_description> return location for the %NULL-terminated list of encoding names
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the filename encoding is UTF-8.

</return>
</function>

<function name="g_queue_peek_tail_link">
<description>
Returns the last link @queue.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
</parameters>
<return> the last link in @queue, or %NULL if @queue is empty

</return>
</function>

<function name="g_param_spec_get_qdata">
<description>
Gets back user data pointers stored via g_param_spec_set_qdata().


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> a #GQuark, naming the user data pointer
</parameter_description>
</parameter>
</parameters>
<return> the user data pointer set, or %NULL
</return>
</function>

<function name="g_list_find_custom">
<description>
Finds an element in a #GList, using a supplied function to 
find the desired element. It iterates over the list, calling 
the given function which should return 0 when the desired 
element is found. The function takes two #gconstpointer arguments, 
the #GList element's data as the first argument and the 
given user data.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> user data passed to the function
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each element. 
It should return 0 when the desired element is found
</parameter_description>
</parameter>
</parameters>
<return> the found #GList element, or %NULL if it is not found
</return>
</function>

<function name="g_mem_chunk_reset">
<description>
Resets a GMemChunk to its initial state. It frees all of the
currently allocated blocks of memory.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
<parameter name="mem_chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_closure_add_invalidate_notifier">
<description>
Registers an invalidation notifier which will be called when the
@closure is invalidated with g_closure_invalidate(). Invalidation
notifiers are invoked before finalization notifiers, in an
unspecified order.

</description>
<parameters>
<parameter name="closure">
<parameter_description> a #GClosure
</parameter_description>
</parameter>
<parameter name="notify_data">
<parameter_description> data to pass to @notify_func
</parameter_description>
</parameter>
<parameter name="notify_func">
<parameter_description> the callback function to register
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_foreach">
<description>
Calls @func for each element in the queue passing @user_data to the
function.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each element's data
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to @func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_source_get_id">
<description>
Returns the numeric ID for a particular source. The ID of a source
is a positive integer which is unique within a particular main loop 
context. The reverse
mapping from ID to source is done by g_main_context_find_source_by_id().


</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) for the source
</return>
</function>

<function name="g_variant_new_variant">
<description>
Boxes @value.  The result is a #GVariant instance representing a
variant containing the original value.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariance instance
</parameter_description>
</parameter>
</parameters>
<return> a new variant #GVariant instance
</return>
</function>

<function name="g_cclosure_marshal_VOID__ENUM">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gint arg1, gpointer user_data)&lt;/literal&gt; where the #gint parameter denotes an enumeration type..

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the enumeration parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_load_from_data">
<description>
Loads a bookmark file from memory into an empty #GBookmarkFile
structure.  If the object cannot be created then @error is set to a
#GBookmarkFileError.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> an empty #GBookmarkFile struct
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> desktop bookmarks loaded in memory
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of @data in bytes
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a desktop bookmark could be loaded.

</return>
</function>

<function name="g_ptr_array_unref">
<description>
Atomically decrements the reference count of @array by one. If the
reference count drops to 0, the effect is the same as calling
g_ptr_array_free() with @free_segment set to %TRUE. This function
is MT-safe and may be called from any thread.

Since: 2.22

</description>
<parameters>
<parameter name="array">
<parameter_description> A #GPtrArray.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_getenv">
<description>
Returns the value of an environment variable. The name and value
are in the GLib file name encoding. On UNIX, this means the actual
bytes which might or might not be in some consistent character set
and encoding. On Windows, it is in UTF-8. On Windows, in case the
environment variable's value contains references to other
environment variables, they are expanded.


</description>
<parameters>
<parameter name="variable">
<parameter_description> the environment variable to get, in the GLib file name encoding.
</parameter_description>
</parameter>
</parameters>
<return> the value of the environment variable, or %NULL if
the environment variable is not found. The returned string may be
overwritten by the next call to g_getenv(), g_setenv() or
g_unsetenv().
</return>
</function>

<function name="g_signal_chain_from_overridden_handler">
<description>
Calls the original class closure of a signal. This function should
only be called from an overridden class closure; see
g_signal_override_class_closure() and
g_signal_override_class_handler().

Since: 2.18

</description>
<parameters>
<parameter name="instance">
<parameter_description> the instance the signal is being emitted on.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> parameters to be passed to the parent class closure, followed by a
location for the return value. If the return type of the signal
is #G_TYPE_NONE, the return value location can be omitted.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_pool_insert">
<description>
Inserts a #GParamSpec in the pool.

</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GParamSpecPool.
</parameter_description>
</parameter>
<parameter name="pspec">
<parameter_description> the #GParamSpec to insert
</parameter_description>
</parameter>
<parameter name="owner_type">
<parameter_description> a #GType identifying the owner of @pspec
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_register_static_simple">
<description>
Registers @type_name as the name of a new static type derived from
@parent_type.  The value of @flags determines the nature (e.g.
abstract or not) of the type. It works by filling a #GTypeInfo
struct and calling g_type_register_static().

Since: 2.12


</description>
<parameters>
<parameter name="parent_type">
<parameter_description> Type from which this type will be derived.
</parameter_description>
</parameter>
<parameter name="type_name">
<parameter_description> 0-terminated string used as the name of the new type.
</parameter_description>
</parameter>
<parameter name="class_size">
<parameter_description> Size of the class structure (see #GTypeInfo)
</parameter_description>
</parameter>
<parameter name="class_init">
<parameter_description> Location of the class initialization function (see #GTypeInfo)
</parameter_description>
</parameter>
<parameter name="instance_size">
<parameter_description> Size of the instance structure (see #GTypeInfo)
</parameter_description>
</parameter>
<parameter name="instance_init">
<parameter_description> Location of the instance initialization function (see #GTypeInfo)
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> Bitwise combination of #GTypeFlags values.
</parameter_description>
</parameter>
</parameters>
<return> The new type identifier.
</return>
</function>

<function name="g_variant_ref">
<description>
Increases the reference count of @value.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return> the same @value
</return>
</function>

<function name="g_signal_handler_disconnect">
<description>
Disconnects a handler from an instance so it will not be called during
any future or currently ongoing emissions of the signal it has been
connected to. The @handler_id becomes invalid and may be reused.

The @handler_id has to be a valid signal handler id, connected to a
signal of @instance.

</description>
<parameters>
<parameter name="instance">
<parameter_description> The instance to remove the signal handler from.
</parameter_description>
</parameter>
<parameter name="handler_id">
<parameter_description> Handler id of the handler to be disconnected.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_uri_unescape_segment">
<description>
Unescapes a segment of an escaped string.

If any of the characters in @illegal_characters or the character zero appears
as an escaped character in @escaped_string then that is an error and %NULL
will be returned. This is useful it you want to avoid for instance having a
slash being expanded in an escaped path element, which might confuse pathname
handling.

Since: 2.16

</description>
<parameters>
<parameter name="escaped_string">
<parameter_description> a string.
</parameter_description>
</parameter>
<parameter name="escaped_string_end">
<parameter_description> a string.
</parameter_description>
</parameter>
<parameter name="illegal_characters">
<parameter_description> an optional string of illegal characters not to be allowed.
</parameter_description>
</parameter>
</parameters>
<return> an unescaped version of @escaped_string or %NULL on error.
The returned string should be freed when no longer needed.

</return>
</function>

<function name="g_file_get_contents">
<description>
Reads an entire file into allocated memory, with good error
checking.

If the call was successful, it returns %TRUE and sets @contents to the file
contents and @length to the length of the file contents in bytes. The string
stored in @contents will be nul-terminated, so for text files you can pass
%NULL for the @length argument. If the call was not successful, it returns
%FALSE and sets @error. The error domain is #G_FILE_ERROR. Possible error
codes are those in the #GFileError enumeration. In the error case,
@contents is set to %NULL and @length is set to zero.


</description>
<parameters>
<parameter name="filename">
<parameter_description> name of a file to read contents from, in the GLib file name encoding
</parameter_description>
</parameter>
<parameter name="contents">
<parameter_description> location to store an allocated string, use g_free() to free
the returned string
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> location to store length in bytes of the contents, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success, %FALSE if an error occurred
</return>
</function>

<function name="g_key_file_set_uint64">
<description>
Associates a new integer value with @key under @group_name.
If @key cannot be found then it is created.

Since: 2.26

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> an integer value
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hash_table_iter_next">
<description>
Advances @iter and retrieves the key and/or value that are now
pointed to as a result of this advancement. If %FALSE is returned,
@key and @value are not set, and the iterator becomes invalid.

Since: 2.16

</description>
<parameters>
<parameter name="iter">
<parameter_description> an initialized #GHashTableIter.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a location to store the key, or %NULL.
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> a location to store the value, or %NULL.
</parameter_description>
</parameter>
</parameters>
<return> %FALSE if the end of the #GHashTable has been reached.

</return>
</function>

<function name="g_list_length">
<description>
Gets the number of elements in a #GList.

&lt;note&gt;&lt;para&gt;
This function iterates over the whole list to 
count its elements.
&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
</parameters>
<return> the number of elements in the #GList
</return>
</function>

<function name="g_test_add_func">
<description>
Create a new test case, similar to g_test_create_case(). However
the test is assumed to use no fixture, and test suites are automatically
created on the fly and added to the root fixture, based on the
slash-separated portions of @testpath.

Since: 2.16

</description>
<parameters>
<parameter name="testpath">
<parameter_description>   Slash-separated test case path name for the test.
</parameter_description>
</parameter>
<parameter name="test_func">
<parameter_description>  The test function to invoke for this test.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_remove_link">
<description>
Removes an element from a #GList, without freeing the element.
The removed element's prev and next links are set to %NULL, so 
that it becomes a self-contained list with one element.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="llink">
<parameter_description> an element in the #GList
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GList, without the element
</return>
</function>

<function name="g_param_spec_pool_remove">
<description>
Removes a #GParamSpec from the pool.

</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GParamSpecPool
</parameter_description>
</parameter>
<parameter name="pspec">
<parameter_description> the #GParamSpec to remove
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_unref">
<description>
Decrements the reference count of a @pspec.

</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_strjoin">
<description>
Joins a number of strings together to form one long string, with the 
optional @separator inserted between each of them. The returned string
should be freed with g_free().


</description>
<parameters>
<parameter name="separator">
<parameter_description> a string to insert between each of the strings, or %NULL
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> a %NULL-terminated list of strings to join
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string containing all of the strings joined
together, with @separator between them
</return>
</function>

<function name="g_io_channel_read">
<description>
Reads data from a #GIOChannel. 

Deprecated:2.2: Use g_io_channel_read_chars() instead.

</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="buf">
<parameter_description> a buffer to read the data into (which should be at least 
count bytes long)
</parameter_description>
</parameter>
<parameter name="count">
<parameter_description> the number of bytes to read from the #GIOChannel
</parameter_description>
</parameter>
<parameter name="bytes_read">
<parameter_description> returns the number of bytes actually read
</parameter_description>
</parameter>
</parameters>
<return> %G_IO_ERROR_NONE if the operation was successful. 

</return>
</function>

<function name="g_array_index">
<description>
Returns the element of a #GArray at the given index. The return
value is cast to the given type.

&lt;example&gt;
&lt;title&gt;Getting a pointer to an element in a #GArray&lt;/title&gt;
&lt;programlisting&gt;
EDayViewEvent *event;
/&lt;!-- --&gt;* This gets a pointer to the 4th element
in the array of EDayViewEvent structs. *&lt;!-- --&gt;/
event = &amp;g_array_index (events, EDayViewEvent, 3);
&lt;/programlisting&gt;
&lt;/example&gt;

</description>
<parameters>
<parameter name="a">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="t">
<parameter_description> the type of the elements.
</parameter_description>
</parameter>
<parameter name="i">
<parameter_description> the index of the element to return.
</parameter_description>
</parameter>
</parameters>
<return> the element of the #GArray at the index given by @i.
</return>
</function>

<function name="g_value_get_variant">
<description>
Get the contents of a variant #GValue.

Since: 2.26

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_VARIANT
</parameter_description>
</parameter>
</parameters>
<return> variant contents of @value

</return>
</function>

<function name="g_checksum_get_string">
<description>
Gets the digest as an hexadecimal string.

Once this function has been called the #GChecksum can no longer be
updated with g_checksum_update().

The hexadecimal characters will be lower case. 

Since: 2.16

</description>
<parameters>
<parameter name="checksum">
<parameter_description> a #GChecksum
</parameter_description>
</parameter>
</parameters>
<return> the hexadecimal representation of the checksum. The
returned string is owned by the checksum and should not be modified
or freed.

</return>
</function>

<function name="g_checksum_new">
<description>
Creates a new #GChecksum, using the checksum algorithm @checksum_type. 
If the @checksum_type is not known, %NULL is returned.
A #GChecksum can be used to compute the checksum, or digest, of an
arbitrary binary blob, using different hashing algorithms.

A #GChecksum works by feeding a binary blob through g_checksum_update()
until there is data to be checked; the digest can then be extracted
using g_checksum_get_string(), which will return the checksum as a
hexadecimal string; or g_checksum_get_digest(), which will return a
vector of raw bytes. Once either g_checksum_get_string() or
g_checksum_get_digest() have been called on a #GChecksum, the checksum
will be closed and it won't be possible to call g_checksum_update()
on it anymore.

Since: 2.16

</description>
<parameters>
<parameter name="checksum_type">
<parameter_description> the desired type of checksum
</parameter_description>
</parameter>
</parameters>
<return> the newly created #GChecksum, or %NULL. 
Use g_checksum_free() to free the memory allocated by it.

</return>
</function>

<function name="g_variant_new_array">
<description>
Creates a new #GVariant array from @children.

@child_type must be non-%NULL if @n_children is zero.  Otherwise, the
child type is determined by inspecting the first element of the
@children array.  If @child_type is non-%NULL then it must be a
definite type.

The items of the array are taken from the @children array.  No entry
in the @children array may be %NULL.

All items in the array must have the same type, which must be the
same as @child_type, if given.

Since: 2.24

</description>
<parameters>
<parameter name="child_type">
<parameter_description> the element type of the new array
</parameter_description>
</parameter>
<parameter name="children">
<parameter_description> an array of
#GVariant pointers, the children
</parameter_description>
</parameter>
<parameter name="n_children">
<parameter_description> the length of @children
</parameter_description>
</parameter>
</parameters>
<return> a new #GVariant array
</return>
</function>

<function name="g_object_run_dispose">
<description>
Releases all references to other objects. This can be used to break
reference cycles.

This functions should only be called from object system implementations.

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ascii_xdigit_value">
<description>
Determines the numeric value of a character as a hexidecimal
digit. Differs from g_unichar_xdigit_value() because it takes
a char, so there's no worry about sign extension if characters
are signed.


</description>
<parameters>
<parameter name="c">
<parameter_description> an ASCII character.
</parameter_description>
</parameter>
</parameters>
<return> If @c is a hex digit (according to
g_ascii_isxdigit()), its numeric value. Otherwise, -1.
</return>
</function>

<function name="g_dataset_id_set_data_full">
<description>
Sets the data element associated with the given #GQuark id, and also
the function to call when the data element is destroyed. Any
previous data with the same key is removed, and its destroy function
is called.

</description>
<parameters>
<parameter name="dataset_location">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="key_id">
<parameter_description> the #GQuark id to identify the data element.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data element.
</parameter_description>
</parameter>
<parameter name="destroy_func">
<parameter_description> the function to call when the data element is
removed. This function will be called with the data
element and can be used to free any memory allocated
for it.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_strconcat">
<description>
Concatenates all of the given strings into one long string.
The returned string should be freed with g_free() when no longer needed.

Note that this function is usually not the right function to use to
assemble a translated message from pieces, since proper translation
often requires the pieces to be reordered.

&lt;warning&gt;&lt;para&gt;The variable argument list &lt;emphasis&gt;must&lt;/emphasis&gt; end
with %NULL. If you forget the %NULL, g_strconcat() will start appending
random memory junk to your string.&lt;/para&gt;&lt;/warning&gt;


</description>
<parameters>
<parameter name="string1">
<parameter_description> the first string to add, which must not be %NULL
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> a %NULL-terminated list of strings to append to the string
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string containing all the string arguments
</return>
</function>

<function name="g_main_context_release">
<description>
Releases ownership of a context previously acquired by this thread
with g_main_context_acquire(). If the context was acquired multiple
times, the ownership will be released only when g_main_context_release()
is called as many times as it was acquired.

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_dngettext">
<description>
This function is a wrapper of dngettext() which does not translate
the message if the default domain as set with textdomain() has no
translations for the current locale.

See g_dgettext() for details of how this differs from dngettext()
proper.

Since: 2.18

</description>
<parameters>
<parameter name="domain">
<parameter_description> the translation domain to use, or %NULL to use
the domain set with textdomain()
</parameter_description>
</parameter>
<parameter name="msgid">
<parameter_description> message to translate
</parameter_description>
</parameter>
<parameter name="msgid_plural">
<parameter_description> plural form of the message
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the quantity for which translation is needed
</parameter_description>
</parameter>
</parameters>
<return> The translated string

</return>
</function>

<function name="g_strsignal">
<description>
Returns a string describing the given signal, e.g. &quot;Segmentation fault&quot;.
You should use this function in preference to strsignal(), because it 
returns a string in UTF-8 encoding, and since not all platforms support
the strsignal() function.


</description>
<parameters>
<parameter name="signum">
<parameter_description> the signal number. See the &lt;literal&gt;signal&lt;/literal&gt;
documentation
</parameter_description>
</parameter>
</parameters>
<return> a UTF-8 string describing the signal. If the signal is unknown,
it returns &quot;unknown signal (&lt;signum&gt;)&quot;. The string can only be 
used until the next call to g_strsignal()
</return>
</function>

<function name="g_list_sort">
<description>
Sorts a #GList using the given comparison function.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> the comparison function used to sort the #GList.
This function is passed the data from 2 elements of the #GList 
and should return 0 if they are equal, a negative value if the 
first element comes before the second, or a positive value if 
the first element comes after the second.
</parameter_description>
</parameter>
</parameters>
<return> the start of the sorted #GList
</return>
</function>

<function name="g_list_insert_sorted">
<description>
Inserts a new element into the list, using the given comparison 
function to determine its position.


</description>
<parameters>
<parameter name="list">
<parameter_description> a pointer to a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to compare elements in the list. It should 
return a number &gt; 0 if the first parameter comes after the 
second parameter in the sort order.
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GList
</return>
</function>

<function name="g_param_spec_unichar">
<description>
Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT
property. #GValue structures for this property can be accessed with
g_value_set_uint() and g_value_get_uint().

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_bookmark_file_set_mime_type">
<description>
Sets @mime_type as the MIME type of the bookmark for @uri.

If a bookmark for @uri cannot be found then it is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="mime_type">
<parameter_description> a MIME type
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_regex_match">
<description>
Scans for a match in string for the pattern in @regex.
The @match_options are combined with the match options specified
when the @regex structure was created, letting you have more
flexibility in reusing #GRegex structures.

A #GMatchInfo structure, used to get information on the match,
is stored in @match_info if not %NULL. Note that if @match_info
is not %NULL then it is created even if the function returns %FALSE,
i.e. you must free it regardless if regular expression actually matched.

To retrieve all the non-overlapping matches of the pattern in
string you can use g_match_info_next().

|[
static void
print_uppercase_words (const gchar *string)
{
/ * Print all uppercase-only words. * /
GRegex *regex;
GMatchInfo *match_info;
&#160;
regex = g_regex_new (&quot;[A-Z]+&quot;, 0, 0, NULL);
g_regex_match (regex, string, 0, &amp;match_info);
while (g_match_info_matches (match_info))
{
gchar *word = g_match_info_fetch (match_info, 0);
g_print (&quot;Found: %s\n&quot;, word);
g_free (word);
g_match_info_next (match_info, NULL);
}
g_match_info_free (match_info);
g_regex_unref (regex);
}
]|

@string is not copied and is used in #GMatchInfo internally. If
you use any #GMatchInfo method (except g_match_info_free()) after
freeing or modifying @string then the behaviour is undefined.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure from g_regex_new()
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to scan for matches
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> match options
</parameter_description>
</parameter>
<parameter name="match_info">
<parameter_description> pointer to location where to store
the #GMatchInfo, or %NULL if you do not need it
</parameter_description>
</parameter>
</parameters>
<return> %TRUE is the string matched, %FALSE otherwise

</return>
</function>

<function name="g_key_file_remove_comment">
<description>
Removes a comment above @key from @group_name.
If @key is %NULL then @comment will be removed above @group_name. 
If both @key and @group_name are %NULL, then @comment will
be removed above the first group in the file.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name, or %NULL
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the comment was removed, %FALSE otherwise

</return>
</function>

<function name="g_unichar_isgraph">
<description>
Determines whether a character is printable and not a space
(returns %FALSE for control characters, format characters, and
spaces). g_unichar_isprint() is similar, but returns %TRUE for
spaces. Given some UTF-8 text, obtain a character value with
g_utf8_get_char().


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is printable unless it's a space
</return>
</function>

<function name="g_node_unlink">
<description>
Unlinks a #GNode from a tree, resulting in two separate trees.

</description>
<parameters>
<parameter name="node">
<parameter_description> the #GNode to unlink, which becomes the root of a new tree
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_unichar_ismark">
<description>
Determines whether a character is a mark (non-spacing mark,
combining mark, or enclosing mark in Unicode speak).
Given some UTF-8 text, obtain a character value
with g_utf8_get_char().

Note: in most cases where isalpha characters are allowed,
ismark characters should be allowed to as they are essential
for writing most European languages as well as many non-Latin
scripts.

Since: 2.14

</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is a mark character

</return>
</function>

<function name="g_node_last_child">
<description>
Gets the last child of a #GNode.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode (must not be %NULL)
</parameter_description>
</parameter>
</parameters>
<return> the last child of @node, or %NULL if @node has no children
</return>
</function>

<function name="g_bookmark_file_get_app_info">
<description>
Gets the registration informations of @app_name for the bookmark for
@uri.  See g_bookmark_file_set_app_info() for more informations about
the returned data.

The string returned in @app_exec must be freed.

In the event the URI cannot be found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
event that no application with name @app_name has registered a bookmark
for @uri,  %FALSE is returned and error is set to
#G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting
the command line fails, an error of the #G_SHELL_ERROR domain is
set and %FALSE is returned.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> an application's name
</parameter_description>
</parameter>
<parameter name="exec">
<parameter_description> location for the command line of the application, or %NULL
</parameter_description>
</parameter>
<parameter name="count">
<parameter_description> return location for the registration count, or %NULL
</parameter_description>
</parameter>
<parameter name="stamp">
<parameter_description> return location for the last registration time, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success.

</return>
</function>

<function name="g_unichar_ispunct">
<description>
Determines whether a character is punctuation or a symbol.
Given some UTF-8 text, obtain a character value with
g_utf8_get_char().


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is a punctuation or symbol character
</return>
</function>

<function name="g_object_bind_property_with_closures">
<description>
Creates a binding between @source_property on @source and @target_property
on @target, allowing you to set the transformation functions to be used by
the binding.

This function is the language bindings friendly version of
g_object_bind_property_full(), using #GClosure&lt;!-- --&gt;s instead of
function pointers.

Since: 2.26

</description>
<parameters>
<parameter name="source">
<parameter_description> the source #GObject
</parameter_description>
</parameter>
<parameter name="source_property">
<parameter_description> the property on @source to bind
</parameter_description>
</parameter>
<parameter name="target">
<parameter_description> the target #GObject
</parameter_description>
</parameter>
<parameter name="target_property">
<parameter_description> the property on @target to bind
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags to pass to #GBinding
</parameter_description>
</parameter>
<parameter name="transform_to">
<parameter_description> a #GClosure wrapping the transformation function
from the @source to the @target, or %NULL to use the default
</parameter_description>
</parameter>
<parameter name="transform_from">
<parameter_description> a #GClosure wrapping the transformation function
from the @target to the @source, or %NULL to use the default
</parameter_description>
</parameter>
</parameters>
<return> the #GBinding instance representing the
binding between the two #GObject instances. The binding is released
whenever the #GBinding reference count reaches zero.

</return>
</function>

<function name="g_completion_add_items">
<description>
Adds items to the #GCompletion.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="cmp">
<parameter_description> the #GCompletion.
</parameter_description>
</parameter>
<parameter name="items">
<parameter_description> the list of items to add.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_vprintf">
<description>
An implementation of the standard vprintf() function which supports 
positional parameters, as specified in the Single Unix Specification.

Since: 2.2

</description>
<parameters>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice 
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;.
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> the list of arguments to insert in the output.
</parameter_description>
</parameter>
</parameters>
<return> the number of bytes printed.

</return>
</function>

<function name="g_bookmark_file_has_group">
<description>
Checks whether @group appears in the list of groups to which
the bookmark for @uri belongs to.

In the event the URI cannot be found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="group">
<parameter_description> the group name to be searched
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @group was found.

</return>
</function>

<function name="g_dataset_get_data">
<description>
Gets the data element corresponding to a string.

</description>
<parameters>
<parameter name="l">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string identifying the data element.
</parameter_description>
</parameter>
</parameters>
<return> the data element corresponding to the string, or %NULL if
it is not found.
</return>
</function>

<function name="g_cclosure_marshal_STRING__OBJECT_POINTER">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;gchar* (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> a #GValue, which can store the returned string
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 3
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding instance, arg1 and arg2
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_set_param_take_ownership">
<description>
This is an internal function introduced mainly for C marshallers.

Deprecated: 2.4: Use g_value_take_param() instead.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_PARAM
</parameter_description>
</parameter>
<parameter name="param">
<parameter_description> the #GParamSpec to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_rand_new">
<description>
Creates a new random number generator initialized with a seed taken
either from &lt;filename&gt;/dev/urandom&lt;/filename&gt; (if existing) or from 
the current time (as a fallback).


</description>
<parameters>
</parameters>
<return> the new #GRand.
</return>
</function>

<function name="g_static_rw_lock_free">
<description>
Releases all resources allocated to @lock.

You don't have to call this functions for a #GStaticRWLock with an
unbounded lifetime, i.e. objects declared 'static', but if you have
a #GStaticRWLock as a member of a structure, and the structure is
freed, you should also free the #GStaticRWLock.

</description>
<parameters>
<parameter name="lock">
<parameter_description> a #GStaticRWLock to be freed.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hash_table_find">
<description>
Calls the given function for key/value pairs in the #GHashTable until
@predicate returns %TRUE.  The function is passed the key and value of
each pair, and the given @user_data parameter. The hash table may not
be modified while iterating over it (you can't add/remove items).

Note, that hash tables are really only optimized for forward lookups,
i.e. g_hash_table_lookup().
So code that frequently issues g_hash_table_find() or
g_hash_table_foreach() (e.g. in the order of once per every entry in a
hash table) should probably be reworked to use additional or different
data structures for reverse lookups (keep in mind that an O(n) find/foreach
operation issued for all n values in a hash table ends up needing O(n*n)
operations).

Since: 2.4

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
<parameter name="predicate">
<parameter_description>  function to test the key/value pairs for a certain property.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description>  user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return> The value of the first key/value pair is returned, for which
func evaluates to %TRUE. If no pair with the requested property is found,
%NULL is returned.

</return>
</function>

<function name="g_object_new">
<description>
Creates a new instance of a #GObject subtype and sets its properties.

Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY)
which are not explicitly specified are set to their default values.


</description>
<parameters>
<parameter name="object_type">
<parameter_description> the type id of the #GObject subtype to instantiate
</parameter_description>
</parameter>
<parameter name="first_property_name">
<parameter_description> the name of the first property
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the value of the first property, followed optionally by more
name/value pairs, followed by %NULL
</parameter_description>
</parameter>
</parameters>
<return> a new instance of @object_type
</return>
</function>

<function name="g_flags_get_value_by_name">
<description>
Looks up a #GFlagsValue by name.


</description>
<parameters>
<parameter name="flags_class">
<parameter_description> a #GFlagsClass
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> the name to look up
</parameter_description>
</parameter>
</parameters>
<return> the #GFlagsValue with name @name, or %NULL if there is no
flag with that name
</return>
</function>

<function name="g_cclosure_new_object">
<description>
A variant of g_cclosure_new() which uses @object as @user_data and
calls g_object_watch_closure() on @object and the created
closure. This function is useful when you have a callback closely
associated with a #GObject, and want the callback to no longer run
after the object is is freed.


</description>
<parameters>
<parameter name="callback_func">
<parameter_description> the function to invoke
</parameter_description>
</parameter>
<parameter name="object">
<parameter_description> a #GObject pointer to pass to @callback_func
</parameter_description>
</parameter>
</parameters>
<return> a new #GCClosure
</return>
</function>

<function name="g_static_mutex_free">
<description>
Releases all resources allocated to @mutex.

You don't have to call this functions for a #GStaticMutex with an
unbounded lifetime, i.e. objects declared 'static', but if you have
a #GStaticMutex as a member of a structure and the structure is
freed, you should also free the #GStaticMutex.

&lt;note&gt;&lt;para&gt;Calling g_static_mutex_free() on a locked mutex may
result in undefined behaviour.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticMutex to be freed.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_win32_new_fd">
<description>
Creates a new #GIOChannel given a file descriptor on Windows. This
works for file descriptors from the C runtime.

This function works for file descriptors as returned by the open(),
creat(), pipe() and fileno() calls in the Microsoft C runtime. In
order to meaningfully use this function your code should use the
same C runtime as GLib uses, which is msvcrt.dll. Note that in
current Microsoft compilers it is near impossible to convince it to
build code that would use msvcrt.dll. The last Microsoft compiler
version that supported using msvcrt.dll as the C runtime was version
6. The GNU compiler and toolchain for Windows, also known as Mingw,
fully supports msvcrt.dll.

If you have created a #GIOChannel for a file descriptor and started
watching (polling) it, you shouldn't call read() on the file
descriptor. This is because adding polling for a file descriptor is
implemented in GLib on Windows by starting a thread that sits
blocked in a read() from the file descriptor most of the time. All
reads from the file descriptor should be done by this internal GLib
thread. Your code should call only g_io_channel_read().

This function is available only in GLib on Windows.

</description>
<parameters>
<parameter name="fd">
<parameter_description> a C library file descriptor.
</parameter_description>
</parameter>
</parameters>
<return> a new #GIOChannel.
</return>
</function>

<function name="g_utf8_strchr">
<description>
Finds the leftmost occurrence of the given Unicode character
in a UTF-8 encoded string, while limiting the search to @len bytes.
If @len is -1, allow unbounded search.


</description>
<parameters>
<parameter name="p">
<parameter_description> a nul-terminated UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length of @p
</parameter_description>
</parameter>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %NULL if the string does not contain the character, 
otherwise, a pointer to the start of the leftmost occurrence of 
the character in the string.
</return>
</function>

<function name="g_key_file_get_string_list">
<description>
Returns the values associated with @key under @group_name.

In the event the key cannot be found, %NULL is returned and
@error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
event that the @group_name cannot be found, %NULL is returned
and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> return location for the number of returned strings, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a %NULL-terminated string array or %NULL if the specified 
key cannot be found. The array should be freed with g_strfreev().

</return>
</function>

<function name="g_regex_unref">
<description>
Decreases reference count of @regex by 1. When reference count drops
to zero, it frees all the memory associated with the regex structure.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_dup_string">
<description>
Get a copy the contents of a %G_TYPE_STRING #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_STRING
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated copy of the string content of @value
</return>
</function>

<function name="g_shell_parse_argv">
<description>
Parses a command line into an argument vector, in much the same way
the shell would, but without many of the expansions the shell would
perform (variable expansion, globs, operators, filename expansion,
etc. are not supported). The results are defined to be the same as
those you would get from a UNIX98 /bin/sh, as long as the input
contains none of the unsupported shell expansions. If the input
does contain such expansions, they are passed through
literally. Possible errors are those from the #G_SHELL_ERROR
domain. Free the returned vector with g_strfreev().


</description>
<parameters>
<parameter name="command_line">
<parameter_description> command line to parse
</parameter_description>
</parameter>
<parameter name="argcp">
<parameter_description> return location for number of args
</parameter_description>
</parameter>
<parameter name="argvp">
<parameter_description> return location for array of args
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for error
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success, %FALSE if error set
</return>
</function>

<function name="g_value_set_boxed">
<description>
Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_BOXED derived type
</parameter_description>
</parameter>
<parameter name="v_boxed">
<parameter_description> boxed value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_set_priority">
<description>
Changes the priority of @thread to @priority.

&lt;note&gt;&lt;para&gt;It is not guaranteed that threads with different
priorities really behave accordingly. On some systems (e.g. Linux)
there are no thread priorities. On other systems (e.g. Solaris) there
doesn't seem to be different scheduling for different priorities. All
in all try to avoid being dependent on priorities.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="thread">
<parameter_description> a #GThread.
</parameter_description>
</parameter>
<parameter name="priority">
<parameter_description> a new priority for @thread.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_iconv_close">
<description>
Same as the standard UNIX routine iconv_close(), but
may be implemented via libiconv on UNIX flavors that lack
a native implementation. Should be called to clean up
the conversion descriptor from g_iconv_open() when
you are done converting things.

GLib provides g_convert() and g_locale_to_utf8() which are likely
more convenient than the raw iconv wrappers.


</description>
<parameters>
<parameter name="converter">
<parameter_description> a conversion descriptor from g_iconv_open()
</parameter_description>
</parameter>
</parameters>
<return> -1 on error, 0 on success
</return>
</function>

<function name="g_async_queue_ref_unlocked">
<description>
Increases the reference count of the asynchronous @queue by 1.

@Deprecated: Since 2.8, reference counting is done atomically
so g_async_queue_ref() can be used regardless of the @queue's
lock.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_sort_with_data">
<description>
Like g_list_sort(), but the comparison function accepts 
a user data argument.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> comparison function
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to comparison function
</parameter_description>
</parameter>
</parameters>
<return> the new head of @list
</return>
</function>

<function name="g_object_bind_property">
<description>
Creates a binding between @source_property on @source and @target_property
on @target. Whenever the @source_property is changed the @target_property is
updated using the same value. For instance:

|[
g_object_bind_property (action, &quot;active&quot;, widget, &quot;sensitive&quot;, 0);
]|

Will result in the &quot;sensitive&quot; property of the widget #GObject instance to be
updated with the same value of the &quot;active&quot; property of the action #GObject
instance.

If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
if @target_property on @target changes then the @source_property on @source
will be updated as well.

The binding will automatically be removed when either the @source or the
@target instances are finalized. To remove the binding without affecting the
@source and the @target you can just call g_object_unref() on the returned
#GBinding instance.

A #GObject can have multiple bindings.

Since: 2.26

</description>
<parameters>
<parameter name="source">
<parameter_description> the source #GObject
</parameter_description>
</parameter>
<parameter name="source_property">
<parameter_description> the property on @source to bind
</parameter_description>
</parameter>
<parameter name="target">
<parameter_description> the target #GObject
</parameter_description>
</parameter>
<parameter name="target_property">
<parameter_description> the property on @target to bind
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags to pass to #GBinding
</parameter_description>
</parameter>
</parameters>
<return> the #GBinding instance representing the
binding between the two #GObject instances. The binding is released
whenever the #GBinding reference count reaches zero.

</return>
</function>

<function name="g_binding_get_source">
<description>
Retrieves the #GObject instance used as the source of the binding

Since: 2.26

</description>
<parameters>
<parameter name="binding">
<parameter_description> a #GBinding
</parameter_description>
</parameter>
</parameters>
<return> the source #GObject

</return>
</function>

<function name="g_key_file_to_data">
<description>
This function outputs @key_file as a string.  

Note that this function never reports an error,
so it is safe to pass %NULL as @error.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> return location for the length of the 
returned string, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string holding
the contents of the #GKeyFile 

</return>
</function>

<function name="g_match_info_matches">
<description>
Returns whether the previous match operation succeeded.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> a #GMatchInfo structure
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the previous match operation succeeded,
%FALSE otherwise

</return>
</function>

<function name="g_timer_elapsed">
<description>
If @timer has been started but not stopped, obtains the time since
the timer was started. If @timer has been stopped, obtains the
elapsed time between the time it was started and the time it was
stopped. The return value is the number of seconds elapsed,
including any fractional part. The @microseconds out parameter is
essentially useless.

&lt;warning&gt;&lt;para&gt;
Calling initialization functions, in particular g_thread_init(), while a
timer is running will cause invalid return values from this function.
&lt;/para&gt;&lt;/warning&gt;

</description>
<parameters>
<parameter name="timer">
<parameter_description> a #GTimer.
</parameter_description>
</parameter>
<parameter name="microseconds">
<parameter_description> return location for the fractional part of seconds
elapsed, in microseconds (that is, the total number
of microseconds elapsed, modulo 1000000), or %NULL
</parameter_description>
</parameter>
</parameters>
<return> seconds elapsed as a floating point value, including any
fractional part.
</return>
</function>

<function name="g_option_group_set_translate_func">
<description>
Sets the function which is used to translate user-visible
strings, for &lt;option&gt;--help&lt;/option&gt; output. Different
groups can use different #GTranslateFunc&lt;!-- --&gt;s. If @func
is %NULL, strings are not translated.

If you are using gettext(), you only need to set the translation
domain, see g_option_group_set_translation_domain().

Since: 2.6

</description>
<parameters>
<parameter name="group">
<parameter_description> a #GOptionGroup
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the #GTranslateFunc, or %NULL 
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> user data to pass to @func, or %NULL
</parameter_description>
</parameter>
<parameter name="destroy_notify">
<parameter_description> a function which gets called to free @data, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_get_int64">
<description>
Returns the value associated with @key under @group_name as a signed
64-bit integer. This is similar to g_key_file_get_integer() but can return
64-bit results without truncation.

Since: 2.26

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a non-%NULL #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a non-%NULL group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a non-%NULL key
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> the value associated with the key as a signed 64-bit integer, or
0 if the key was not found or could not be parsed.

</return>
</function>

<function name="g_get_language_names">
<description>
Computes a list of applicable locale names, which can be used to 
e.g. construct locale-dependent filenames or search paths. The returned 
list is sorted from most desirable to least desirable and always contains 
the default locale &quot;C&quot;.

For example, if LANGUAGE=de:en_US, then the returned list is
&quot;de&quot;, &quot;en_US&quot;, &quot;en&quot;, &quot;C&quot;.

This function consults the environment variables &lt;envar&gt;LANGUAGE&lt;/envar&gt;, 
&lt;envar&gt;LC_ALL&lt;/envar&gt;, &lt;envar&gt;LC_MESSAGES&lt;/envar&gt; and &lt;envar&gt;LANG&lt;/envar&gt; 
to find the list of locales specified by the user.

Since: 2.6

</description>
<parameters>
</parameters>
<return> a %NULL-terminated array of strings owned by GLib 
that must not be modified or freed.

</return>
</function>

<function name="g_thread_pool_set_sort_function">
<description>
Sets the function used to sort the list of tasks. This allows the
tasks to be processed by a priority determined by @func, and not
just in the order in which they were added to the pool.

Note, if the maximum number of threads is more than 1, the order
that threads are executed can not be guranteed 100%. Threads are
scheduled by the operating system and are executed at random. It
cannot be assumed that threads are executed in the order they are
created. 

Since: 2.10

</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GThreadPool
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the #GCompareDataFunc used to sort the list of tasks. 
This function is passed two tasks. It should return
0 if the order in which they are handled does not matter, 
a negative value if the first task should be processed before
the second or a positive value if the second task should be 
processed first.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data passed to @func.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_tree_insert">
<description>
Inserts a key/value pair into a #GTree. If the given key already exists 
in the #GTree its corresponding value is set to the new value. If you 
supplied a value_destroy_func when creating the #GTree, the old value is 
freed using that function. If you supplied a @key_destroy_func when 
creating the #GTree, the passed key is freed using that function.

The tree is automatically 'balanced' as new key/value pairs are added,
so that the distance from the root to every leaf is as small as possible.

</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the key to insert.
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> the value corresponding to the key.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_async_queue_unlock">
<description>
Releases the queue's lock.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_rand_new_with_seed">
<description>
Creates a new random number generator initialized with @seed.


</description>
<parameters>
<parameter name="seed">
<parameter_description> a value to initialize the random number generator.
</parameter_description>
</parameter>
</parameters>
<return> the new #GRand.
</return>
</function>

<function name="g_locale_to_utf8">
<description>
Converts a string which is in the encoding used for strings by
the C runtime (usually the same as that used by the operating
system) in the &lt;link linkend=&quot;setlocale&quot;&gt;current locale&lt;/link&gt; into a
UTF-8 string.


</description>
<parameters>
<parameter name="opsysstring">
<parameter_description>   a string in the encoding of the current locale. On Windows
this means the system codepage.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description>           the length of the string, or -1 if the string is
nul-terminated&lt;footnoteref linkend=&quot;nul-unsafe&quot;/&gt;. 
</parameter_description>
</parameter>
<parameter name="bytes_read">
<parameter_description>    location to store the number of bytes in the
input string that were successfully converted, or %NULL.
Even if the conversion was successful, this may be 
less than @len if there were partial characters
at the end of the input. If the error
#G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
stored will the byte offset after the last valid
input sequence.
</parameter_description>
</parameter>
<parameter name="bytes_written">
<parameter_description> the number of bytes stored in the output buffer (not 
including the terminating nul).
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description>         location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError may occur.
</parameter_description>
</parameter>
</parameters>
<return> The converted string, or %NULL on an error.
</return>
</function>

<function name="g_async_queue_push_sorted">
<description>
Inserts @data into @queue using @func to determine the new
position. 

This function requires that the @queue is sorted before pushing on
new elements.

This function will lock @queue before it sorts the queue and unlock
it when it is finished.

For an example of @func see g_async_queue_sort(). 

Since: 2.10

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the @data to push into the @queue
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the #GCompareDataFunc is used to sort @queue. This function
is passed two elements of the @queue. The function should return
0 if they are equal, a negative value if the first element
should be higher in the @queue or a positive value if the first
element should be lower in the @queue than the second element.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data passed to @func.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_pop_allocator">
<description>
Restores the previous #GAllocator, used when allocating #GNode
elements.

Note that this function is not available if GLib has been compiled
with &lt;option&gt;--disable-mem-pools&lt;/option&gt;

Deprecated:2.10: It does nothing, since #GNode has been converted to
the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt;

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_string_overwrite">
<description>
Overwrites part of a string, lengthening it if necessary.

Since: 2.14

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="pos">
<parameter_description> the position at which to start overwriting
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> the string that will overwrite the @string starting at @pos
</parameter_description>
</parameter>
</parameters>
<return> @string

</return>
</function>

<function name="g_win32_get_windows_version">
<description>
Returns version information for the Windows operating system the
code is running on. See MSDN documentation for the GetVersion()
function. To summarize, the most significant bit is one on Win9x,
and zero on NT-based systems. Since version 2.14, GLib works only
on NT-based systems, so checking whether your are running on Win9x
in your own software is moot. The least significant byte is 4 on
Windows NT 4, and 5 on Windows XP. Software that needs really
detailled version and feature information should use Win32 API like
GetVersionEx() and VerifyVersionInfo().

Since: 2.6

</description>
<parameters>
</parameters>
<return> The version information.

</return>
</function>

<function name="g_value_get_double">
<description>
Get the contents of a %G_TYPE_DOUBLE #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_DOUBLE
</parameter_description>
</parameter>
</parameters>
<return> double contents of @value
</return>
</function>

<function name="g_filename_from_uri">
<description>
Converts an escaped ASCII-encoded URI to a local filename in the
encoding used for filenames. 


</description>
<parameters>
<parameter name="uri">
<parameter_description> a uri describing a filename (escaped, encoded in ASCII).
</parameter_description>
</parameter>
<parameter name="hostname">
<parameter_description> Location to store hostname for the URI, or %NULL.
If there is no hostname in the URI, %NULL will be
stored in this location.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError may occur.
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string holding the resulting
filename, or %NULL on an error.
</return>
</function>

<function name="g_io_channel_get_buffered">
<description>
Returns whether @channel is buffered.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the @channel is buffered. 
</return>
</function>

<function name="g_source_get_context">
<description>
Gets the #GMainContext with which the source is associated.
Calling this function on a destroyed source is an error.


</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
</parameters>
<return> the #GMainContext with which the source is associated,
or %NULL if the context has not yet been added
to a source.
</return>
</function>

<function name="g_unichar_tolower">
<description>
Converts a character to lower case.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character.
</parameter_description>
</parameter>
</parameters>
<return> the result of converting @c to lower case.
If @c is not an upperlower or titlecase character,
or has no lowercase equivalent @c is returned unchanged.
</return>
</function>

<function name="g_completion_free">
<description>
Frees all memory used by the #GCompletion.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="cmp">
<parameter_description> the #GCompletion.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_byte_array_unref">
<description>
Atomically decrements the reference count of @array by one. If the
reference count drops to 0, all memory allocated by the array is
released. This function is MT-safe and may be called from any
thread.

Since: 2.22

</description>
<parameters>
<parameter name="array">
<parameter_description> A #GByteArray.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_utf8_pointer_to_offset">
<description>
Converts from a pointer to position within a string to a integer
character offset.

Since 2.10, this function allows @pos to be before @str, and returns
a negative offset in this case.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="pos">
<parameter_description> a pointer to a position within @str
</parameter_description>
</parameter>
</parameters>
<return> the resulting character offset
</return>
</function>

<function name="g_spawn_sync">
<description>
Executes a child synchronously (waits for the child to exit before returning).
All output from the child is stored in @standard_output and @standard_error,
if those parameters are non-%NULL. Note that you must set the  
%G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when
passing %NULL for @standard_output and @standard_error.
If @exit_status is non-%NULL, the exit status of the child is stored
there as it would be returned by waitpid(); standard UNIX macros such 
as WIFEXITED() and WEXITSTATUS() must be used to evaluate the exit status.
Note that this function call waitpid() even if @exit_status is %NULL, and
does not accept the %G_SPAWN_DO_NOT_REAP_CHILD flag.
If an error occurs, no data is returned in @standard_output, 
@standard_error, or @exit_status. 

This function calls g_spawn_async_with_pipes() internally; see that
function for full details on the other parameters and details on
how these functions work on Windows.


</description>
<parameters>
<parameter name="working_directory">
<parameter_description> child's current working directory, or %NULL to inherit parent's
</parameter_description>
</parameter>
<parameter name="argv">
<parameter_description> child's argument vector
</parameter_description>
</parameter>
<parameter name="envp">
<parameter_description> child's environment, or %NULL to inherit parent's
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags from #GSpawnFlags 
</parameter_description>
</parameter>
<parameter name="child_setup">
<parameter_description> function to run in the child just before exec()
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data for @child_setup
</parameter_description>
</parameter>
<parameter name="standard_output">
<parameter_description> return location for child output, or %NULL
</parameter_description>
</parameter>
<parameter name="standard_error">
<parameter_description> return location for child error messages, or %NULL
</parameter_description>
</parameter>
<parameter name="exit_status">
<parameter_description> return location for child exit status, as returned by waitpid(), or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for error, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success, %FALSE if an error was set.
</return>
</function>

<function name="g_queue_index">
<description>
Returns the position of the first element in @queue which contains @data.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to find.
</parameter_description>
</parameter>
</parameters>
<return> The position of the first element in @queue which contains @data, or -1 if no element in @queue contains @data.

</return>
</function>

<function name="g_type_add_interface_check">
<description>
Adds a function to be called after an interface vtable is
initialized for any class (i.e. after the @interface_init member of
#GInterfaceInfo has been called).

This function is useful when you want to check an invariant that
depends on the interfaces of a class. For instance, the
implementation of #GObject uses this facility to check that an
object implements all of the properties that are defined on its
interfaces.

Since: 2.4

</description>
<parameters>
<parameter name="check_data">
<parameter_description> data to pass to @check_func
</parameter_description>
</parameter>
<parameter name="check_func">
<parameter_description> function to be called after each interface
is initialized.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_test_message">
<description>
Add a message to the test report.

Since: 2.16

</description>
<parameters>
<parameter name="format">
<parameter_description> the format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description>    printf-like arguments to @format
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_array_copy">
<description>
Construct an exact copy of a #GValueArray by duplicating all its
contents.


</description>
<parameters>
<parameter name="value_array">
<parameter_description> #GValueArray to copy
</parameter_description>
</parameter>
</parameters>
<return> Newly allocated copy of #GValueArray
</return>
</function>

<function name="g_utf8_strrchr">
<description>
Find the rightmost occurrence of the given Unicode character
in a UTF-8 encoded string, while limiting the search to @len bytes.
If @len is -1, allow unbounded search.


</description>
<parameters>
<parameter name="p">
<parameter_description> a nul-terminated UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length of @p
</parameter_description>
</parameter>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %NULL if the string does not contain the character, 
otherwise, a pointer to the start of the rightmost occurrence of the 
character in the string.
</return>
</function>

<function name="g_clear_error">
<description>
If @err is %NULL, does nothing. If @err is non-%NULL,
calls g_error_free() on *@err and sets *@err to %NULL.

</description>
<parameters>
<parameter name="err">
<parameter_description> a #GError return location
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_get_end_iter">
<description>
Returns the end iterator for @seg

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence 
</parameter_description>
</parameter>
</parameters>
<return> the end iterator for @seq

</return>
</function>

<function name="g_ascii_tolower">
<description>
Convert a character to ASCII lower case.

Unlike the standard C library tolower() function, this only
recognizes standard ASCII letters and ignores the locale, returning
all non-ASCII characters unchanged, even if they are lower case
letters in a particular character set. Also unlike the standard
library function, this takes and returns a char, not an int, so
don't call it on %EOF but no need to worry about casting to #guchar
before passing a possibly non-ASCII character in.


</description>
<parameters>
<parameter name="c">
<parameter_description> any character.
</parameter_description>
</parameter>
</parameters>
<return> the result of converting @c to lower case.
If @c is not an ASCII upper case letter,
@c is returned unchanged.
</return>
</function>

<function name="g_variant_get_string">
<description>
Returns the string value of a #GVariant instance with a string
type.  This includes the types %G_VARIANT_TYPE_STRING,
%G_VARIANT_TYPE_OBJECT_PATH and %G_VARIANT_TYPE_SIGNATURE.

The string will always be utf8 encoded.

If @length is non-%NULL then the length of the string (in bytes) is
returned there.  For trusted values, this information is already
known.  For untrusted values, a strlen() will be performed.

It is an error to call this function with a @value of any type
other than those three.

The return value remains valid as long as @value exists.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a string #GVariant instance
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> a pointer to a #gsize,
to store the length
</parameter_description>
</parameter>
</parameters>
<return> the constant string, utf8 encoded
</return>
</function>

<function name="g_byte_array_remove_index_fast">
<description>
Removes the byte at the given index from a #GByteArray. The last
element in the array is used to fill in the space, so this function
does not preserve the order of the #GByteArray. But it is faster
than g_byte_array_remove_index().

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GByteArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the byte to remove.
</parameter_description>
</parameter>
</parameters>
<return> the #GByteArray.
</return>
</function>

<function name="g_type_remove_interface_check">
<description>
Removes an interface check function added with
g_type_add_interface_check().

Since: 2.4

</description>
<parameters>
<parameter name="check_data">
<parameter_description> callback data passed to g_type_add_interface_check()
</parameter_description>
</parameter>
<parameter name="check_func">
<parameter_description> callback function passed to g_type_add_interface_check()
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_next">
<description>
Determines the next item type of a tuple or dictionary entry
type.

@type must be the result of a previous call to
g_variant_type_first() or g_variant_type_next().

If called on the key type of a dictionary entry then this call
returns the value type.  If called on the value type of a dictionary
entry then this call returns %NULL.

For tuples, %NULL is returned when @type is the last item in a tuple.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType from a previous call
</parameter_description>
</parameter>
</parameters>
<return> the next #GVariantType after @type, or %NULL
</return>
</function>

<function name="g_static_rw_lock_init">
<description>
A #GStaticRWLock must be initialized with this function before it
can be used. Alternatively you can initialize it with
#G_STATIC_RW_LOCK_INIT.

</description>
<parameters>
<parameter name="lock">
<parameter_description> a #GStaticRWLock to be initialized.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_win32_error_message">
<description>
Translate a Win32 error code (as returned by GetLastError()) into
the corresponding message. The message is either language neutral,
or in the thread's language, or the user's language, the system's
language, or US English (see docs for FormatMessage()). The
returned string is in UTF-8. It should be deallocated with
g_free().


</description>
<parameters>
<parameter name="error">
<parameter_description> error code.
</parameter_description>
</parameter>
</parameters>
<return> newly-allocated error message
</return>
</function>

<function name="g_value_array_sort">
<description>
Sort @value_array using @compare_func to compare the elements accoring to
the semantics of #GCompareFunc.

The current implementation uses Quick-Sort as sorting algorithm.


</description>
<parameters>
<parameter name="value_array">
<parameter_description> #GValueArray to sort
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> function to compare elements
</parameter_description>
</parameter>
</parameters>
<return> the #GValueArray passed in as @value_array
</return>
</function>

<function name="g_unlink">
<description>
A wrapper for the POSIX unlink() function. The unlink() function 
deletes a name from the filesystem. If this was the last link to the 
file and no processes have it opened, the diskspace occupied by the
file is freed.

See your C library manual for more details about unlink(). Note
that on Windows, it is in general not possible to delete files that
are open to some process, or mapped into memory.

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
</parameters>
<return> 0 if the name was successfully deleted, -1 if an error 
occurred

</return>
</function>

<function name="g_type_default_interface_ref">
<description>
Increments the reference count for the interface type @g_type,
and returns the default interface vtable for the type.

If the type is not currently in use, then the default vtable
for the type will be created and initalized by calling
the base interface init and default vtable init functions for
the type (the @&lt;structfield&gt;base_init&lt;/structfield&gt;
and &lt;structfield&gt;class_init&lt;/structfield&gt; members of #GTypeInfo).
Calling g_type_default_interface_ref() is useful when you
want to make sure that signals and properties for an interface
have been installed.

Since: 2.4


</description>
<parameters>
<parameter name="g_type">
<parameter_description> an interface type
</parameter_description>
</parameter>
</parameters>
<return> the default vtable for the interface; call
g_type_default_interface_unref() when you are done using
the interface.
</return>
</function>

<function name="g_object_unref">
<description>
Decreases the reference count of @object. When its reference count
drops to 0, the object is finalized (i.e. its memory is freed).

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_take_object">
<description>
Sets the contents of a %G_TYPE_OBJECT derived #GValue to @v_object
and takes over the ownership of the callers reference to @v_object;
the caller doesn't have to unref it any more (i.e. the reference
count of the object is not increased).

If you want the #GValue to hold its own reference to @v_object, use
g_value_set_object() instead.

Since: 2.4

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_OBJECT derived type
</parameter_description>
</parameter>
<parameter name="v_object">
<parameter_description> object value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_main_depth">
<description>
Returns the depth of the stack of calls to
g_main_context_dispatch() on any #GMainContext in the current thread.
That is, when called from the toplevel, it gives 0. When
called from within a callback from g_main_context_iteration()
(or g_main_loop_run(), etc.) it returns 1. When called from within 
a callback to a recursive call to g_main_context_iterate(),
it returns 2. And so forth.

This function is useful in a situation like the following:
Imagine an extremely simple &quot;garbage collected&quot; system.

|[
static GList *free_list;

gpointer
allocate_memory (gsize size)
{ 
gpointer result = g_malloc (size);
free_list = g_list_prepend (free_list, result);
return result;
}

void
free_allocated_memory (void)
{
GList *l;
for (l = free_list; l; l = l-&gt;next);
g_free (l-&gt;data);
g_list_free (free_list);
free_list = NULL;
}

[...]

while (TRUE); 
{
g_main_context_iteration (NULL, TRUE);
free_allocated_memory();
}
]|

This works from an application, however, if you want to do the same
thing from a library, it gets more difficult, since you no longer
control the main loop. You might think you can simply use an idle
function to make the call to free_allocated_memory(), but that
doesn't work, since the idle function could be called from a
recursive callback. This can be fixed by using g_main_depth()

|[
gpointer
allocate_memory (gsize size)
{ 
FreeListBlock *block = g_new (FreeListBlock, 1);
block-&gt;mem = g_malloc (size);
block-&gt;depth = g_main_depth ();   
free_list = g_list_prepend (free_list, block);
return block-&gt;mem;
}

void
free_allocated_memory (void)
{
GList *l;

int depth = g_main_depth ();
for (l = free_list; l; );
{
GList *next = l-&gt;next;
FreeListBlock *block = l-&gt;data;
if (block-&gt;depth &gt; depth)
{
g_free (block-&gt;mem);
g_free (block);
free_list = g_list_delete_link (free_list, l);
}

l = next;
}
}
]|

There is a temptation to use g_main_depth() to solve
problems with reentrancy. For instance, while waiting for data
to be received from the network in response to a menu item,
the menu item might be selected again. It might seem that
one could make the menu item's callback return immediately
and do nothing if g_main_depth() returns a value greater than 1.
However, this should be avoided since the user then sees selecting
the menu item do nothing. Furthermore, you'll find yourself adding
these checks all over your code, since there are doubtless many,
many things that the user could do. Instead, you can use the
following techniques:

&lt;orderedlist&gt;
&lt;listitem&gt;
&lt;para&gt;
Use gtk_widget_set_sensitive() or modal dialogs to prevent
the user from interacting with elements while the main
loop is recursing.
&lt;/para&gt;
&lt;/listitem&gt;
&lt;listitem&gt;
&lt;para&gt;
Avoid main loop recursion in situations where you can't handle
arbitrary  callbacks. Instead, structure your code so that you
simply return to the main loop and then get called again when
there is more work to do.
&lt;/para&gt;
&lt;/listitem&gt;
&lt;/orderedlist&gt;


</description>
<parameters>
</parameters>
<return> The main loop recursion level in the current thread
</return>
</function>

<function name="g_signal_accumulator_true_handled">
<description>
A predefined #GSignalAccumulator for signals that return a
boolean values. The behavior that this accumulator gives is
that a return of %TRUE stops the signal emission: no further
callbacks will be invoked, while a return of %FALSE allows
the emission to coninue. The idea here is that a %TRUE return
indicates that the callback &lt;emphasis&gt;handled&lt;/emphasis&gt; the signal,
and no further handling is needed.

Since: 2.4


</description>
<parameters>
<parameter name="ihint">
<parameter_description> standard #GSignalAccumulator parameter
</parameter_description>
</parameter>
<parameter name="return_accu">
<parameter_description> standard #GSignalAccumulator parameter
</parameter_description>
</parameter>
<parameter name="handler_return">
<parameter_description> standard #GSignalAccumulator parameter
</parameter_description>
</parameter>
<parameter name="dummy">
<parameter_description> standard #GSignalAccumulator parameter
</parameter_description>
</parameter>
</parameters>
<return> standard #GSignalAccumulator result
</return>
</function>

<function name="g_error_matches">
<description>
Returns %TRUE if @error matches @domain and @code, %FALSE
otherwise. In particular, when @error is %NULL, %FALSE will
be returned.


</description>
<parameters>
<parameter name="error">
<parameter_description> a #GError or %NULL
</parameter_description>
</parameter>
<parameter name="domain">
<parameter_description> an error domain
</parameter_description>
</parameter>
<parameter name="code">
<parameter_description> an error code
</parameter_description>
</parameter>
</parameters>
<return> whether @error has @domain and @code
</return>
</function>

<function name="g_string_sized_new">
<description>
Creates a new #GString, with enough space for @dfl_size 
bytes. This is useful if you are going to add a lot of 
text to the string and don't want it to be reallocated 
too often.


</description>
<parameters>
<parameter name="dfl_size">
<parameter_description> the default size of the space allocated to 
hold the string
</parameter_description>
</parameter>
</parameters>
<return> the new #GString
</return>
</function>

<function name="g_variant_is_signature">
<description>
Determines if a given string is a valid DBus type signature.  You
should ensure that a string is a valid DBus type signature before
passing it to g_variant_new_signature().

DBus type signatures consist of zero or more definite #GVariantType
strings in sequence.

Since: 2.24

</description>
<parameters>
<parameter name="string">
<parameter_description> a normal C nul-terminated string
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @string is a DBus type signature
</return>
</function>

<function name="g_variant_is_of_type">
<description>
Checks if a value has a type matching the provided type.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant instance
</parameter_description>
</parameter>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the type of @value matches @type
</return>
</function>

<function name="g_slist_foreach">
<description>
Calls a function for each element of a #GSList.

</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call with each element's data
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_dir_open">
<description>
Opens a directory for reading. The names of the files in the
directory can then be retrieved using g_dir_read_name().


</description>
<parameters>
<parameter name="path">
<parameter_description> the path to the directory you are interested in. On Unix
in the on-disk encoding. On Windows in UTF-8
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> Currently must be set to 0. Reserved for future use.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL.
If non-%NULL, an error will be set if and only if
g_dir_open() fails.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated #GDir on success, %NULL on failure.
If non-%NULL, you must free the result with g_dir_close()
when you are finished with it.
</return>
</function>

<function name="g_lstat">
<description>
A wrapper for the POSIX lstat() function. The lstat() function is
like stat() except that in the case of symbolic links, it returns
information about the symbolic link itself and not the file that it
refers to. If the system does not support symbolic links g_lstat()
is identical to g_stat().

See your C library manual for more details about lstat().

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="buf">
<parameter_description> a pointer to a &lt;structname&gt;stat&lt;/structname&gt; struct, which
will be filled with the file information
</parameter_description>
</parameter>
</parameters>
<return> 0 if the information was successfully retrieved, -1 if an error 
occurred

</return>
</function>

<function name="g_array_get_element_size">
<description>
Gets the size of the elements in @array.

Since: 2.22

</description>
<parameters>
<parameter name="array">
<parameter_description> A #GArray.
</parameter_description>
</parameter>
</parameters>
<return> Size of each element, in bytes.

</return>
</function>

<function name="g_test_bug_base">
<description>
Specify the base URI for bug reports.

The base URI is used to construct bug report messages for
g_test_message() when g_test_bug() is called.
Calling this function outside of a test case sets the
default base URI for all test cases. Calling it from within
a test case changes the base URI for the scope of the test
case only.
Bug URIs are constructed by appending a bug specific URI
portion to @uri_pattern, or by replacing the special string
'%s' within @uri_pattern if that is present.

Since: 2.16

</description>
<parameters>
<parameter name="uri_pattern">
<parameter_description> the base pattern for bug URIs
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_strip_context">
<description>
An auxiliary function for gettext() support (see Q_()).

Since: 2.4

</description>
<parameters>
<parameter name="msgid">
<parameter_description> a string
</parameter_description>
</parameter>
<parameter name="msgval">
<parameter_description> another string
</parameter_description>
</parameter>
</parameters>
<return> @msgval, unless @msgval is identical to @msgid and contains
a '|' character, in which case a pointer to the substring of msgid after
the first '|' character is returned. 

</return>
</function>

<function name="g_object_notify">
<description>
Emits a &quot;notify&quot; signal for the property @property_name on @object.

When possible, eg. when signaling a property change from within the class
that registered the property, you should use g_object_notify_by_pspec()
instead.

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="property_name">
<parameter_description> the name of a property installed on the class of @object.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_init">
<description>
A statically-allocated #GQueue must be initialized with this function
before it can be used. Alternatively you can initialize it with
#G_QUEUE_INIT. It is not necessary to initialize queues created with
g_queue_new().

Since: 2.14

</description>
<parameters>
<parameter name="queue">
<parameter_description> an uninitialized #GQueue
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_match_info_expand_references">
<description>
Returns a new string containing the text in @string_to_expand with
references and escape sequences expanded. References refer to the last
match done with @string against @regex and have the same syntax used by
g_regex_replace().

The @string_to_expand must be UTF-8 encoded even if #G_REGEX_RAW was
passed to g_regex_new().

The backreferences are extracted from the string passed to the match
function, so you cannot call this function after freeing the string.

@match_info may be %NULL in which case @string_to_expand must not
contain references. For instance &quot;foo\n&quot; does not refer to an actual
pattern and '\n' merely will be replaced with \n character,
while to expand &quot;\0&quot; (whole match) one needs the result of a match.
Use g_regex_check_replacement() to find out whether @string_to_expand
contains references.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> a #GMatchInfo or %NULL
</parameter_description>
</parameter>
<parameter name="string_to_expand">
<parameter_description> the string to expand
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore errors
</parameter_description>
</parameter>
</parameters>
<return> the expanded string, or %NULL if an error occurred

</return>
</function>

<function name="g_param_spec_char">
<description>
Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_datalist_set_data_full">
<description>
Sets the data element corresponding to the given string identifier,
and the function to be called when the data element is removed.

</description>
<parameters>
<parameter name="dl">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string to identify the data element.
</parameter_description>
</parameter>
<parameter name="d">
<parameter_description> the data element, or %NULL to remove any previous element
corresponding to @k.
</parameter_description>
</parameter>
<parameter name="f">
<parameter_description> the function to call when the data element is removed. This
function will be called with the data element and can be used to
free any memory allocated for it. If @d is %NULL, then @f must
also be %NULL.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_classify">
<description>
Classifies @value according to its top-level type.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return> the #GVariantClass of @value
</return>
</function>

<function name="g_main_context_set_poll_func">
<description>
Sets the function to use to handle polling of file descriptors. It
will be used instead of the poll() system call 
(or GLib's replacement function, which is used where 
poll() isn't available).

This function could possibly be used to integrate the GLib event
loop with an external event loop.

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call to poll all file descriptors
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_pop_tail">
<description>
Removes the last element of the queue.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
</parameters>
<return> the data of the last element in the queue, or %NULL if the queue
is empty.
</return>
</function>

<function name="g_value_dup_param">
<description>
Get the contents of a %G_TYPE_PARAM #GValue, increasing its
reference count.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue whose type is derived from %G_TYPE_PARAM
</parameter_description>
</parameter>
</parameters>
<return> #GParamSpec content of @value, should be unreferenced when
no longer needed.
</return>
</function>

<function name="g_array_sized_new">
<description>
Creates a new #GArray with @reserved_size elements preallocated and
a reference count of 1. This avoids frequent reallocation, if you
are going to add many elements to the array. Note however that the
size of the array is still 0.

</description>
<parameters>
<parameter name="zero_terminated">
<parameter_description> %TRUE if the array should have an extra element at
the end with all bits cleared.
</parameter_description>
</parameter>
<parameter name="clear_">
<parameter_description> %TRUE if all bits in the array should be cleared to 0 on
allocation.
</parameter_description>
</parameter>
<parameter name="element_size">
<parameter_description> size of each element in the array.
</parameter_description>
</parameter>
<parameter name="reserved_size">
<parameter_description> number of elements preallocated.
</parameter_description>
</parameter>
</parameters>
<return> the new #GArray.
</return>
</function>

<function name="g_utf8_strncpy">
<description>
Like the standard C strncpy() function, but 
copies a given number of characters instead of a given number of 
bytes. The @src string must be valid UTF-8 encoded text. 
(Use g_utf8_validate() on all text before trying to use UTF-8 
utility functions with it.)


</description>
<parameters>
<parameter name="dest">
<parameter_description> buffer to fill with characters from @src
</parameter_description>
</parameter>
<parameter name="src">
<parameter_description> UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> character count
</parameter_description>
</parameter>
</parameters>
<return> @dest
</return>
</function>

<function name="g_filename_display_name">
<description>
Converts a filename into a valid UTF-8 string. The conversion is 
not necessarily reversible, so you should keep the original around 
and use the return value of this function only for display purposes.
Unlike g_filename_to_utf8(), the result is guaranteed to be non-%NULL 
even if the filename actually isn't in the GLib file name encoding.

If GLib can not make sense of the encoding of @filename, as a last resort it 
replaces unknown characters with U+FFFD, the Unicode replacement character.
You can search the result for the UTF-8 encoding of this character (which is
&quot;\357\277\275&quot; in octal notation) to find out if @filename was in an invalid
encoding.

If you know the whole pathname of the file you should use
g_filename_display_basename(), since that allows location-based
translation of filenames.

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname hopefully in the GLib file name encoding
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string containing
a rendition of the filename in valid UTF-8

</return>
</function>

<function name="g_cond_broadcast">
<description>
If threads are waiting for @cond, all of them are woken up. It is
good practice to lock the same mutex as the waiting threads, while
calling this function, though not required.

This function can be used even if g_thread_init() has not yet been
called, and, in that case, will do nothing.

</description>
<parameters>
<parameter name="cond">
<parameter_description> a #GCond.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_error_copy">
<description>
Makes a copy of @error.


</description>
<parameters>
<parameter name="error">
<parameter_description> a #GError
</parameter_description>
</parameter>
</parameters>
<return> a new #GError
</return>
</function>

<function name="g_value_array_append">
<description>
Insert a copy of @value as last element of @value_array. If @value is
%NULL, an uninitialized value is appended.


</description>
<parameters>
<parameter name="value_array">
<parameter_description> #GValueArray to add an element to
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> #GValue to copy into #GValueArray, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> the #GValueArray passed in as @value_array
</return>
</function>

<function name="g_io_channel_unix_get_fd">
<description>
Returns the file descriptor of the #GIOChannel.

On Windows this function returns the file descriptor or socket of
the #GIOChannel.

</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel, created with g_io_channel_unix_new().
</parameter_description>
</parameter>
</parameters>
<return> the file descriptor of the #GIOChannel.
</return>
</function>

<function name="g_ascii_strup">
<description>
Converts all lower case ASCII letters to upper case ASCII letters.


</description>
<parameters>
<parameter name="str">
<parameter_description> a string.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> length of @str in bytes, or -1 if @str is nul-terminated.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string, with all the lower case
characters in @str converted to upper case, with
semantics that exactly match g_ascii_toupper(). (Note
that this is unlike the old g_strup(), which modified
the string in place.)
</return>
</function>

<function name="g_source_attach">
<description>
Adds a #GSource to a @context so that it will be executed within
that context. Remove it by calling g_source_destroy().


</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
<parameter name="context">
<parameter_description> a #GMainContext (if %NULL, the default context will be used)
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) for the source within the 
#GMainContext. 
</return>
</function>

<function name="g_value_set_boolean">
<description>
Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_BOOLEAN
</parameter_description>
</parameter>
<parameter name="v_boolean">
<parameter_description> boolean value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_supported">
<description>
This function returns %TRUE if the thread system is initialized, and
%FALSE if it is not.

&lt;note&gt;&lt;para&gt;This function is actually a macro. Apart from taking the
address of it you can however use it as if it was a
function.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
</parameters>
<return> %TRUE, if the thread system is initialized.
</return>
</function>

<function name="g_value_set_string_take_ownership">
<description>
This is an internal function introduced mainly for C marshallers.

Deprecated: 2.4: Use g_value_take_string() instead.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_STRING
</parameter_description>
</parameter>
<parameter name="v_string">
<parameter_description> duplicated unowned string to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_async_queue_new">
<description>
Creates a new asynchronous queue with the initial reference count of 1.


</description>
<parameters>
</parameters>
<return> the new #GAsyncQueue.
</return>
</function>

<function name="g_type_interface_add_prerequisite">
<description>
Adds @prerequisite_type to the list of prerequisites of @interface_type.
This means that any type implementing @interface_type must also implement
@prerequisite_type. Prerequisites can be thought of as an alternative to
interface derivation (which GType doesn't support). An interface can have
at most one instantiatable prerequisite type.

</description>
<parameters>
<parameter name="interface_type">
<parameter_description> #GType value of an interface type.
</parameter_description>
</parameter>
<parameter name="prerequisite_type">
<parameter_description> #GType value of an interface or instantiatable type.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_uri_list_extract_uris">
<description>
Splits an URI list conforming to the text/uri-list
mime type defined in RFC 2483 into individual URIs,
discarding any comments. The URIs are not validated.

Since: 2.6

</description>
<parameters>
<parameter name="uri_list">
<parameter_description> an URI list 
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated %NULL-terminated list of
strings holding the individual URIs. The array should
be freed with g_strfreev().

</return>
</function>

<function name="g_filename_to_uri">
<description>
Converts an absolute filename to an escaped ASCII-encoded URI, with the path
component following Section 3.3. of RFC 2396.


</description>
<parameters>
<parameter name="filename">
<parameter_description> an absolute filename specified in the GLib file name encoding,
which is the on-disk file name bytes on Unix, and UTF-8 on 
Windows
</parameter_description>
</parameter>
<parameter name="hostname">
<parameter_description> A UTF-8 encoded hostname, or %NULL for none.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError may occur.
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string holding the resulting
URI, or %NULL on an error.
</return>
</function>

<function name="g_variant_compare">
<description>
Compares @one and @two.

The types of @one and @two are #gconstpointer only to allow use of
this function with #GTree, #GPtrArray, etc.  They must each be a
#GVariant.

Comparison is only defined for basic types (ie: booleans, numbers,
strings).  For booleans, %FALSE is less than %TRUE.  Numbers are
ordered in the usual way.  Strings are in ASCII lexographical order.

It is a programmer error to attempt to compare container values or
two values that have types that are not exactly equal.  For example,
you can not compare a 32-bit signed integer with a 32-bit unsigned
integer.  Also note that this function is not particularly
well-behaved when it comes to comparison of doubles; in particular,
the handling of incomparable values (ie: NaN) is undefined.

If you only require an equality comparison, g_variant_equal() is more
general.

Since: 2.26

</description>
<parameters>
<parameter name="one">
<parameter_description> a basic-typed #GVariant instance
</parameter_description>
</parameter>
<parameter name="two">
<parameter_description> a #GVariant instance of the same type
</parameter_description>
</parameter>
</parameters>
<return> negative value if a &lt; b;
zero if a = b;
positive value if a &gt; b.
</return>
</function>

<function name="g_uri_escape_string">
<description>
Escapes a string for use in a URI.

Normally all characters that are not &quot;unreserved&quot; (i.e. ASCII alphanumerical
characters plus dash, dot, underscore and tilde) are escaped.
But if you specify characters in @reserved_chars_allowed they are not
escaped. This is useful for the &quot;reserved&quot; characters in the URI
specification, since those are allowed unescaped in some portions of
a URI. 

Since: 2.16

</description>
<parameters>
<parameter name="unescaped">
<parameter_description> the unescaped input string.
</parameter_description>
</parameter>
<parameter name="reserved_chars_allowed">
<parameter_description> a string of reserved characters that are
allowed to be used, or %NULL.
</parameter_description>
</parameter>
<parameter name="allow_utf8">
<parameter_description> %TRUE if the result can include UTF-8 characters.
</parameter_description>
</parameter>
</parameters>
<return> an escaped version of @unescaped. The returned string should be 
freed when no longer needed.

</return>
</function>

<function name="g_string_chunk_insert_const">
<description>
Adds a copy of @string to the #GStringChunk, unless the same
string has already been added to the #GStringChunk with
g_string_chunk_insert_const().

This function is useful if you need to copy a large number
of strings but do not want to waste space storing duplicates.
But you must remember that there may be several pointers to
the same string, and so any changes made to the strings
should be done very carefully.

Note that g_string_chunk_insert_const() will not return a
pointer to a string added with g_string_chunk_insert(), even
if they do match.


</description>
<parameters>
<parameter name="chunk">
<parameter_description> a #GStringChunk
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to add
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the new or existing copy of @string
within the #GStringChunk
</return>
</function>

<function name="g_hostname_is_ascii_encoded">
<description>
Tests if @hostname contains segments with an ASCII-compatible
encoding of an Internationalized Domain Name. If this returns
%TRUE, you should decode the hostname with g_hostname_to_unicode()
before displaying it to the user.

Note that a hostname might contain a mix of encoded and unencoded
segments, and so it is possible for g_hostname_is_non_ascii() and
g_hostname_is_ascii_encoded() to both return %TRUE for a name.

Since: 2.22

</description>
<parameters>
<parameter name="hostname">
<parameter_description> a hostname
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @hostname contains any ASCII-encoded
segments.

</return>
</function>

<function name="g_test_maximized_result">
<description>
Report the result of a performance or measurement test.
The test should generally strive to maximize the reported
quantities (larger values are better than smaller ones),
this and @maximized_quantity can determine sorting
order for test result reports.

Since: 2.16

</description>
<parameters>
<parameter name="maximized_quantity">
<parameter_description> the reported value
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> the format string of the report message
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments to pass to the printf() function
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_unicode_canonical_decomposition">
<description>
Computes the canonical decomposition of a Unicode character.  


</description>
<parameters>
<parameter name="ch">
<parameter_description> a Unicode character.
</parameter_description>
</parameter>
<parameter name="result_len">
<parameter_description> location to store the length of the return value.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string of Unicode characters.
@result_len is set to the resulting length of the string.
</return>
</function>

<function name="g_node_get_root">
<description>
Gets the root of a tree.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
</parameters>
<return> the root of the tree
</return>
</function>

<function name="g_rand_int">
<description>
Returns the next random #guint32 from @rand_ equally distributed over
the range [0..2^32-1].


</description>
<parameters>
<parameter name="rand_">
<parameter_description> a #GRand.
</parameter_description>
</parameter>
</parameters>
<return> A random number.
</return>
</function>

<function name="g_value_copy">
<description>
Copies the value of @src_value into @dest_value.

</description>
<parameters>
<parameter name="src_value">
<parameter_description> An initialized #GValue structure.
</parameter_description>
</parameter>
<parameter name="dest_value">
<parameter_description> An initialized #GValue structure of the same type as @src_value.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hash_table_foreach">
<description>
Calls the given function for each of the key/value pairs in the
#GHashTable.  The function is passed the key and value of each
pair, and the given @user_data parameter.  The hash table may not
be modified while iterating over it (you can't add/remove
items). To remove all items matching a predicate, use
g_hash_table_foreach_remove().

See g_hash_table_find() for performance caveats for linear
order searches in contrast to g_hash_table_lookup().

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each key/value pair.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_n_items">
<description>
Determines the number of items contained in a tuple or
dictionary entry type.

This function may only be used with tuple or dictionary entry types,
but must not be used with the generic tuple type
%G_VARIANT_TYPE_TUPLE.

In the case of a dictionary entry type, this function will always
return 2.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a tuple or dictionary entry #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> the number of items in @type
</return>
</function>

<function name="g_sequence_append">
<description>
Adds a new item to the end of @seq.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequencePointer
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new item
</parameter_description>
</parameter>
</parameters>
<return> an iterator pointing to the new item

</return>
</function>

<function name="g_datalist_set_data">
<description>
Sets the data element corresponding to the given string identifier.

</description>
<parameters>
<parameter name="dl">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string to identify the data element.
</parameter_description>
</parameter>
<parameter name="d">
<parameter_description> the data element, or %NULL to remove any previous element
corresponding to @k.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_nullify_pointer">
<description>
Set the pointer at the specified location to %NULL.

</description>
<parameters>
<parameter name="nullify_location">
<parameter_description> the memory address of the pointer.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_test_init">
<description>
Initialize the GLib testing framework, e.g. by seeding the
test random number generator, the name for g_get_prgname()
and parsing test related command line args.
So far, the following arguments are understood:
&lt;variablelist&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;-l&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
list test cases available in a test executable.
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;--seed=&lt;replaceable&gt;RANDOMSEED&lt;/replaceable&gt;&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
provide a random seed to reproduce test runs using random numbers.
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;--verbose&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;run tests verbosely.&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;-q&lt;/option&gt;, &lt;option&gt;--quiet&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;run tests quietly.&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;-p &lt;replaceable&gt;TESTPATH&lt;/replaceable&gt;&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
execute all tests matching &lt;replaceable&gt;TESTPATH&lt;/replaceable&gt;.
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;-m {perf|slow|thorough|quick}&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
execute tests according to these test modes:
&lt;variablelist&gt;
&lt;varlistentry&gt;
&lt;term&gt;perf&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
performance tests, may take long and report results.
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;slow, thorough&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
slow and thorough tests, may take quite long and 
maximize coverage.
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;quick&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
quick tests, should run really quickly and give good coverage.
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;/variablelist&gt;
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;--debug-log&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;debug test logging output.&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;-k&lt;/option&gt;, &lt;option&gt;--keep-going&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;gtester-specific argument.&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;--GTestLogFD &lt;replaceable&gt;N&lt;/replaceable&gt;&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;gtester-specific argument.&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;&lt;option&gt;--GTestSkipCount &lt;replaceable&gt;N&lt;/replaceable&gt;&lt;/option&gt;&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;gtester-specific argument.&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;/variablelist&gt;

Since: 2.16

</description>
<parameters>
<parameter name="argc">
<parameter_description> Address of the @argc parameter of the main() function.
Changed if any arguments were handled.
</parameter_description>
</parameter>
<parameter name="argv">
<parameter_description> Address of the @argv parameter of main().
Any parameters understood by g_test_init() stripped before return.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> Reserved for future extension. Currently, you must pass %NULL.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_set_locale_string">
<description>
Associates a string value for @key and @locale under @group_name.
If the translation for @key cannot be found then it is created.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="locale">
<parameter_description> a locale identifier
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> a string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_free">
<description>
Frees a #GBookmarkFile.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_regex_match_full">
<description>
Scans for a match in string for the pattern in @regex.
The @match_options are combined with the match options specified
when the @regex structure was created, letting you have more
flexibility in reusing #GRegex structures.

Setting @start_position differs from just passing over a shortened
string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
that begins with any kind of lookbehind assertion, such as &quot;\b&quot;.

A #GMatchInfo structure, used to get information on the match, is
stored in @match_info if not %NULL. Note that if @match_info is
not %NULL then it is created even if the function returns %FALSE,
i.e. you must free it regardless if regular expression actually
matched.

@string is not copied and is used in #GMatchInfo internally. If
you use any #GMatchInfo method (except g_match_info_free()) after
freeing or modifying @string then the behaviour is undefined.

To retrieve all the non-overlapping matches of the pattern in
string you can use g_match_info_next().

|[
static void
print_uppercase_words (const gchar *string)
{
/ * Print all uppercase-only words. * /
GRegex *regex;
GMatchInfo *match_info;
GError *error = NULL;
&#160;
regex = g_regex_new (&quot;[A-Z]+&quot;, 0, 0, NULL);
g_regex_match_full (regex, string, -1, 0, 0, &amp;match_info, &amp;error);
while (g_match_info_matches (match_info))
{
gchar *word = g_match_info_fetch (match_info, 0);
g_print (&quot;Found: %s\n&quot;, word);
g_free (word);
g_match_info_next (match_info, &amp;error);
}
g_match_info_free (match_info);
g_regex_unref (regex);
if (error != NULL)
{
g_printerr (&quot;Error while matching: %s\n&quot;, error-&gt;message);
g_error_free (error);
}
}
]|

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure from g_regex_new()
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to scan for matches
</parameter_description>
</parameter>
<parameter name="string_len">
<parameter_description> the length of @string, or -1 if @string is nul-terminated
</parameter_description>
</parameter>
<parameter name="start_position">
<parameter_description> starting index of the string to match
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> match options
</parameter_description>
</parameter>
<parameter name="match_info">
<parameter_description> pointer to location where to store
the #GMatchInfo, or %NULL if you do not need it
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore errors
</parameter_description>
</parameter>
</parameters>
<return> %TRUE is the string matched, %FALSE otherwise

</return>
</function>

<function name="g_key_file_set_string_list">
<description>
Associates a list of string values for @key under @group_name.
If @key cannot be found then it is created.
If @group_name cannot be found then it is created.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="list">
<parameter_description> an array of string values
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> number of string values in @list
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_override">
<description>
Creates a new property of type #GParamSpecOverride. This is used
to direct operations to another paramspec, and will not be directly
useful unless you are implementing a new base type similar to GObject.

Since: 2.4


</description>
<parameters>
<parameter name="name">
<parameter_description> the name of the property.
</parameter_description>
</parameter>
<parameter name="overridden">
<parameter_description> The property that is being overridden
</parameter_description>
</parameter>
</parameters>
<return> the newly created #GParamSpec
</return>
</function>

<function name="g_type_value_table_peek">
<description>
Returns the location of the #GTypeValueTable associated with @type.
&lt;emphasis&gt;Note that this function should only be used from source code
that implements or has internal knowledge of the implementation of
@type.&lt;/emphasis&gt;


</description>
<parameters>
<parameter name="type">
<parameter_description> A #GType value.
</parameter_description>
</parameter>
</parameters>
<return> Location of the #GTypeValueTable associated with @type or
%NULL if there is no #GTypeValueTable associated with @type.
</return>
</function>

<function name="g_closure_unref">
<description>
Decrements the reference count of a closure after it was previously
incremented by the same caller. If no other callers are using the
closure, then the closure will be destroyed and freed.

</description>
<parameters>
<parameter name="closure">
<parameter_description> #GClosure to decrement the reference count on
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_emitv">
<description>
Emits a signal.

Note that g_signal_emitv() doesn't change @return_value if no handlers are
connected, in contrast to g_signal_emit() and g_signal_emit_valist().

</description>
<parameters>
<parameter name="instance_and_params">
<parameter_description> argument list for the signal emission. The first
element in the array is a #GValue for the instance the signal is
being emitted on. The rest are any arguments to be passed to the
signal.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> the signal id
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> the detail
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> Location to store the return value of the signal emission.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_list_ids">
<description>
Lists the signals by id that a certain instance or interface type
created. Further information about the signals can be acquired through
g_signal_query().


</description>
<parameters>
<parameter name="itype">
<parameter_description> Instance or interface type.
</parameter_description>
</parameter>
<parameter name="n_ids">
<parameter_description> Location to store the number of signal ids for @itype.
</parameter_description>
</parameter>
</parameters>
<return> Newly allocated array of signal IDs.
</return>
</function>

<function name="g_boxed_copy">
<description>
Provide a copy of a boxed structure @src_boxed which is of type @boxed_type.


</description>
<parameters>
<parameter name="boxed_type">
<parameter_description> The type of @src_boxed.
</parameter_description>
</parameter>
<parameter name="src_boxed">
<parameter_description> The boxed structure to be copied.
</parameter_description>
</parameter>
</parameters>
<return> The newly created copy of the boxed structure.
</return>
</function>

<function name="g_pattern_spec_free">
<description>
Frees the memory allocated for the #GPatternSpec.

</description>
<parameters>
<parameter name="pspec">
<parameter_description> a #GPatternSpec
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_hash">
<description>
Hashes @type.

The argument type of @type is only #gconstpointer to allow use with
#GHashTable without function pointer casting.  A valid
#GVariantType must be provided.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> the hash value
</return>
</function>

<function name="g_once_init_leave">
<description>
Counterpart to g_once_init_enter(). Expects a location of a static
0-initialized initialization variable, and an initialization value
other than 0. Sets the variable to the initialization value, and
releases concurrent threads blocking in g_once_init_enter() on this
initialization variable.

Since: 2.14

</description>
<parameters>
<parameter name="value_location">
<parameter_description> location of a static initializable variable
containing 0.
</parameter_description>
</parameter>
<parameter name="initialization_value">
<parameter_description> new non-0 value for *@value_location.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_delete_link">
<description>
Removes the node link_ from the list and frees it. 
Compare this to g_slist_remove_link() which removes the node 
without freeing it.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="link_">
<parameter_description> node to delete
</parameter_description>
</parameter>
</parameters>
<return> the new head of @list
</return>
</function>

<function name="g_value_set_variant">
<description>
Set the contents of a variant #GValue to @variant.
If the variant is floating, it is consumed.

Since: 2.26

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_VARIANT
</parameter_description>
</parameter>
<parameter name="variant">
<parameter_description> a #GVariant, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_strsplit">
<description>
Splits a string into a maximum of @max_tokens pieces, using the given
@delimiter. If @max_tokens is reached, the remainder of @string is appended
to the last token. 

As a special case, the result of splitting the empty string &quot;&quot; is an empty
vector, not a vector containing a single string. The reason for this
special case is that being able to represent a empty vector is typically
more useful than consistent handling of empty elements. If you do need
to represent empty elements, you'll need to check for the empty string
before calling g_strsplit().


</description>
<parameters>
<parameter name="string">
<parameter_description> a string to split.
</parameter_description>
</parameter>
<parameter name="delimiter">
<parameter_description> a string which specifies the places at which to split the string.
The delimiter is not included in any of the resulting strings, unless
@max_tokens is reached.
</parameter_description>
</parameter>
<parameter name="max_tokens">
<parameter_description> the maximum number of pieces to split @string into. If this is
less than 1, the string is split completely.
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated %NULL-terminated array of strings. Use 
g_strfreev() to free it.
</return>
</function>

<function name="g_static_mutex_lock">
<description>
Works like g_mutex_lock(), but for a #GStaticMutex.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticMutex.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_new_double">
<description>
Creates a new double #GVariant instance.

Since: 2.24

</description>
<parameters>
<parameter name="floating">
<parameter_description> a #gdouble floating point value
</parameter_description>
</parameter>
</parameters>
<return> a new double #GVariant instance
</return>
</function>

<function name="g_param_spec_param">
<description>
Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM
property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="param_type">
<parameter_description> a #GType derived from %G_TYPE_PARAM
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_list_free_1">
<description>
Frees one #GList element.
It is usually used after g_list_remove_link().

</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList element
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_is_tuple">
<description>
Determines if the given @type is a tuple type.  This is true if the
type string for @type starts with a '(' or if @type is
%G_VARIANT_TYPE_TUPLE.

This function returns %TRUE for any indefinite type for which every
definite subtype is a tuple type -- %G_VARIANT_TYPE_TUPLE, for
example.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is a tuple type
</return>
</function>

<function name="g_async_queue_length">
<description>
Returns the length of the queue, negative values mean waiting
threads, positive values mean available entries in the
@queue. Actually this function returns the number of data items in
the queue minus the number of waiting threads. Thus a return value
of 0 could mean 'n' entries in the queue and 'n' thread waiting.
That can happen due to locking of the queue or due to
scheduling.  


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return> the length of the @queue.
</return>
</function>

<function name="g_ascii_strtoll">
<description>
Converts a string to a #gint64 value.
This function behaves like the standard strtoll() function
does in the C locale. It does this without actually
changing the current locale, since that would not be
thread-safe.

This function is typically used when reading configuration
files or other non-user input that should be locale independent.
To handle input from the user you should normally use the
locale-sensitive system strtoll() function.

If the correct value would cause overflow, %G_MAXINT64 or %G_MININT64
is returned, and %ERANGE is stored in %errno.  If the base is
outside the valid range, zero is returned, and %EINVAL is stored
in %errno.  If the string conversion fails, zero is returned, and
@endptr returns @nptr (if @endptr is non-%NULL).

Since: 2.12

</description>
<parameters>
<parameter name="nptr">
<parameter_description>    the string to convert to a numeric value.
</parameter_description>
</parameter>
<parameter name="endptr">
<parameter_description>  if non-%NULL, it returns the character after
the last character used in the conversion.
</parameter_description>
</parameter>
<parameter name="base">
<parameter_description>    to be used for the conversion, 2..36 or 0
</parameter_description>
</parameter>
</parameters>
<return> the #gint64 value or zero on error.

</return>
</function>

<function name="g_pattern_spec_equal">
<description>
Compares two compiled pattern specs and returns whether they will
match the same set of strings.

</description>
<parameters>
<parameter name="pspec1">
<parameter_description> a #GPatternSpec
</parameter_description>
</parameter>
<parameter name="pspec2">
<parameter_description> another #GPatternSpec
</parameter_description>
</parameter>
</parameters>
<return> Whether the compiled patterns are equal
</return>
</function>

<function name="g_mkdir">
<description>
A wrapper for the POSIX mkdir() function. The mkdir() function 
attempts to create a directory with the given name and permissions.
The mode argument is ignored on Windows.

See your C library manual for more details about mkdir().

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> permissions to use for the newly created directory
</parameter_description>
</parameter>
</parameters>
<return> 0 if the directory was successfully created, -1 if an error 
occurred

</return>
</function>

<function name="g_option_context_get_summary">
<description>
Returns the summary. See g_option_context_set_summary().

Since: 2.12

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
</parameters>
<return> the summary

</return>
</function>

<function name="g_object_class_override_property">
<description>
Registers @property_id as referring to a property with the
name @name in a parent class or in an interface implemented
by @oclass. This allows this class to &lt;firstterm&gt;override&lt;/firstterm&gt;
a property implementation in a parent class or to provide
the implementation of a property from an interface.

&lt;note&gt;
Internally, overriding is implemented by creating a property of type
#GParamSpecOverride; generally operations that query the properties of
the object class, such as g_object_class_find_property() or
g_object_class_list_properties() will return the overridden
property. However, in one case, the @construct_properties argument of
the @constructor virtual function, the #GParamSpecOverride is passed
instead, so that the @param_id field of the #GParamSpec will be
correct.  For virtually all uses, this makes no difference. If you
need to get the overridden property, you can call
g_param_spec_get_redirect_target().
&lt;/note&gt;

Since: 2.4

</description>
<parameters>
<parameter name="oclass">
<parameter_description> a #GObjectClass
</parameter_description>
</parameter>
<parameter name="property_id">
<parameter_description> the new property ID
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> the name of a property registered in a parent class or
in an interface of this class.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_unichar_isalpha">
<description>
Determines whether a character is alphabetic (i.e. a letter).
Given some UTF-8 text, obtain a character value with
g_utf8_get_char().


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is an alphabetic character
</return>
</function>

<function name="g_queue_unlink">
<description>
Unlinks @link_ so that it will no longer be part of @queue. The link is
not freed.

@link_ must be part of @queue,

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="link_">
<parameter_description> a #GList link that &lt;emphasis&gt;must&lt;/emphasis&gt; be part of @queue
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_win32_new_socket">
<description>
Creates a new #GIOChannel given a socket on Windows.

This function works for sockets created by Winsock. It's available
only in GLib on Windows.

Polling a #GSource created to watch a channel for a socket puts the
socket in non-blocking mode. This is a side-effect of the
implementation and unavoidable.

</description>
<parameters>
<parameter name="socket">
<parameter_description> a Winsock socket
</parameter_description>
</parameter>
</parameters>
<return> a new #GIOChannel
</return>
</function>

<function name="g_source_destroy">
<description>
Removes a source from its #GMainContext, if any, and mark it as
destroyed.  The source cannot be subsequently added to another
context.

</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_get_is_private">
<description>
Gets whether the private flag of the bookmark for @uri is set.

In the event the URI cannot be found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
event that the private flag cannot be found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the private flag is set, %FALSE otherwise.

</return>
</function>

<function name="g_source_set_closure">
<description>
Set the callback for a source as a #GClosure.

If the source is not one of the standard GLib types, the @closure_callback
and @closure_marshal fields of the #GSourceFuncs structure must have been
filled in with pointers to appropriate functions.

</description>
<parameters>
<parameter name="source">
<parameter_description> the source
</parameter_description>
</parameter>
<parameter name="closure">
<parameter_description> a #GClosure
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_interface_peek_parent">
<description>
Returns the corresponding #GTypeInterface structure of the parent type
of the instance type to which @g_iface belongs. This is useful when
deriving the implementation of an interface from the parent type and
then possibly overriding some methods.


</description>
<parameters>
<parameter name="g_iface">
<parameter_description> A #GTypeInterface structure.
</parameter_description>
</parameter>
</parameters>
<return> The corresponding #GTypeInterface structure of the parent
type of the instance type to which @g_iface belongs, or
%NULL if the parent type doesn't conform to the interface.
</return>
</function>

<function name="g_variant_type_value">
<description>
Determines the value type of a dictionary entry type.

This function may only be used with a dictionary entry type.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a dictionary entry #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> the value type of the dictionary entry
</return>
</function>

<function name="g_cclosure_marshal_VOID__CHAR">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gchar arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #gchar parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_set_encoding">
<description>
Sets the encoding for the input/output of the channel. 
The internal encoding is always UTF-8. The default encoding 
for the external file is UTF-8.

The encoding %NULL is safe to use with binary data.

The encoding can only be set if one of the following conditions
is true:
&lt;itemizedlist&gt;
&lt;listitem&gt;&lt;para&gt;
The channel was just created, and has not been written to or read 
from yet.
&lt;/para&gt;&lt;/listitem&gt;
&lt;listitem&gt;&lt;para&gt;
The channel is write-only.
&lt;/para&gt;&lt;/listitem&gt;
&lt;listitem&gt;&lt;para&gt;
The channel is a file, and the file pointer was just
repositioned by a call to g_io_channel_seek_position().
(This flushes all the internal buffers.)
&lt;/para&gt;&lt;/listitem&gt;
&lt;listitem&gt;&lt;para&gt;
The current encoding is %NULL or UTF-8.
&lt;/para&gt;&lt;/listitem&gt;
&lt;listitem&gt;&lt;para&gt;
One of the (new API) read functions has just returned %G_IO_STATUS_EOF
(or, in the case of g_io_channel_read_to_end(), %G_IO_STATUS_NORMAL).
&lt;/para&gt;&lt;/listitem&gt;
&lt;listitem&gt;&lt;para&gt;
One of the functions g_io_channel_read_chars() or 
g_io_channel_read_unichar() has returned %G_IO_STATUS_AGAIN or 
%G_IO_STATUS_ERROR. This may be useful in the case of 
%G_CONVERT_ERROR_ILLEGAL_SEQUENCE.
Returning one of these statuses from g_io_channel_read_line(),
g_io_channel_read_line_string(), or g_io_channel_read_to_end()
does &lt;emphasis&gt;not&lt;/emphasis&gt; guarantee that the encoding can 
be changed.
&lt;/para&gt;&lt;/listitem&gt;
&lt;/itemizedlist&gt;
Channels which do not meet one of the above conditions cannot call
g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if 
they are &quot;seekable&quot;, cannot call g_io_channel_write_chars() after 
calling one of the API &quot;read&quot; functions.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="encoding">
<parameter_description> the encoding type
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store an error of type #GConvertError
</parameter_description>
</parameter>
</parameters>
<return> %G_IO_STATUS_NORMAL if the encoding was successfully set.
</return>
</function>

<function name="g_mapped_file_get_contents">
<description>
Returns the contents of a #GMappedFile. 

Note that the contents may not be zero-terminated,
even if the #GMappedFile is backed by a text file.

If the file is empty then %NULL is returned.

Since: 2.8

</description>
<parameters>
<parameter name="file">
<parameter_description> a #GMappedFile
</parameter_description>
</parameter>
</parameters>
<return> the contents of @file, or %NULL.

</return>
</function>

<function name="g_type_create_instance">
<description>
Creates and initializes an instance of @type if @type is valid and
can be instantiated. The type system only performs basic allocation
and structure setups for instances: actual instance creation should
happen through functions supplied by the type's fundamental type
implementation.  So use of g_type_create_instance() is reserved for
implementators of fundamental types only. E.g. instances of the
#GObject hierarchy should be created via g_object_new() and
&lt;emphasis&gt;never&lt;/emphasis&gt; directly through
g_type_create_instance() which doesn't handle things like singleton
objects or object construction.  Note: Do &lt;emphasis&gt;not&lt;/emphasis&gt;
use this function, unless you're implementing a fundamental
type. Also language bindings should &lt;emphasis&gt;not&lt;/emphasis&gt; use
this function but g_object_new() instead.


</description>
<parameters>
<parameter name="type">
<parameter_description> An instantiatable type to create an instance for.
</parameter_description>
</parameter>
</parameters>
<return> An allocated and initialized instance, subject to further
treatment by the fundamental type implementation.
</return>
</function>

<function name="g_qsort_with_data">
<description>
This is just like the standard C qsort() function, but
the comparison routine accepts a user data argument.


</description>
<parameters>
<parameter name="pbase">
<parameter_description> start of array to sort
</parameter_description>
</parameter>
<parameter name="total_elems">
<parameter_description> elements in the array
</parameter_description>
</parameter>
<parameter name="size">
<parameter_description> size of each element
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> function to compare elements
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> data to pass to @compare_func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_builder_end">
<description>
Ends the builder process and returns the constructed value.

It is not permissible to use @builder in any way after this call
except for reference counting operations (in the case of a
heap-allocated #GVariantBuilder) or by reinitialising it with
g_variant_builder_init() (in the case of stack-allocated).

It is an error to call this function in any way that would create an
inconsistent value to be constructed (ie: insufficient number of
items added to a container with a specific number of children
required).  It is also an error to call this function if the builder
was created with an indefinite array or maybe type and no children
have been added; in this case it is impossible to infer the type of
the empty array.

Since: 2.24

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder
</parameter_description>
</parameter>
</parameters>
<return> a new, floating, #GVariant
</return>
</function>

<function name="g_static_rec_mutex_lock_full">
<description>
Works like calling g_static_rec_mutex_lock() for @mutex @depth times.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticRecMutex to lock.
</parameter_description>
</parameter>
<parameter name="depth">
<parameter_description> number of times this mutex has to be unlocked to be
completely unlocked.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_type_transformable">
<description>
Check whether g_value_transform() is able to transform values
of type @src_type into values of type @dest_type.


</description>
<parameters>
<parameter name="src_type">
<parameter_description> Source type.
</parameter_description>
</parameter>
<parameter name="dest_type">
<parameter_description> Target type.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the transformation is possible, %FALSE otherwise.
</return>
</function>

<function name="g_main_context_ref">
<description>
Increases the reference count on a #GMainContext object by one.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
</parameters>
<return> the @context that was passed in (since 2.6)
</return>
</function>

<function name="g_variant_builder_unref">
<description>
Decreases the reference count on @builder.

In the event that there are no more references, releases all memory
associated with the #GVariantBuilder.

Don't call this on stack-allocated #GVariantBuilder instances or bad
things will happen.

Since: 2.24

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder allocated by g_variant_builder_new()
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_test_timer_start">
<description>
Start a timing test. Call g_test_timer_elapsed() when the task is supposed
to be done. Call this function again to restart the timer.

Since: 2.16

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_closure_sink">
<description>
Takes over the initial ownership of a closure.  Each closure is
initially created in a &lt;firstterm&gt;floating&lt;/firstterm&gt; state, which
means that the initial reference count is not owned by any caller.
g_closure_sink() checks to see if the object is still floating, and
if so, unsets the floating state and decreases the reference
count. If the closure is not floating, g_closure_sink() does
nothing. The reason for the existance of the floating state is to
prevent cumbersome code sequences like:
|[
closure = g_cclosure_new (cb_func, cb_data);
g_source_set_closure (source, closure);
g_closure_unref (closure); // XXX GObject doesn't really need this
]|
Because g_source_set_closure() (and similar functions) take ownership of the
initial reference count, if it is unowned, we instead can write:
|[
g_source_set_closure (source, g_cclosure_new (cb_func, cb_data));
]|

Generally, this function is used together with g_closure_ref(). Ane example
of storing a closure for later notification looks like:
|[
static GClosure *notify_closure = NULL;
void
foo_notify_set_closure (GClosure *closure)
{
if (notify_closure)
g_closure_unref (notify_closure);
notify_closure = closure;
if (notify_closure)
{
g_closure_ref (notify_closure);
g_closure_sink (notify_closure);
}
}
]|

Because g_closure_sink() may decrement the reference count of a closure
(if it hasn't been called on @closure yet) just like g_closure_unref(),
g_closure_ref() should be called prior to this function.

</description>
<parameters>
<parameter name="closure">
<parameter_description> #GClosure to decrement the initial reference count on, if it's
still being held
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_dir_rewind">
<description>
Resets the given directory. The next call to g_dir_read_name()
will return the first entry again.

</description>
<parameters>
<parameter name="dir">
<parameter_description> a #GDir* created by g_dir_open()
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_handlers_unblock_matched">
<description>
Unblocks all handlers on an instance that match a certain selection
criteria. The criteria mask is passed as an OR-ed combination of
#GSignalMatchType flags, and the criteria values are passed as arguments.
Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC
or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
If no handlers were found, 0 is returned, the number of unblocked handlers
otherwise. The match criteria should not apply to any handlers that are
not currently blocked.


</description>
<parameters>
<parameter name="instance">
<parameter_description> The instance to unblock handlers from.
</parameter_description>
</parameter>
<parameter name="mask">
<parameter_description> Mask indicating which of @signal_id, @detail, @closure, @func
and/or @data the handlers have to match.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> Signal the handlers have to be connected to.
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> Signal detail the handlers have to be connected to.
</parameter_description>
</parameter>
<parameter name="closure">
<parameter_description> The closure the handlers will invoke.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> The C closure callback of the handlers (useless for non-C closures).
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> The closure data of the handlers' closures.
</parameter_description>
</parameter>
</parameters>
<return> The number of handlers that matched.
</return>
</function>

<function name="g_key_file_has_key">
<description>
Looks whether the key file has the key @key in the group
@group_name. 

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key name
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @key is a part of @group_name, %FALSE
otherwise.

</return>
</function>

<function name="g_allocator_new">
<description>
Creates a new #GAllocator.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
<parameter name="name">
<parameter_description> the name of the #GAllocator. This name is used to set the
name of the #GMemChunk used by the #GAllocator, and is only
used for debugging.
</parameter_description>
</parameter>
<parameter name="n_preallocs">
<parameter_description> the number of elements in each block of memory
allocated.  Larger blocks mean less calls to
g_malloc(), but some memory may be wasted.  (GLib uses
128 elements per block by default.) The value must be
between 1 and 65535.
</parameter_description>
</parameter>
</parameters>
<return> a new #GAllocator.
</return>
</function>

<function name="g_markup_parse_context_parse">
<description>
Feed some data to the #GMarkupParseContext. The data need not
be valid UTF-8; an error will be signaled if it's invalid.
The data need not be an entire document; you can feed a document
into the parser incrementally, via multiple calls to this function.
Typically, as you receive data from a network connection or file,
you feed each received chunk of data into this function, aborting
the process if an error occurs. Once an error is reported, no further
data may be fed to the #GMarkupParseContext; all errors are fatal.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMarkupParseContext
</parameter_description>
</parameter>
<parameter name="text">
<parameter_description> chunk of text to parse
</parameter_description>
</parameter>
<parameter name="text_len">
<parameter_description> length of @text in bytes
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> %FALSE if an error occurred, %TRUE on success
</return>
</function>

<function name="g_io_add_watch_full">
<description>
Adds the #GIOChannel into the default main loop context
with the given priority.

This internally creates a main loop source using g_io_create_watch()
and attaches it to the main loop context with g_source_attach().
You can do these steps manuallt if you need greater control.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="priority">
<parameter_description> the priority of the #GIOChannel source
</parameter_description>
</parameter>
<parameter name="condition">
<parameter_description> the condition to watch for
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call when the condition is satisfied
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to @func
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description> the function to call when the source is removed
</parameter_description>
</parameter>
</parameters>
<return> the event source id
</return>
</function>

<function name="g_file_read_link">
<description>
Reads the contents of the symbolic link @filename like the POSIX
readlink() function.  The returned string is in the encoding used
for filenames. Use g_filename_to_utf8() to convert it to UTF-8.

Since: 2.4

</description>
<parameters>
<parameter name="filename">
<parameter_description> the symbolic link
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> A newly-allocated string with the contents of the symbolic link, 
or %NULL if an error occurred.

</return>
</function>

<function name="g_signal_lookup">
<description>
Given the name of the signal and the type of object it connects to, gets
the signal's identifying integer. Emitting the signal by number is
somewhat faster than using the name each time.

Also tries the ancestors of the given type.

See g_signal_new() for details on allowed signal names.


</description>
<parameters>
<parameter name="name">
<parameter_description> the signal's name.
</parameter_description>
</parameter>
<parameter name="itype">
<parameter_description> the type that the signal operates on.
</parameter_description>
</parameter>
</parameters>
<return> the signal's identifying number, or 0 if no signal was found.
</return>
</function>

<function name="g_strlcat">
<description>
Portability wrapper that calls strlcat() on systems which have it, 
and emulates it otherwise. Appends nul-terminated @src string to @dest, 
guaranteeing nul-termination for @dest. The total size of @dest won't 
exceed @dest_size. 

At most dest_size - 1 characters will be copied.
Unlike strncat, dest_size is the full size of dest, not the space left over.
This function does NOT allocate memory.
This always NUL terminates (unless siz == 0 or there were no NUL characters
in the dest_size characters of dest to start with).

&lt;note&gt;&lt;para&gt;Caveat: this is supposedly a more secure alternative to 
strcat() or strncat(), but for real security g_strconcat() is harder 
to mess up.&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="dest">
<parameter_description> destination buffer, already containing one nul-terminated string
</parameter_description>
</parameter>
<parameter name="src">
<parameter_description> source buffer
</parameter_description>
</parameter>
<parameter name="dest_size">
<parameter_description> length of @dest buffer in bytes (not length of existing string 
inside @dest)
</parameter_description>
</parameter>
</parameters>
<return> size of attempted result, which is MIN (dest_size, strlen
(original dest)) + strlen (src), so if retval &gt;= dest_size,
truncation occurred.
</return>
</function>

<function name="g_async_queue_unref_and_unlock">
<description>
Decreases the reference count of the asynchronous @queue by 1 and
releases the lock. This function must be called while holding the
@queue's lock. If the reference count went to 0, the @queue will be
destroyed and the memory allocated will be freed.

@Deprecated: Since 2.8, reference counting is done atomically
so g_async_queue_unref() can be used regardless of the @queue's
lock.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_copy">
<description>
Copies a #GList.

&lt;note&gt;&lt;para&gt;
Note that this is a &quot;shallow&quot; copy. If the list elements 
consist of pointers to data, the pointers are copied but 
the actual data is not.
&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
</parameters>
<return> a copy of @list
</return>
</function>

<function name="g_base64_decode_step">
<description>
Incrementally decode a sequence of binary data from its Base-64 stringified
representation. By calling this function multiple times you can convert 
data in chunks to avoid having to have the full encoded data in memory.

The output buffer must be large enough to fit all the data that will
be written to it. Since base64 encodes 3 bytes in 4 chars you need
at least: (@len / 4) * 3 + 3 bytes (+ 3 may be needed in case of non-zero
state).

Since: 2.12

</description>
<parameters>
<parameter name="in">
<parameter_description> binary input data
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> max length of @in data to decode
</parameter_description>
</parameter>
<parameter name="out">
<parameter_description> output buffer
</parameter_description>
</parameter>
<parameter name="state">
<parameter_description> Saved state between steps, initialize to 0
</parameter_description>
</parameter>
<parameter name="save">
<parameter_description> Saved state between steps, initialize to 0
</parameter_description>
</parameter>
</parameters>
<return> The number of bytes of output that was written

</return>
</function>

<function name="g_convert">
<description>
Converts a string from one character set to another.

Note that you should use g_iconv() for streaming 
conversions&lt;footnoteref linkend=&quot;streaming-state&quot;/&gt;.


</description>
<parameters>
<parameter name="str">
<parameter_description>           the string to convert
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description>           the length of the string, or -1 if the string is 
nul-terminated&lt;footnote id=&quot;nul-unsafe&quot;&gt;
                     &lt;para&gt;
                       Note that some encodings may allow nul bytes to 
                       occur inside strings. In that case, using -1 for 
                       the @len parameter is unsafe.
                     &lt;/para&gt;
                   &lt;/footnote&gt;. 
</parameter_description>
</parameter>
<parameter name="to_codeset">
<parameter_description>    name of character set into which to convert @str
</parameter_description>
</parameter>
<parameter name="from_codeset">
<parameter_description>  character set of @str.
</parameter_description>
</parameter>
<parameter name="bytes_read">
<parameter_description>    location to store the number of bytes in the
input string that were successfully converted, or %NULL.
Even if the conversion was successful, this may be 
less than @len if there were partial characters
at the end of the input. If the error
#G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
stored will the byte offset after the last valid
input sequence.
</parameter_description>
</parameter>
<parameter name="bytes_written">
<parameter_description> the number of bytes stored in the output buffer (not 
including the terminating nul).
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description>         location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError may occur.
</parameter_description>
</parameter>
</parameters>
<return> If the conversion was successful, a newly allocated
nul-terminated string, which must be freed with
g_free(). Otherwise %NULL and @error will be set.
</return>
</function>

<function name="g_main_context_add_poll">
<description>
Adds a file descriptor to the set of file descriptors polled for
this context. This will very seldomly be used directly. Instead
a typical event source will use g_source_add_poll() instead.

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext (or %NULL for the default context)
</parameter_description>
</parameter>
<parameter name="fd">
<parameter_description> a #GPollFD structure holding information about a file
descriptor to watch.
</parameter_description>
</parameter>
<parameter name="priority">
<parameter_description> the priority for this file descriptor which should be
the same as the priority used for g_source_attach() to ensure that the
file descriptor is polled whenever the results may be needed.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_test_run_suite">
<description>
Execute the tests within @suite and all nested #GTestSuites.
The test suites to be executed are filtered according to
test path arguments (-p &lt;replaceable&gt;testpath&lt;/replaceable&gt;) 
as parsed by g_test_init().
g_test_run_suite() or g_test_run() may only be called once
in a program.

Since: 2.16

</description>
<parameters>
<parameter name="suite">
<parameter_description> a #GTestSuite
</parameter_description>
</parameter>
</parameters>
<return> 0 on success

</return>
</function>

<function name="g_tuples_index">
<description>
Gets a field from the records returned by g_relation_select(). It
returns the given field of the record at the given index. The
returned value should not be changed.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="tuples">
<parameter_description> the tuple data, returned by g_relation_select().
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the record.
</parameter_description>
</parameter>
<parameter name="field">
<parameter_description> the field to return.
</parameter_description>
</parameter>
</parameters>
<return> the field of the record.
</return>
</function>

<function name="g_quark_from_string">
<description>
Gets the #GQuark identifying the given string. If the string does
not currently have an associated #GQuark, a new #GQuark is created,
using a copy of the string.

</description>
<parameters>
<parameter name="string">
<parameter_description> a string.
</parameter_description>
</parameter>
</parameters>
<return> the #GQuark identifying the string, or 0 if @string is
%NULL.
</return>
</function>

<function name="g_variant_builder_close">
<description>
Closes the subcontainer inside the given @builder that was opened by
the most recent call to g_variant_builder_open().

It is an error to call this function in any way that would create an
inconsistent value to be constructed (ie: too few values added to the
subcontainer).

Since: 2.24

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_emit_by_name">
<description>
Emits a signal.

Note that g_signal_emit_by_name() resets the return value to the default
if no handlers are connected, in contrast to g_signal_emitv().

</description>
<parameters>
<parameter name="instance">
<parameter_description> the instance the signal is being emitted on.
</parameter_description>
</parameter>
<parameter name="detailed_signal">
<parameter_description> a string of the form &quot;signal-name::detail&quot;.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> parameters to be passed to the signal, followed by a
location for the return value. If the return type of the signal
is #G_TYPE_NONE, the return value location can be omitted.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_datalist_id_remove_no_notify">
<description>
Removes an element, without calling its destroy notification
function.

</description>
<parameters>
<parameter name="datalist">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="key_id">
<parameter_description> the #GQuark identifying a data element.
</parameter_description>
</parameter>
</parameters>
<return> the data previously stored at @key_id, or %NULL if none.
</return>
</function>

<function name="g_signal_type_cclosure_new">
<description>
Creates a new closure which invokes the function found at the offset
@struct_offset in the class structure of the interface or classed type
identified by @itype.


</description>
<parameters>
<parameter name="itype">
<parameter_description> the #GType identifier of an interface or classed type
</parameter_description>
</parameter>
<parameter name="struct_offset">
<parameter_description> the offset of the member function of @itype's class
structure which is to be invoked by the new closure
</parameter_description>
</parameter>
</parameters>
<return> a new #GCClosure
</return>
</function>

<function name="g_str_equal">
<description>
Compares two strings for byte-by-byte equality and returns %TRUE
if they are equal. It can be passed to g_hash_table_new() as the
@key_equal_func parameter, when using strings as keys in a #GHashTable.

Note that this function is primarily meant as a hash table comparison
function. For a general-purpose, %NULL-safe string comparison function,
see g_strcmp0().


</description>
<parameters>
<parameter name="v1">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="v2">
<parameter_description> a key to compare with @v1
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the two keys match
</return>
</function>

<function name="g_type_class_ref">
<description>
Increments the reference count of the class structure belonging to
@type. This function will demand-create the class if it doesn't
exist already.


</description>
<parameters>
<parameter name="type">
<parameter_description> Type ID of a classed type.
</parameter_description>
</parameter>
</parameters>
<return> The #GTypeClass structure for the given type ID.
</return>
</function>

<function name="g_bookmark_file_has_item">
<description>
Looks whether the desktop bookmark has an item with its URI set to @uri.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @uri is inside @bookmark, %FALSE otherwise

</return>
</function>

<function name="g_param_spec_variant">
<description>
Creates a new #GParamSpecVariant instance specifying a #GVariant
property.

If @default_value is floating, it is consumed.

See g_param_spec_internal() for details on property names.

Since: 2.26

</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> a #GVariant of type @type to use as the
default value, or %NULL
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> the newly created #GParamSpec

</return>
</function>

<function name="g_source_unref">
<description>
Decreases the reference count of a source by one. If the
resulting reference count is zero the source and associated
memory will be destroyed. 

</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_relation_insert">
<description>
Inserts a record into a #GRelation.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="relation">
<parameter_description> a #GRelation.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the fields of the record to add. These must match the
number of fields in the #GRelation, and of type #gpointer
or #gconstpointer.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_atomic_int_add">
<description>
Atomically adds @val to the integer pointed to by @atomic.
Also acts as a memory barrier.

Since: 2.4

</description>
<parameters>
<parameter name="atomic">
<parameter_description> a pointer to an integer
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> the value to add to *@atomic
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ptr_array_remove_index">
<description>
Removes the pointer at the given index from the pointer array. The
following elements are moved down one place. If @array has a
non-%NULL #GDestroyNotify function it is called for the removed
element.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the pointer to remove.
</parameter_description>
</parameter>
</parameters>
<return> the pointer which was removed.
</return>
</function>

<function name="g_utf8_prev_char">
<description>
Finds the previous UTF-8 character in the string before @p.

@p does not have to be at the beginning of a UTF-8 character. No check
is made to see if the character found is actually valid other than
it starts with an appropriate byte. If @p might be the first
character of the string, you must use g_utf8_find_prev_char() instead.


</description>
<parameters>
<parameter name="p">
<parameter_description> a pointer to a position within a UTF-8 encoded string
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the found character.
</return>
</function>

<function name="g_fprintf">
<description>
An implementation of the standard fprintf() function which supports 
positional parameters, as specified in the Single Unix Specification.

Since: 2.2

</description>
<parameters>
<parameter name="file">
<parameter_description> the stream to write to.
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice 
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the arguments to insert in the output.
</parameter_description>
</parameter>
</parameters>
<return> the number of bytes printed.

</return>
</function>

<function name="g_value_set_double">
<description>
Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_DOUBLE
</parameter_description>
</parameter>
<parameter name="v_double">
<parameter_description> double value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="find_conversion">
<description>
Find the next conversion in a printf-style format string.
Partially based on code from printf-parser.c,
Copyright (C) 1999-2000, 2002-2003 Free Software Foundation, Inc.


</description>
<parameters>
<parameter name="format">
<parameter_description> a printf-style format string
</parameter_description>
</parameter>
<parameter name="after">
<parameter_description> location to store a pointer to the character after
the returned conversion. On a %NULL return, returns the
pointer to the trailing NUL in the string
</parameter_description>
</parameter>
</parameters>
<return> pointer to the next conversion in @format,
or %NULL, if none.
</return>
</function>

<function name="g_filename_from_utf8">
<description>
Converts a string from UTF-8 to the encoding GLib uses for
filenames. Note that on Windows GLib uses UTF-8 for filenames;
on other platforms, this function indirectly depends on the 
&lt;link linkend=&quot;setlocale&quot;&gt;current locale&lt;/link&gt;.


</description>
<parameters>
<parameter name="utf8string">
<parameter_description>    a UTF-8 encoded string.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description>           the length of the string, or -1 if the string is
nul-terminated.
</parameter_description>
</parameter>
<parameter name="bytes_read">
<parameter_description>    location to store the number of bytes in the
input string that were successfully converted, or %NULL.
Even if the conversion was successful, this may be 
less than @len if there were partial characters
at the end of the input. If the error
#G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
stored will the byte offset after the last valid
input sequence.
</parameter_description>
</parameter>
<parameter name="bytes_written">
<parameter_description> the number of bytes stored in the output buffer (not 
including the terminating nul).
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description>         location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError may occur.
</parameter_description>
</parameter>
</parameters>
<return> The converted string, or %NULL on an error.
</return>
</function>

<function name="g_variant_get_normal_form">
<description>
Gets a #GVariant instance that has the same value as @value and is
trusted to be in normal form.

If @value is already trusted to be in normal form then a new
reference to @value is returned.

If @value is not already trusted, then it is scanned to check if it
is in normal form.  If it is found to be in normal form then it is
marked as trusted and a new reference to it is returned.

If @value is found not to be in normal form then a new trusted
#GVariant is created with the same value as @value.

It makes sense to call this function if you've received #GVariant
data from untrusted sources and you want to ensure your serialised
output is definitely in normal form.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return> a trusted #GVariant
</return>
</function>

<function name="g_value_set_gtype">
<description>
Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.

Since: 2.12

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_GTYPE
</parameter_description>
</parameter>
<parameter name="v_gtype">
<parameter_description> #GType to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_fits_pointer">
<description>
Determines if @value will fit inside the size of a pointer value.
This is an internal function introduced mainly for C marshallers.


</description>
<parameters>
<parameter name="value">
<parameter_description> An initialized #GValue structure.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @value will fit inside a pointer value.
</return>
</function>

<function name="g_byte_array_append">
<description>
Adds the given bytes to the end of the #GByteArray. The array will
grow in size automatically if necessary.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GByteArray.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the byte data to be added.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the number of bytes to add.
</parameter_description>
</parameter>
</parameters>
<return> the #GByteArray.
</return>
</function>

<function name="g_slist_sort">
<description>
Sorts a #GSList using the given comparison function.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> the comparison function used to sort the #GSList.
This function is passed the data from 2 elements of the #GSList 
and should return 0 if they are equal, a negative value if the 
first element comes before the second, or a positive value if 
the first element comes after the second.
</parameter_description>
</parameter>
</parameters>
<return> the start of the sorted #GSList
</return>
</function>

<function name="g_list_free">
<description>
Frees all of the memory used by a #GList.
The freed elements are returned to the slice allocator.

&lt;note&gt;&lt;para&gt;
If list elements contain dynamically-allocated memory, 
they should be freed first.
&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_async_queue_length_unlocked">
<description>
Returns the length of the queue, negative values mean waiting
threads, positive values mean available entries in the
@queue. Actually this function returns the number of data items in
the queue minus the number of waiting threads. Thus a return value
of 0 could mean 'n' entries in the queue and 'n' thread waiting.
That can happen due to locking of the queue or due to
scheduling. This function must be called while holding the @queue's
lock.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return> the length of the @queue.
</return>
</function>

<function name="g_list_free1">
<description>
Another name for g_list_free_1().

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_hash_table_new_full">
<description>
Creates a new #GHashTable like g_hash_table_new() with a reference count
of 1 and allows to specify functions to free the memory allocated for the
key and value that get called when removing the entry from the #GHashTable.


</description>
<parameters>
<parameter name="hash_func">
<parameter_description> a function to create a hash value from a key.
</parameter_description>
</parameter>
<parameter name="key_equal_func">
<parameter_description> a function to check two keys for equality.
</parameter_description>
</parameter>
<parameter name="key_destroy_func">
<parameter_description> a function to free the memory allocated for the key
used when removing the entry from the #GHashTable or %NULL if you
don't want to supply such a function.
</parameter_description>
</parameter>
<parameter name="value_destroy_func">
<parameter_description> a function to free the memory allocated for the
value used when removing the entry from the #GHashTable or %NULL if
you don't want to supply such a function.
</parameter_description>
</parameter>
</parameters>
<return> a new #GHashTable.
</return>
</function>

<function name="g_io_channel_set_buffered">
<description>
The buffering state can only be set if the channel's encoding
is %NULL. For any other encoding, the channel must be buffered.

A buffered channel can only be set unbuffered if the channel's
internal buffers have been flushed. Newly created channels or
channels which have returned %G_IO_STATUS_EOF
not require such a flush. For write-only channels, a call to
g_io_channel_flush () is sufficient. For all other channels,
the buffers may be flushed by a call to g_io_channel_seek_position ().
This includes the possibility of seeking with seek type %G_SEEK_CUR
and an offset of zero. Note that this means that socket-based
channels cannot be set unbuffered once they have had data
read from them.

On unbuffered channels, it is safe to mix read and write
calls from the new and old APIs, if this is necessary for
maintaining old code.

The default state of the channel is buffered.

</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="buffered">
<parameter_description> whether to set the channel buffered or unbuffered
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_utf8_find_prev_char">
<description>
Given a position @p with a UTF-8 encoded string @str, find the start
of the previous UTF-8 character starting before @p. Returns %NULL if no
UTF-8 characters are present in @str before @p.

@p does not have to be at the beginning of a UTF-8 character. No check
is made to see if the character found is actually valid other than
it starts with an appropriate byte.


</description>
<parameters>
<parameter name="str">
<parameter_description> pointer to the beginning of a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="p">
<parameter_description> pointer to some position within @str
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the found character or %NULL.
</return>
</function>

<function name="g_sequence_move">
<description>
Moves the item pointed to by @src to the position indicated by @dest.
After calling this function @dest will point to the position immediately
after @src. It is allowed for @src and @dest to point into different
sequences.

Since: 2.14

</description>
<parameters>
<parameter name="src">
<parameter_description> a #GSequenceIter pointing to the item to move
</parameter_description>
</parameter>
<parameter name="dest">
<parameter_description> a #GSequenceIter pointing to the position to which
the item is moved.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cond_wait">
<description>
Waits until this thread is woken up on @cond. The @mutex is unlocked
before falling asleep and locked again before resuming.

This function can be used even if g_thread_init() has not yet been
called, and, in that case, will immediately return.

</description>
<parameters>
<parameter name="cond">
<parameter_description> a #GCond.
</parameter_description>
</parameter>
<parameter name="mutex">
<parameter_description> a #GMutex, that is currently locked.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_array_append_vals">
<description>
Adds @len elements onto the end of the array.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> a pointer to the elements to append to the end of the array.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the number of elements to append.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_variant_iter_loop">
<description>
Gets the next item in the container and unpacks it into the variable
argument list according to @format_string, returning %TRUE.

If no more items remain then %FALSE is returned.

On the first call to this function, the pointers appearing on the
variable argument list are assumed to point at uninitialised memory.
On the second and later calls, it is assumed that the same pointers
will be given and that they will point to the memory as set by the
previous call to this function.  This allows the previous values to
be freed, as appropriate.

This function is intended to be used with a while loop as
demonstrated in the following example.  This function can only be
used when iterating over an array.  It is only valid to call this
function with a string constant for the format string and the same
string constant must be used each time.  Mixing calls to this
function and g_variant_iter_next() or g_variant_iter_next_value() on
the same iterator is not recommended.

See the section on &lt;link linkend='gvariant-format-strings'&gt;GVariant
Format Strings&lt;/link&gt;.

&lt;example&gt;
&lt;title&gt;Memory management with g_variant_iter_loop()&lt;/title&gt;
&lt;programlisting&gt;
/&lt;!-- --&gt;* Iterates a dictionary of type 'a{sv}' *&lt;!-- --&gt;/
void
iterate_dictionary (GVariant *dictionary)
{
GVariantIter iter;
GVariant *value;
gchar *key;

g_variant_iter_init (&amp;iter, dictionary);
while (g_variant_iter_loop (&amp;iter, &quot;{sv}&quot;, &amp;key, &amp;value))
{
g_print (&quot;Item '%s' has type '%s'\n&quot;, key,
g_variant_get_type_string (value));

/&lt;!-- --&gt;* no need to free 'key' and 'value' here *&lt;!-- --&gt;/
}
}
&lt;/programlisting&gt;
&lt;/example&gt;

If you want a slightly less magical alternative that requires more
typing, see g_variant_iter_next().

Since: 2.24

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GVariantIter
</parameter_description>
</parameter>
<parameter name="format_string">
<parameter_description> a GVariant format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the arguments to unpack the value into
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a value was unpacked, or %FALSE if there as no
value
</return>
</function>

<function name="g_dpgettext">
<description>
This function is a variant of g_dgettext() which supports
a disambiguating message context. GNU gettext uses the
'\004' character to separate the message context and
message id in @msgctxtid.
If 0 is passed as @msgidoffset, this function will fall back to
trying to use the deprecated convention of using &quot;|&quot; as a separation
character.

This uses g_dgettext() internally.  See that functions for differences
with dgettext() proper.

Applications should normally not use this function directly,
but use the C_() macro for translations with context.

Since: 2.16

</description>
<parameters>
<parameter name="domain">
<parameter_description> the translation domain to use, or %NULL to use
the domain set with textdomain()
</parameter_description>
</parameter>
<parameter name="msgctxtid">
<parameter_description> a combined message context and message id, separated
by a \004 character
</parameter_description>
</parameter>
<parameter name="msgidoffset">
<parameter_description> the offset of the message id in @msgctxid
</parameter_description>
</parameter>
</parameters>
<return> The translated string

</return>
</function>

<function name="g_bookmark_file_set_added">
<description>
Sets the time the bookmark for @uri was added into @bookmark.

If no bookmark for @uri is found then it is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="added">
<parameter_description> a timestamp or -1 to use the current time
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_main_context_is_owner">
<description>
Determines whether this thread holds the (recursive)
ownership of this #GMaincontext. This is useful to
know before waiting on another thread that may be
blocking to get ownership of @context.

Since: 2.10

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if current thread is owner of @context.

</return>
</function>

<function name="g_datalist_get_data">
<description>
Gets a data element, using its string identifer. This is slower than
g_datalist_id_get_data() because the string is first converted to a
#GQuark.

</description>
<parameters>
<parameter name="dl">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string identifying a data element.
</parameter_description>
</parameter>
</parameters>
<return> the data element, or %NULL if it is not found.
</return>
</function>

<function name="g_dataset_set_data">
<description>
Sets the data corresponding to the given string identifier.

</description>
<parameters>
<parameter name="l">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string to identify the data element.
</parameter_description>
</parameter>
<parameter name="d">
<parameter_description> the data element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ptr_array_remove">
<description>
Removes the first occurrence of the given pointer from the pointer
array. The following elements are moved down one place. If @array
has a non-%NULL #GDestroyNotify function it is called for the
removed element.

It returns %TRUE if the pointer was removed, or %FALSE if the
pointer was not found.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the pointer to remove.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the pointer is removed. %FALSE if the pointer is
not found in the array.
</return>
</function>

<function name="g_datalist_clear">
<description>
Frees all the data elements of the datalist. The data elements'
destroy functions are called if they have been set.

</description>
<parameters>
<parameter name="datalist">
<parameter_description> a datalist.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_source_set_callback_indirect">
<description>
Sets the callback function storing the data as a refcounted callback
&quot;object&quot;. This is used internally. Note that calling 
g_source_set_callback_indirect() assumes
an initial reference count on @callback_data, and thus
@callback_funcs-&gt;unref will eventually be called once more
than @callback_funcs-&gt;ref.

</description>
<parameters>
<parameter name="source">
<parameter_description> the source
</parameter_description>
</parameter>
<parameter name="callback_data">
<parameter_description> pointer to callback data &quot;object&quot;
</parameter_description>
</parameter>
<parameter name="callback_funcs">
<parameter_description> functions for reference counting @callback_data
and getting the callback and data
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_allocator_free">
<description>
Frees all of the memory allocated by the #GAllocator.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
<parameter name="allocator">
<parameter_description> a #GAllocator.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_get_int64">
<description>
Returns the 64-bit signed integer value of @value.

It is an error to call this function with a @value of any type
other than %G_VARIANT_TYPE_INT64.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a int64 #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> a #gint64
</return>
</function>

<function name="g_strlcpy">
<description>
Portability wrapper that calls strlcpy() on systems which have it, 
and emulates strlcpy() otherwise. Copies @src to @dest; @dest is 
guaranteed to be nul-terminated; @src must be nul-terminated; 
@dest_size is the buffer size, not the number of chars to copy. 

At most dest_size - 1 characters will be copied. Always nul-terminates
(unless dest_size == 0). This function does &lt;emphasis&gt;not&lt;/emphasis&gt; 
allocate memory. Unlike strncpy(), this function doesn't pad dest (so 
it's often faster). It returns the size of the attempted result, 
strlen (src), so if @retval &gt;= @dest_size, truncation occurred.

&lt;note&gt;&lt;para&gt;Caveat: strlcpy() is supposedly more secure than
strcpy() or strncpy(), but if you really want to avoid screwups, 
g_strdup() is an even better idea.&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="dest">
<parameter_description> destination buffer
</parameter_description>
</parameter>
<parameter name="src">
<parameter_description> source buffer
</parameter_description>
</parameter>
<parameter name="dest_size">
<parameter_description> length of @dest in bytes
</parameter_description>
</parameter>
</parameters>
<return> length of @src
</return>
</function>

<function name="g_option_context_new">
<description>
Creates a new option context. 

The @parameter_string can serve multiple purposes. It can be used
to add descriptions for &quot;rest&quot; arguments, which are not parsed by
the #GOptionContext, typically something like &quot;FILES&quot; or
&quot;FILE1 FILE2...&quot;. If you are using #G_OPTION_REMAINING for
collecting &quot;rest&quot; arguments, GLib handles this automatically by
using the @arg_description of the corresponding #GOptionEntry in
the usage summary.

Another usage is to give a short summary of the program
functionality, like &quot; - frob the strings&quot;, which will be displayed
in the same line as the usage. For a longer description of the
program functionality that should be displayed as a paragraph
below the usage line, use g_option_context_set_summary().

Note that the @parameter_string is translated using the
function set with g_option_context_set_translate_func(), so
it should normally be passed untranslated.

Since: 2.6

</description>
<parameters>
<parameter name="parameter_string">
<parameter_description> a string which is displayed in
the first line of &lt;option&gt;--help&lt;/option&gt; output, after the
usage summary 
&lt;literal&gt;&lt;replaceable&gt;programname&lt;/replaceable&gt; [OPTION...]&lt;/literal&gt;
</parameter_description>
</parameter>
</parameters>
<return> a newly created #GOptionContext, which must be
freed with g_option_context_free() after use.

</return>
</function>

<function name="g_key_file_has_group">
<description>
Looks whether the key file has the group @group_name.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @group_name is a part of @key_file, %FALSE
otherwise.
</return>
</function>

<function name="g_param_value_validate">
<description>
Ensures that the contents of @value comply with the specifications
set out by @pspec. For example, a #GParamSpecInt might require
that integers stored in @value may not be smaller than -42 and not be
greater than +42. If @value contains an integer outside of this range,
it is modified accordingly, so the resulting value will fit into the
range -42 .. +42.


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> a #GValue of correct type for @pspec
</parameter_description>
</parameter>
</parameters>
<return> whether modifying @value was necessary to ensure validity
</return>
</function>

<function name="g_signal_handler_find">
<description>
Finds the first signal handler that matches certain selection criteria.
The criteria mask is passed as an OR-ed combination of #GSignalMatchType
flags, and the criteria values are passed as arguments.
The match @mask has to be non-0 for successful matches.
If no handler was found, 0 is returned.


</description>
<parameters>
<parameter name="instance">
<parameter_description> The instance owning the signal handler to be found.
</parameter_description>
</parameter>
<parameter name="mask">
<parameter_description> Mask indicating which of @signal_id, @detail, @closure, @func
and/or @data the handler has to match.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> Signal the handler has to be connected to.
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> Signal detail the handler has to be connected to.
</parameter_description>
</parameter>
<parameter name="closure">
<parameter_description> The closure the handler will invoke.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> The C closure callback of the handler (useless for non-C closures).
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> The closure data of the handler's closure.
</parameter_description>
</parameter>
</parameters>
<return> A valid non-0 signal handler id for a successful match.
</return>
</function>

<function name="g_unichar_isalnum">
<description>
Determines whether a character is alphanumeric.
Given some UTF-8 text, obtain a character value
with g_utf8_get_char().


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is an alphanumeric character
</return>
</function>

<function name="g_io_channel_unref">
<description>
Decrements the reference count of a #GIOChannel.

</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_utime">
<description>
A wrapper for the POSIX utime() function. The utime() function
sets the access and modification timestamps of a file.

See your C library manual for more details about how utime() works
on your system.

Since: 2.18

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="utb">
<parameter_description> a pointer to a struct utimbuf.
</parameter_description>
</parameter>
</parameters>
<return> 0 if the operation was successful, -1 if an error 
occurred

</return>
</function>

<function name="g_type_check_instance">
<description>
Private helper function to aid implementation of the G_TYPE_CHECK_INSTANCE()
macro.


</description>
<parameters>
<parameter name="instance">
<parameter_description> A valid #GTypeInstance structure.
</parameter_description>
</parameter>
</parameters>
<return>  #TRUE if @instance is valid, #FALSE otherwise.
</return>
</function>

<function name="g_string_append_len">
<description>
Appends @len bytes of @val to @string. Because @len is 
provided, @val may contain embedded nuls and need not 
be nul-terminated.

Since this function does not stop at nul bytes, it is 
the caller's responsibility to ensure that @val has at 
least @len addressable bytes.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> bytes to append
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> number of bytes of @val to use
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_signal_has_handler_pending">
<description>
Returns whether there are any handlers connected to @instance for the
given signal id and detail.

One example of when you might use this is when the arguments to the
signal are difficult to compute. A class implementor may opt to not
emit the signal if no one is attached anyway, thus saving the cost
of building the arguments.


</description>
<parameters>
<parameter name="instance">
<parameter_description> the object whose signal handlers are sought.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> the signal id.
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> the detail.
</parameter_description>
</parameter>
<parameter name="may_be_blocked">
<parameter_description> whether blocked handlers should count as match.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a handler is connected to the signal, %FALSE
otherwise.
</return>
</function>

<function name="g_param_spec_enum">
<description>
Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM
property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="enum_type">
<parameter_description> a #GType derived from %G_TYPE_ENUM
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_variant_dup_bytestring">
<description>
Similar to g_variant_get_bytestring() except that instead of
returning a constant string, the string is duplicated.

The return value must be freed using g_free().

Since: 2.26

</description>
<parameters>
<parameter name="value">
<parameter_description> an array-of-bytes #GVariant instance
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> a pointer to a #gsize, to store
the length (not including the nul terminator)
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string
</return>
</function>

<function name="g_value_set_long">
<description>
Set the contents of a %G_TYPE_LONG #GValue to @v_long.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_LONG
</parameter_description>
</parameter>
<parameter name="v_long">
<parameter_description> long integer value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cclosure_marshal_VOID__DOUBLE">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gdouble arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #gdouble parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_time_val_from_iso8601">
<description>
Converts a string containing an ISO 8601 encoded date and time
to a #GTimeVal and puts it into @time_.

Since: 2.12

</description>
<parameters>
<parameter name="iso_date">
<parameter_description> an ISO 8601 encoded date string
</parameter_description>
</parameter>
<parameter name="time_">
<parameter_description> a #GTimeVal
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the conversion was successful.

</return>
</function>

<function name="g_async_queue_push">
<description>
Pushes the @data into the @queue. @data must not be %NULL.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> @data to push into the @queue.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_set_qdata">
<description>
Sets an opaque, named pointer on a #GParamSpec. The name is
specified through a #GQuark (retrieved e.g. via
g_quark_from_static_string()), and the pointer can be gotten back
from the @pspec with g_param_spec_get_qdata().  Setting a
previously set user data pointer, overrides (frees) the old pointer
set, using %NULL as pointer essentially removes the data stored.

</description>
<parameters>
<parameter name="pspec">
<parameter_description> the #GParamSpec to set store a user data pointer
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> a #GQuark, naming the user data pointer
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> an opaque user data pointer
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_exit">
<description>
Exits the current thread. If another thread is waiting for that
thread using g_thread_join() and the current thread is joinable, the
waiting thread will be woken up and get @retval as the return value
of g_thread_join(). If the current thread is not joinable, @retval
is ignored. Calling

&lt;informalexample&gt;
&lt;programlisting&gt;
g_thread_exit (retval);
&lt;/programlisting&gt;
&lt;/informalexample&gt;

is equivalent to returning @retval from the function @func, as given
to g_thread_create().

&lt;note&gt;&lt;para&gt;Never call g_thread_exit() from within a thread of a
#GThreadPool, as that will mess up the bookkeeping and lead to funny
and unwanted results.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="retval">
<parameter_description> the return value of this thread.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_dcgettext">
<description>
This is a variant of g_dgettext() that allows specifying a locale
category instead of always using %LC_MESSAGES. See g_dgettext() for
more information about how this functions differs from calling
dcgettext() directly.

Since: 2.26

</description>
<parameters>
<parameter name="domain">
<parameter_description> the translation domain to use, or %NULL to use
the domain set with textdomain()
</parameter_description>
</parameter>
<parameter name="msgid">
<parameter_description> message to translate
</parameter_description>
</parameter>
<parameter name="category">
<parameter_description> a locale category
</parameter_description>
</parameter>
</parameters>
<return> the translated string for the given locale category

</return>
</function>

<function name="g_strstr_len">
<description>
Searches the string @haystack for the first occurrence
of the string @needle, limiting the length of the search
to @haystack_len. 


</description>
<parameters>
<parameter name="haystack">
<parameter_description> a string.
</parameter_description>
</parameter>
<parameter name="haystack_len">
<parameter_description> the maximum length of @haystack. Note that -1 is
a valid length, if @haystack is nul-terminated, meaning it will
search through the whole string.
</parameter_description>
</parameter>
<parameter name="needle">
<parameter_description> the string to search for.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the found occurrence, or
%NULL if not found.
</return>
</function>

<function name="g_unichar_isxdigit">
<description>
Determines if a character is a hexidecimal digit.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the character is a hexadecimal digit
</return>
</function>

<function name="g_string_chunk_clear">
<description>
Frees all strings contained within the #GStringChunk.
After calling g_string_chunk_clear() it is not safe to
access any of the strings which were contained within it.

Since: 2.14

</description>
<parameters>
<parameter name="chunk">
<parameter_description> a #GStringChunk
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_array_ref">
<description>
Atomically increments the reference count of @array by one. This
function is MT-safe and may be called from any thread.

Since: 2.22

</description>
<parameters>
<parameter name="array">
<parameter_description> A #GArray.
</parameter_description>
</parameter>
</parameters>
<return> The passed in #GArray.

</return>
</function>

<function name="g_async_queue_unref">
<description>
Decreases the reference count of the asynchronous @queue by 1. If
the reference count went to 0, the @queue will be destroyed and the
memory allocated will be freed. So you are not allowed to use the
@queue afterwards, as it might have disappeared. You do not need to
hold the lock to call this function.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_stat">
<description>
A wrapper for the POSIX stat() function. The stat() function
returns information about a file. On Windows the stat() function in
the C library checks only the FAT-style READONLY attribute and does
not look at the ACL at all. Thus on Windows the protection bits in
the st_mode field are a fabrication of little use.

On Windows the Microsoft C libraries have several variants of the
&lt;structname&gt;stat&lt;/structname&gt; struct and stat() function with names
like &quot;_stat&quot;, &quot;_stat32&quot;, &quot;_stat32i64&quot; and &quot;_stat64i32&quot;. The one
used here is for 32-bit code the one with 32-bit size and time
fields, specifically called &quot;_stat32&quot;.

In Microsoft's compiler, by default &quot;struct stat&quot; means one with
64-bit time fields while in MinGW &quot;struct stat&quot; is the legacy one
with 32-bit fields. To hopefully clear up this messs, the gstdio.h
header defines a type GStatBuf which is the appropriate struct type
depending on the platform and/or compiler being used. On POSIX it
is just &quot;struct stat&quot;, but note that even on POSIX platforms,
&quot;stat&quot; might be a macro.

See your C library manual for more details about stat().

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="buf">
<parameter_description> a pointer to a &lt;structname&gt;stat&lt;/structname&gt; struct, which
will be filled with the file information
</parameter_description>
</parameter>
</parameters>
<return> 0 if the information was successfully retrieved, -1 if an error 
occurred

</return>
</function>

<function name="g_timeout_source_new_seconds">
<description>
Creates a new timeout source.

The source will not initially be associated with any #GMainContext
and must be added to one with g_source_attach() before it will be
executed.

The scheduling granularity/accuracy of this timeout source will be
in seconds.

Since: 2.14	

</description>
<parameters>
<parameter name="interval">
<parameter_description> the timeout interval in seconds
</parameter_description>
</parameter>
</parameters>
<return> the newly-created timeout source

</return>
</function>

<function name="g_atexit">
<description>
Specifies a function to be called at normal program termination.

Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor
macro that maps to a call to the atexit() function in the C
library. This means that in case the code that calls g_atexit(),
i.e. atexit(), is in a DLL, the function will be called when the
DLL is detached from the program. This typically makes more sense
than that the function is called when the GLib DLL is detached,
which happened earlier when g_atexit() was a function in the GLib
DLL.

The behaviour of atexit() in the context of dynamically loaded
modules is not formally specified and varies wildly.

On POSIX systems, calling g_atexit() (or atexit()) in a dynamically
loaded module which is unloaded before the program terminates might
well cause a crash at program exit.

Some POSIX systems implement atexit() like Windows, and have each
dynamically loaded module maintain an own atexit chain that is
called when the module is unloaded.

On other POSIX systems, before a dynamically loaded module is
unloaded, the registered atexit functions (if any) residing in that
module are called, regardless where the code that registered them
resided. This is presumably the most robust approach.

As can be seen from the above, for portability it's best to avoid
calling g_atexit() (or atexit()) except in the main executable of a
program.

</description>
<parameters>
<parameter name="func">
<parameter_description> the function to call on normal program termination.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ascii_dtostr">
<description>
Converts a #gdouble to a string, using the '.' as
decimal point. 

This functions generates enough precision that converting
the string back using g_ascii_strtod() gives the same machine-number
(on machines with IEEE compatible 64bit doubles). It is
guaranteed that the size of the resulting string will never
be larger than @G_ASCII_DTOSTR_BUF_SIZE bytes.


</description>
<parameters>
<parameter name="buffer">
<parameter_description> A buffer to place the resulting string in
</parameter_description>
</parameter>
<parameter name="buf_len">
<parameter_description> The length of the buffer.
</parameter_description>
</parameter>
<parameter name="d">
<parameter_description> The #gdouble to convert
</parameter_description>
</parameter>
</parameters>
<return> The pointer to the buffer with the converted string.
</return>
</function>

<function name="g_test_add">
<description>
Hook up a new test case at @testpath, similar to g_test_add_func().
A fixture data structure with setup and teardown function may be provided
though, similar to g_test_create_case().
g_test_add() is implemented as a macro, so that the fsetup(), ftest() and
fteardown() callbacks can expect a @Fixture pointer as first argument in
a type safe manner.

Since: 2.16

</description>
<parameters>
<parameter name="testpath">
<parameter_description>  The test path for a new test case.
</parameter_description>
</parameter>
<parameter name="Fixture">
<parameter_description>   The type of a fixture data structure.
</parameter_description>
</parameter>
<parameter name="tdata">
<parameter_description>     Data argument for the test functions.
</parameter_description>
</parameter>
<parameter name="fsetup">
<parameter_description>    The function to set up the fixture data.
</parameter_description>
</parameter>
<parameter name="ftest">
<parameter_description>     The actual test function.
</parameter_description>
</parameter>
<parameter name="fteardown">
<parameter_description> The function to tear down the fixture data.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_handlers_disconnect_matched">
<description>
Disconnects all handlers on an instance that match a certain
selection criteria. The criteria mask is passed as an OR-ed
combination of #GSignalMatchType flags, and the criteria values are
passed as arguments.  Passing at least one of the
%G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or
%G_SIGNAL_MATCH_DATA match flags is required for successful
matches.  If no handlers were found, 0 is returned, the number of
disconnected handlers otherwise.


</description>
<parameters>
<parameter name="instance">
<parameter_description> The instance to remove handlers from.
</parameter_description>
</parameter>
<parameter name="mask">
<parameter_description> Mask indicating which of @signal_id, @detail, @closure, @func
and/or @data the handlers have to match.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> Signal the handlers have to be connected to.
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> Signal detail the handlers have to be connected to.
</parameter_description>
</parameter>
<parameter name="closure">
<parameter_description> The closure the handlers will invoke.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> The C closure callback of the handlers (useless for non-C closures).
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> The closure data of the handlers' closures.
</parameter_description>
</parameter>
</parameters>
<return> The number of handlers that matched.
</return>
</function>

<function name="g_test_trap_fork">
<description>
Fork the current test program to execute a test case that might
not return or that might abort. The forked test case is aborted
and considered failing if its run time exceeds @usec_timeout.

The forking behavior can be configured with the #GTestTrapFlags flags.

In the following example, the test code forks, the forked child
process produces some sample output and exits successfully.
The forking parent process then asserts successful child program
termination and validates child program outputs.

|[
static void
test_fork_patterns (void)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
{
g_print (&quot;some stdout text: somagic17\n&quot;);
g_printerr (&quot;some stderr text: semagic43\n&quot;);
exit (0); / * successful test run * /
}
g_test_trap_assert_passed();
g_test_trap_assert_stdout (&quot;*somagic17*&quot;);
g_test_trap_assert_stderr (&quot;*semagic43*&quot;);
}
]|

This function is implemented only on Unix platforms.

Since: 2.16

</description>
<parameters>
<parameter name="usec_timeout">
<parameter_description>    Timeout for the forked test in micro seconds.
</parameter_description>
</parameter>
<parameter name="test_trap_flags">
<parameter_description> Flags to modify forking behaviour.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE for the forked child and %FALSE for the executing parent process.

</return>
</function>

<function name="g_main_context_find_source_by_user_data">
<description>
Finds a source with the given user data for the callback.  If
multiple sources exist with the same user data, the first
one found will be returned.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> the user_data for the callback.
</parameter_description>
</parameter>
</parameters>
<return> the source, if one was found, otherwise %NULL
</return>
</function>

<function name="g_spawn_async">
<description>
See g_spawn_async_with_pipes() for a full description; this function
simply calls the g_spawn_async_with_pipes() without any pipes.

You should call g_spawn_close_pid() on the returned child process
reference when you don't need it any more.

&lt;note&gt;&lt;para&gt;
If you are writing a GTK+ application, and the program you 
are spawning is a graphical application, too, then you may
want to use gdk_spawn_on_screen() instead to ensure that 
the spawned program opens its windows on the right screen.
&lt;/para&gt;&lt;/note&gt;

&lt;note&gt;&lt;para&gt; Note that the returned @child_pid on Windows is a
handle to the child process and not its identifier. Process handles
and process identifiers are different concepts on Windows.
&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="working_directory">
<parameter_description> child's current working directory, or %NULL to inherit parent's
</parameter_description>
</parameter>
<parameter name="argv">
<parameter_description> child's argument vector
</parameter_description>
</parameter>
<parameter name="envp">
<parameter_description> child's environment, or %NULL to inherit parent's
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags from #GSpawnFlags
</parameter_description>
</parameter>
<parameter name="child_setup">
<parameter_description> function to run in the child just before exec()
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data for @child_setup
</parameter_description>
</parameter>
<parameter name="child_pid">
<parameter_description> return location for child process reference, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for error
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success, %FALSE if error is set
</return>
</function>

<function name="g_object_class_find_property">
<description>
Looks up the #GParamSpec for a property of a class.


</description>
<parameters>
<parameter name="oclass">
<parameter_description> a #GObjectClass
</parameter_description>
</parameter>
<parameter name="property_name">
<parameter_description> the name of the property to look up
</parameter_description>
</parameter>
</parameters>
<return> the #GParamSpec for the property, or %NULL if the class
doesn't have a property of that name
</return>
</function>

<function name="g_string_sprintfa">
<description>
Appends a formatted string onto the end of a #GString.
This function is similar to g_string_sprintf() except that
the text is appended to the #GString. 

Deprecated: This function has been renamed to g_string_append_printf()

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> the string format. See the sprintf() documentation
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the parameters to insert into the format string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_closure_ref">
<description>
Increments the reference count on a closure to force it staying
alive while the caller holds a pointer to it.


</description>
<parameters>
<parameter name="closure">
<parameter_description> #GClosure to increment the reference count on
</parameter_description>
</parameter>
</parameters>
<return> The @closure passed in, for convenience
</return>
</function>

<function name="g_random_set_seed">
<description>
Sets the seed for the global random number generator, which is used
by the &lt;function&gt;g_random_*&lt;/function&gt; functions, to @seed.

</description>
<parameters>
<parameter name="seed">
<parameter_description> a value to reinitialize the global random number generator.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_option_group_new">
<description>
Creates a new #GOptionGroup.

Since: 2.6

</description>
<parameters>
<parameter name="name">
<parameter_description> the name for the option group, this is used to provide
help for the options in this group with &lt;option&gt;--help-&lt;/option&gt;@name
</parameter_description>
</parameter>
<parameter name="description">
<parameter_description> a description for this group to be shown in 
&lt;option&gt;--help&lt;/option&gt;. This string is translated using the translation
domain or translation function of the group
</parameter_description>
</parameter>
<parameter name="help_description">
<parameter_description> a description for the &lt;option&gt;--help-&lt;/option&gt;@name option.
This string is translated using the translation domain or translation function
of the group
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data that will be passed to the pre- and post-parse hooks,
the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL
</parameter_description>
</parameter>
<parameter name="destroy">
<parameter_description> a function that will be called to free @user_data, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly created option group. It should be added 
to a #GOptionContext or freed with g_option_group_free().

</return>
</function>

<function name="g_binding_get_target">
<description>
Retrieves the #GObject instance used as the target of the binding

Since: 2.26

</description>
<parameters>
<parameter name="binding">
<parameter_description> a #GBinding
</parameter_description>
</parameter>
</parameters>
<return> the target #GObject

</return>
</function>

<function name="g_thread_pool_get_max_unused_threads">
<description>
Returns the maximal allowed number of unused threads.


</description>
<parameters>
</parameters>
<return> the maximal number of unused threads
</return>
</function>

<function name="g_int_equal">
<description>
Compares the two #gint values being pointed to and returns 
%TRUE if they are equal.
It can be passed to g_hash_table_new() as the @key_equal_func
parameter, when using pointers to integers as keys in a #GHashTable.


</description>
<parameters>
<parameter name="v1">
<parameter_description> a pointer to a #gint key.
</parameter_description>
</parameter>
<parameter name="v2">
<parameter_description> a pointer to a #gint key to compare with @v1.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the two keys match.
</return>
</function>

<function name="g_signal_emit">
<description>
Emits a signal.

Note that g_signal_emit() resets the return value to the default
if no handlers are connected, in contrast to g_signal_emitv().

</description>
<parameters>
<parameter name="instance">
<parameter_description> the instance the signal is being emitted on.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> the signal id
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> the detail
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> parameters to be passed to the signal, followed by a
location for the return value. If the return type of the signal
is #G_TYPE_NONE, the return value location can be omitted.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_byte_array_free">
<description>
Frees the memory allocated by the #GByteArray. If @free_segment is
%TRUE it frees the actual byte data. If the reference count of
@array is greater than one, the #GByteArray wrapper is preserved but
the size of @array will be set to zero.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GByteArray.
</parameter_description>
</parameter>
<parameter name="free_segment">
<parameter_description> if %TRUE the actual byte data is freed as well.
</parameter_description>
</parameter>
</parameters>
<return> the element data if @free_segment is %FALSE, otherwise
%NULL.  The element data should be freed using g_free().
</return>
</function>

<function name="g_async_queue_sort">
<description>
Sorts @queue using @func. 

This function will lock @queue before it sorts the queue and unlock
it when it is finished.

If you were sorting a list of priority numbers to make sure the
lowest priority would be at the top of the queue, you could use:
|[
gint32 id1;
gint32 id2;

id1 = GPOINTER_TO_INT (element1);
id2 = GPOINTER_TO_INT (element2);

return (id1 &gt; id2 ? +1 : id1 == id2 ? 0 : -1);
]|

Since: 2.10

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the #GCompareDataFunc is used to sort @queue. This
function is passed two elements of the @queue. The function
should return 0 if they are equal, a negative value if the
first element should be higher in the @queue or a positive
value if the first element should be lower in the @queue than
the second element. 
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data passed to @func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_path_is_absolute">
<description>
Returns %TRUE if the given @file_name is an absolute file name,
i.e. it contains a full path from the root directory such as &quot;/usr/local&quot;
on UNIX or &quot;C:\windows&quot; on Windows systems.


</description>
<parameters>
<parameter name="file_name">
<parameter_description> a file name.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @file_name is an absolute path. 
</return>
</function>

<function name="g_string_prepend_len">
<description>
Prepends @len bytes of @val to @string. 
Because @len is provided, @val may contain 
embedded nuls and need not be nul-terminated.

Since this function does not stop at nul bytes, 
it is the caller's responsibility to ensure that 
@val has at least @len addressable bytes.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> bytes to prepend
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> number of bytes in @val to prepend
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_string_overwrite_len">
<description>
Overwrites part of a string, lengthening it if necessary. 
This function will work with embedded nuls.

Since: 2.14

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="pos">
<parameter_description> the position at which to start overwriting
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> the string that will overwrite the @string starting at @pos
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the number of bytes to write from @val
</parameter_description>
</parameter>
</parameters>
<return> @string

</return>
</function>

<function name="g_main_loop_is_running">
<description>
Checks to see if the main loop is currently being run via g_main_loop_run().


</description>
<parameters>
<parameter name="loop">
<parameter_description> a #GMainLoop.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the mainloop is currently being run.
</return>
</function>

<function name="g_string_new">
<description>
Creates a new #GString, initialized with the given string.


</description>
<parameters>
<parameter name="init">
<parameter_description> the initial text to copy into the string
</parameter_description>
</parameter>
</parameters>
<return> the new #GString
</return>
</function>

<function name="g_source_remove_by_user_data">
<description>
Removes a source from the default main loop context given the user
data for the callback. If multiple sources exist with the same user
data, only one will be destroyed.


</description>
<parameters>
<parameter name="user_data">
<parameter_description> the user_data for the callback.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a source was found and removed. 
</return>
</function>

<function name="g_variant_type_key">
<description>
Determines the key type of a dictionary entry type.

This function may only be used with a dictionary entry type.  Other
than the additional restriction, this call is equivalent to
g_variant_type_first().

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a dictionary entry #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> the key type of the dictionary entry
</return>
</function>

<function name="g_mem_chunk_alloc0">
<description>
Allocates an atom of memory from a #GMemChunk, setting the memory to
0.

Deprecated:2.10: Use g_slice_alloc0() instead

</description>
<parameters>
<parameter name="mem_chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the allocated atom.
</return>
</function>

<function name="g_key_file_remove_key">
<description>
Removes @key in @group_name from the key file. 

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key name to remove
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the key was removed, %FALSE otherwise

</return>
</function>

<function name="g_bookmark_file_new">
<description>
Creates a new empty #GBookmarkFile object.

Use g_bookmark_file_load_from_file(), g_bookmark_file_load_from_data()
or g_bookmark_file_load_from_data_dirs() to read an existing bookmark
file.

Since: 2.12

</description>
<parameters>
</parameters>
<return> an empty #GBookmarkFile

</return>
</function>

<function name="g_binding_get_source_property">
<description>
Retrieves the name of the property of #GBinding:source used as the source
of the binding

Since: 2.26

</description>
<parameters>
<parameter name="binding">
<parameter_description> a #GBinding
</parameter_description>
</parameter>
</parameters>
<return> the name of the source property

</return>
</function>

<function name="g_queue_pop_nth_link">
<description>
Removes and returns the link at the given position.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the link's position
</parameter_description>
</parameter>
</parameters>
<return> The @n'th link, or %NULL if @n is off the end of @queue.

</return>
</function>

<function name="g_async_queue_pop">
<description>
Pops data from the @queue. This function blocks until data become
available.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return> data from the queue.
</return>
</function>

<function name="g_stpcpy">
<description>
Copies a nul-terminated string into the dest buffer, include the
trailing nul, and return a pointer to the trailing nul byte.
This is useful for concatenating multiple strings together
without having to repeatedly scan for the end.


</description>
<parameters>
<parameter name="dest">
<parameter_description> destination buffer.
</parameter_description>
</parameter>
<parameter name="src">
<parameter_description> source string.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to trailing nul byte.
</return>
</function>

<function name="g_string_insert_c">
<description>
Inserts a byte into a #GString, expanding it if necessary.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="pos">
<parameter_description> the position to insert the byte
</parameter_description>
</parameter>
<parameter name="c">
<parameter_description> the byte to insert
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_variant_new_parsed">
<description>
Parses @format and returns the result.

@format must be a text format #GVariant with one extension: at any
point that a value may appear in the text, a '%' character followed
by a GVariant format string (as per g_variant_new()) may appear.  In
that case, the same arguments are collected from the argument list as
g_variant_new() would have collected.

Consider this simple example:

&lt;informalexample&gt;&lt;programlisting&gt;
g_variant_new_parsed (&quot;[('one', 1), ('two', %i), (%s, 3)]&quot;, 2, &quot;three&quot;);
&lt;/programlisting&gt;&lt;/informalexample&gt;

In the example, the variable argument parameters are collected and
filled in as if they were part of the original string to produce the
result of &lt;code&gt;[('one', 1), ('two', 2), ('three', 3)]&lt;/code&gt;.

This function is intended only to be used with @format as a string
literal.  Any parse error is fatal to the calling process.  If you
want to parse data from untrusted sources, use g_variant_parse().

You may not use this function to return, unmodified, a single
#GVariant pointer from the argument list.  ie: @format may not solely
be anything along the lines of &quot;%*&quot;, &quot;%?&quot;, &quot;%r&quot;, or anything starting
with &quot;%@&quot;.

</description>
<parameters>
<parameter name="format">
<parameter_description> a text format #GVariant
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments as per @format
</parameter_description>
</parameter>
</parameters>
<return> a new floating #GVariant instance
</return>
</function>

<function name="g_thread_pool_unprocessed">
<description>
Returns the number of tasks still unprocessed in @pool.


</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GThreadPool
</parameter_description>
</parameter>
</parameters>
<return> the number of unprocessed tasks
</return>
</function>

<function name="g_bookmark_file_set_description">
<description>
Sets @description as the description of the bookmark for @uri.

If @uri is %NULL, the description of @bookmark is set.

If a bookmark for @uri cannot be found then it is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI or %NULL
</parameter_description>
</parameter>
<parameter name="description">
<parameter_description> a string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_tree_unref">
<description>
Decrements the reference count of @tree by one.  If the reference count
drops to 0, all keys and values will be destroyed (if destroy
functions were specified) and all memory allocated by @tree will be
released.

It is safe to call this function from any thread.

Since: 2.22

</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_connect_closure">
<description>
Connects a closure to a signal for a particular object.


</description>
<parameters>
<parameter name="instance">
<parameter_description> the instance to connect to.
</parameter_description>
</parameter>
<parameter name="detailed_signal">
<parameter_description> a string of the form &quot;signal-name::detail&quot;.
</parameter_description>
</parameter>
<parameter name="closure">
<parameter_description> the closure to connect.
</parameter_description>
</parameter>
<parameter name="after">
<parameter_description> whether the handler should be called before or after the
default handler of the signal.
</parameter_description>
</parameter>
</parameters>
<return> the handler id
</return>
</function>

<function name="g_timeout_add_seconds_full">
<description>
Sets a function to be called at regular intervals, with @priority.
The function is called repeatedly until it returns %FALSE, at which
point the timeout is automatically destroyed and the function will
not be called again.

Unlike g_timeout_add(), this function operates at whole second granularity.
The initial starting point of the timer is determined by the implementation
and the implementation is expected to group multiple timers together so that
they fire all at the same time.
To allow this grouping, the @interval to the first timer is rounded
and can deviate up to one second from the specified interval.
Subsequent timer iterations will generally run at the specified interval.

Note that timeout functions may be delayed, due to the processing of other
event sources. Thus they should not be relied on for precise timing.
After each call to the timeout function, the time of the next
timeout is recalculated based on the current time and the given @interval

If you want timing more precise than whole seconds, use g_timeout_add()
instead.

The grouping of timers to fire at the same time results in a more power
and CPU efficient behavior so if your timer is in multiples of seconds
and you don't require the first timer exactly one second from now, the
use of g_timeout_add_seconds() is preferred over g_timeout_add().

This internally creates a main loop source using 
g_timeout_source_new_seconds() and attaches it to the main loop context 
using g_source_attach(). You can do these steps manually if you need 
greater control.

Since: 2.14

</description>
<parameters>
<parameter name="priority">
<parameter_description> the priority of the timeout source. Typically this will be in
the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
</parameter_description>
</parameter>
<parameter name="interval">
<parameter_description> the time between calls to the function, in seconds
</parameter_description>
</parameter>
<parameter name="function">
<parameter_description> function to call
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description>     data to pass to @function
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description>   function to call when the timeout is removed, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) of the event source.

</return>
</function>

<function name="g_mkstemp_full">
<description>
Opens a temporary file. See the mkstemp() documentation
on most UNIX-like systems.

The parameter is a string that should follow the rules for
mkstemp() templates, i.e. contain the string &quot;XXXXXX&quot;.
g_mkstemp_full() is slightly more flexible than mkstemp()
in that the sequence does not have to occur at the very end of the
template and you can pass a @mode and additional @flags. The X
string will be modified to form the name of a file that didn't exist.
The string should be in the GLib file name encoding. Most importantly,
on Windows it should be in UTF-8.

Since: 2.22

</description>
<parameters>
<parameter name="tmpl">
<parameter_description> template filename
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags to pass to an open() call in addition to O_EXCL and
O_CREAT, which are passed automatically
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> permissios to create the temporary file with
</parameter_description>
</parameter>
</parameters>
<return> A file handle (as from open()) to the file
opened for reading and writing. The file handle should be
closed with close(). In case of errors, -1 is returned.

</return>
</function>

<function name="g_string_insert">
<description>
Inserts a copy of a string into a #GString, 
expanding it if necessary.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="pos">
<parameter_description> the position to insert the copy of the string
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> the string to insert
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_async_queue_pop_unlocked">
<description>
Pops data from the @queue. This function blocks until data become
available. This function must be called while holding the @queue's
lock.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return> data from the queue.
</return>
</function>

<function name="g_main_context_push_thread_default">
<description>
Acquires @context and sets it as the thread-default context for the
current thread. This will cause certain asynchronous operations
(such as most &lt;link linkend=&quot;gio&quot;&gt;gio&lt;/link&gt;-based I/O) which are
started in this thread to run under @context and deliver their
results to its main loop, rather than running under the global
default context in the main thread. Note that calling this function
changes the context returned by
g_main_context_get_thread_default(), &lt;emphasis&gt;not&lt;/emphasis&gt; the
one returned by g_main_context_default(), so it does not affect the
context used by functions like g_idle_add().

Normally you would call this function shortly after creating a new
thread, passing it a #GMainContext which will be run by a
#GMainLoop in that thread, to set a new default context for all
async operations in that thread. (In this case, you don't need to
ever call g_main_context_pop_thread_default().) In some cases
however, you may want to schedule a single operation in a
non-default context, or temporarily use a non-default context in
the main thread. In that case, you can wrap the call to the
asynchronous operation inside a
g_main_context_push_thread_default() /
g_main_context_pop_thread_default() pair, but it is up to you to
ensure that no other asynchronous operations accidentally get
started while the non-default context is active.

Beware that libraries that predate this function may not correctly
handle being used from a thread with a thread-default context. Eg,
see g_file_supports_thread_contexts().

Since: 2.22

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext, or %NULL for the global default context
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_array_remove">
<description>
Remove the value at position @index_ from @value_array.


</description>
<parameters>
<parameter name="value_array">
<parameter_description> #GValueArray to remove an element from
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> position of value to remove, must be &lt; value_array-&gt;n_values
</parameter_description>
</parameter>
</parameters>
<return> the #GValueArray passed in as @value_array
</return>
</function>

<function name="g_slist_alloc">
<description>
Allocates space for one #GSList element. It is called by the
g_slist_append(), g_slist_prepend(), g_slist_insert() and
g_slist_insert_sorted() functions and so is rarely used on its own.

</description>
<parameters>
</parameters>
<return> a pointer to the newly-allocated #GSList element.
</return>
</function>

<function name="g_object_watch_closure">
<description>
This function essentially limits the life time of the @closure to
the life time of the object. That is, when the object is finalized,
the @closure is invalidated by calling g_closure_invalidate() on
it, in order to prevent invocations of the closure with a finalized
(nonexisting) object. Also, g_object_ref() and g_object_unref() are
added as marshal guards to the @closure, to ensure that an extra
reference count is held on @object during invocation of the
@closure.  Usually, this function will be called on closures that
use this @object as closure data.

</description>
<parameters>
<parameter name="object">
<parameter_description> GObject restricting lifetime of @closure
</parameter_description>
</parameter>
<parameter name="closure">
<parameter_description> GClosure to watch
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_get_close_on_unref">
<description>
Returns whether the file/socket/whatever associated with @channel
will be closed when @channel receives its final unref and is
destroyed. The default value of this is %TRUE for channels created
by g_io_channel_new_file (), and %FALSE for all other channels.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel.
</parameter_description>
</parameter>
</parameters>
<return> Whether the channel will be closed on the final unref of
the GIOChannel data structure.
</return>
</function>

<function name="g_value_get_gtype">
<description>
Get the contents of a %G_TYPE_GTYPE #GValue.

Since: 2.12


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_GTYPE
</parameter_description>
</parameter>
</parameters>
<return> the #GType stored in @value
</return>
</function>

<function name="g_uri_parse_scheme">
<description>
Gets the scheme portion of a URI string. RFC 3986 decodes the scheme as:
&lt;programlisting&gt;
URI = scheme &quot;:&quot; hier-part [ &quot;?&quot; query ] [ &quot;#&quot; fragment ] 
&lt;/programlisting&gt;
Common schemes include &quot;file&quot;, &quot;http&quot;, &quot;svn+ssh&quot;, etc.

Since: 2.16

</description>
<parameters>
<parameter name="uri">
<parameter_description> a valid URI.
</parameter_description>
</parameter>
</parameters>
<return> The &quot;Scheme&quot; component of the URI, or %NULL on error. 
The returned string should be freed when no longer needed.

</return>
</function>

<function name="g_vfprintf">
<description>
An implementation of the standard fprintf() function which supports 
positional parameters, as specified in the Single Unix Specification.

Since: 2.2

</description>
<parameters>
<parameter name="file">
<parameter_description> the stream to write to.
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice 
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;.
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> the list of arguments to insert in the output.
</parameter_description>
</parameter>
</parameters>
<return> the number of bytes printed.

</return>
</function>

<function name="g_match_info_get_regex">
<description>
Returns #GRegex object used in @match_info. It belongs to Glib
and must not be freed. Use g_regex_ref() if you need to keep it
after you free @match_info object.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> a #GMatchInfo
</parameter_description>
</parameter>
</parameters>
<return> #GRegex object used in @match_info

</return>
</function>

<function name="g_value_get_boxed">
<description>
Get the contents of a %G_TYPE_BOXED derived #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_BOXED derived type
</parameter_description>
</parameter>
</parameters>
<return> boxed contents of @value
</return>
</function>

<function name="g_variant_print_string">
<description>
Behaves as g_variant_print(), but operates on a #GString.

If @string is non-%NULL then it is appended to and returned.  Else,
a new empty #GString is allocated and it is returned.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> a #GString, or %NULL
</parameter_description>
</parameter>
<parameter name="type_annotate">
<parameter_description> %TRUE if type information should be included in
the output
</parameter_description>
</parameter>
</parameters>
<return> a #GString containing the string
</return>
</function>

<function name="g_array_free">
<description>
Frees the memory allocated for the #GArray. If @free_segment is
%TRUE it frees the memory block holding the elements as well and
also each element if @array has a @element_free_func set. Pass
%FALSE if you want to free the #GArray wrapper but preserve the
underlying array for use elsewhere. If the reference count of @array
is greater than one, the #GArray wrapper is preserved but the size
of @array will be set to zero.

&lt;note&gt;&lt;para&gt;If array elements contain dynamically-allocated memory,
they should be freed separately.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="free_segment">
<parameter_description> if %TRUE the actual element data is freed as well.
</parameter_description>
</parameter>
</parameters>
<return> the element data if @free_segment is %FALSE, otherwise
%NULL.  The element data should be freed using g_free().
</return>
</function>

<function name="g_relation_exists">
<description>
Returns %TRUE if a record with the given values exists in a
#GRelation. Note that the values are compared directly, so that, for
example, two copies of the same string will not match.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="relation">
<parameter_description> a #GRelation.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the fields of the record to compare. The number must match
the number of fields in the #GRelation.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a record matches.
</return>
</function>

<function name="g_strerror">
<description>
Returns a string corresponding to the given error code, e.g. 
&quot;no such process&quot;. You should use this function in preference to 
strerror(), because it returns a string in UTF-8 encoding, and since 
not all platforms support the strerror() function.


</description>
<parameters>
<parameter name="errnum">
<parameter_description> the system error number. See the standard C %errno
documentation
</parameter_description>
</parameter>
</parameters>
<return> a UTF-8 string describing the error code. If the error code 
is unknown, it returns &quot;unknown error (&lt;code&gt;)&quot;. The string 
can only be used until the next call to g_strerror()
</return>
</function>

<function name="g_variant_type_new_dict_entry">
<description>
Constructs the type corresponding to a dictionary entry with a key
of type @key and a value of type @value.

It is appropriate to call g_variant_type_free() on the return value.

Since 2.24

</description>
<parameters>
<parameter name="key">
<parameter_description> a basic #GVariantType
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> a new dictionary entry #GVariantType
</return>
</function>

<function name="g_hash_table_foreach_remove">
<description>
Calls the given function for each key/value pair in the #GHashTable.
If the function returns %TRUE, then the key/value pair is removed from the
#GHashTable. If you supplied key or value destroy functions when creating
the #GHashTable, they are used to free the memory allocated for the removed
keys and values.

See #GHashTableIter for an alternative way to loop over the 
key/value pairs in the hash table.


</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each key/value pair.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return> the number of key/value pairs removed.
</return>
</function>

<function name="g_test_get_root">
<description>
Get the toplevel test suite for the test path API.

Since: 2.16

</description>
<parameters>
</parameters>
<return> the toplevel #GTestSuite

</return>
</function>

<function name="g_hostname_to_unicode">
<description>
Converts @hostname to its canonical presentation form; a UTF-8
string in Unicode normalization form C, containing no uppercase
letters, no forbidden characters, and no ASCII-encoded segments,
and not ending with a trailing dot.

Of course if @hostname is not an internationalized hostname, then
the canonical presentation form will be entirely ASCII.

Since: 2.22

</description>
<parameters>
<parameter name="hostname">
<parameter_description> a valid UTF-8 or ASCII hostname
</parameter_description>
</parameter>
</parameters>
<return> a UTF-8 hostname, which must be freed, or %NULL if
@hostname is in some way invalid.

</return>
</function>

<function name="g_ptr_array_remove_range">
<description>
Removes the given number of pointers starting at the given index
from a #GPtrArray.  The following elements are moved to close the
gap. If @array has a non-%NULL #GDestroyNotify function it is called
for the removed elements.

Since: 2.4

</description>
<parameters>
<parameter name="array">
<parameter_description> a @GPtrArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the first pointer to remove.
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the number of pointers to remove.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_source_set_name_by_id">
<description>
Sets the name of a source using its ID.

This is a convenience utility to set source names from the return
value of g_idle_add(), g_timeout_add(), etc.

Since: 2.26

</description>
<parameters>
<parameter name="tag">
<parameter_description> a #GSource ID
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> debug name for the source
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_string_append_c">
<description>
Adds a byte onto the end of a #GString, expanding 
it if necessary.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="c">
<parameter_description> the byte to append onto the end of @string
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_key_file_set_integer_list">
<description>
Associates a list of integer values with @key under @group_name.  
If @key cannot be found then it is created.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="list">
<parameter_description> an array of integer values
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> number of integer values in @list
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_get">
<description>
Deconstructs a #GVariant instance.

Think of this function as an analogue to scanf().

The arguments that are expected by this function are entirely
determined by @format_string.  @format_string also restricts the
permissible types of @value.  It is an error to give a value with
an incompatible type.  See the section on &lt;link
linkend='gvariant-format-strings'&gt;GVariant Format Strings&lt;/link&gt;.
Please note that the syntax of the format string is very likely to be
extended in the future.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant instance
</parameter_description>
</parameter>
<parameter name="format_string">
<parameter_description> a #GVariant format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments, as per @format_string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ptr_array_free">
<description>
Frees the memory allocated for the #GPtrArray. If @free_seg is %TRUE
it frees the memory block holding the elements as well. Pass %FALSE
if you want to free the #GPtrArray wrapper but preserve the
underlying array for use elsewhere. If the reference count of @array
is greater than one, the #GPtrArray wrapper is preserved but the
size of @array will be set to zero.

&lt;note&gt;&lt;para&gt;If array contents point to dynamically-allocated
memory, they should be freed separately if @free_seg is %TRUE and no
#GDestroyNotify function has been set for @array.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="free_seg">
<parameter_description> if %TRUE the actual pointer array is freed as well.
</parameter_description>
</parameter>
</parameters>
<return> the pointer array if @free_seg is %FALSE, otherwise %NULL.
The pointer array should be freed using g_free().
</return>
</function>

<function name="g_variant_builder_ref">
<description>
Increases the reference count on @builder.

Don't call this on stack-allocated #GVariantBuilder instances or bad
things will happen.

Since: 2.24

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder allocated by g_variant_builder_new()
</parameter_description>
</parameter>
</parameters>
<return> a new reference to @builder
</return>
</function>

<function name="g_static_rw_lock_writer_unlock">
<description>
Unlocks @lock. If a thread is waiting to lock @lock for writing and
all locks for reading have been unlocked, the waiting thread is
woken up and can lock @lock for writing. If no thread is waiting to
lock @lock for writing, and some thread or threads are waiting to
lock @lock for reading, the waiting threads are woken up and can
lock @lock for reading.

</description>
<parameters>
<parameter name="lock">
<parameter_description> a #GStaticRWLock to unlock after writing.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_dup_string">
<description>
Similar to g_variant_get_string() except that instead of returning
a constant string, the string is duplicated.

The string will always be utf8 encoded.

The return value must be freed using g_free().

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a string #GVariant instance
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> a pointer to a #gsize, to store the length
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string, utf8 encoded
</return>
</function>

<function name="g_variant_get_uint64">
<description>
Returns the 64-bit unsigned integer value of @value.

It is an error to call this function with a @value of any type
other than %G_VARIANT_TYPE_UINT64.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a uint64 #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> a #guint64
</return>
</function>

<function name="g_rand_int_range">
<description>
Returns the next random #gint32 from @rand_ equally distributed over
the range [@begin..@end-1].


</description>
<parameters>
<parameter name="rand_">
<parameter_description> a #GRand.
</parameter_description>
</parameter>
<parameter name="begin">
<parameter_description> lower closed bound of the interval.
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> upper open bound of the interval.
</parameter_description>
</parameter>
</parameters>
<return> A random number.
</return>
</function>

<function name="g_value_array_insert">
<description>
Insert a copy of @value at specified position into @value_array. If @value
is %NULL, an uninitialized value is inserted.


</description>
<parameters>
<parameter name="value_array">
<parameter_description> #GValueArray to add an element to
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> insertion position, must be &lt;= value_array-&gt;n_values
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> #GValue to copy into #GValueArray, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> the #GValueArray passed in as @value_array
</return>
</function>

<function name="g_source_get_current_time">
<description>
Gets the &quot;current time&quot; to be used when checking 
this source. The advantage of calling this function over
calling g_get_current_time() directly is that when 
checking multiple sources, GLib can cache a single value
instead of having to repeatedly get the system time.

</description>
<parameters>
<parameter name="source">
<parameter_description>  a #GSource
</parameter_description>
</parameter>
<parameter name="timeval">
<parameter_description> #GTimeVal structure in which to store current time.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_async_queue_push_unlocked">
<description>
Pushes the @data into the @queue. @data must not be %NULL. This
function must be called while holding the @queue's lock.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> @data to push into the @queue.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_new_uint32">
<description>
Creates a new uint32 #GVariant instance.

Since: 2.24

</description>
<parameters>
<parameter name="uint32">
<parameter_description> a #guint32 value
</parameter_description>
</parameter>
</parameters>
<return> a new uint32 #GVariant instance
</return>
</function>

<function name="g_type_init">
<description>
Prior to any use of the type system, g_type_init() has to be called
to initialize the type system and assorted other code portions
(such as the various fundamental type implementations or the signal
system).

Since version 2.24 this also initializes the thread system

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_slist_find">
<description>
Finds the element in a #GSList which 
contains the given data.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the element data to find
</parameter_description>
</parameter>
</parameters>
<return> the found #GSList element, 
or %NULL if it is not found
</return>
</function>

<function name="g_build_path">
<description>
Creates a path from a series of elements using @separator as the
separator between elements. At the boundary between two elements,
any trailing occurrences of separator in the first element, or
leading occurrences of separator in the second element are removed
and exactly one copy of the separator is inserted.

Empty elements are ignored.

The number of leading copies of the separator on the result is
the same as the number of leading copies of the separator on
the first non-empty element.

The number of trailing copies of the separator on the result is
the same as the number of trailing copies of the separator on
the last non-empty element. (Determination of the number of
trailing copies is done without stripping leading copies, so
if the separator is &lt;literal&gt;ABA&lt;/literal&gt;, &lt;literal&gt;ABABA&lt;/literal&gt;
has 1 trailing copy.)

However, if there is only a single non-empty element, and there
are no characters in that element not part of the leading or
trailing separators, then the result is exactly the original value
of that element.

Other than for determination of the number of leading and trailing
copies of the separator, elements consisting only of copies
of the separator are ignored.


</description>
<parameters>
<parameter name="separator">
<parameter_description> a string used to separator the elements of the path.
</parameter_description>
</parameter>
<parameter name="first_element">
<parameter_description> the first element in the path
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> remaining elements in path, terminated by %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string that must be freed with g_free().
</return>
</function>

<function name="g_param_type_register_static">
<description>
Registers @name as the name of a new static type derived from
#G_TYPE_PARAM. The type system uses the information contained in
the #GParamSpecTypeInfo structure pointed to by @info to manage the
#GParamSpec type and its instances.


</description>
<parameters>
<parameter name="name">
<parameter_description> 0-terminated string used as the name of the new #GParamSpec type.
</parameter_description>
</parameter>
<parameter name="pspec_info">
<parameter_description> The #GParamSpecTypeInfo for this #GParamSpec type.
</parameter_description>
</parameter>
</parameters>
<return> The new type identifier.
</return>
</function>

<function name="g_cclosure_new_object_swap">
<description>
A variant of g_cclosure_new_swap() which uses @object as @user_data
and calls g_object_watch_closure() on @object and the created
closure. This function is useful when you have a callback closely
associated with a #GObject, and want the callback to no longer run
after the object is is freed.


</description>
<parameters>
<parameter name="callback_func">
<parameter_description> the function to invoke
</parameter_description>
</parameter>
<parameter name="object">
<parameter_description> a #GObject pointer to pass to @callback_func
</parameter_description>
</parameter>
</parameters>
<return> a new #GCClosure
</return>
</function>

<function name="g_mem_chunk_info">
<description>
Outputs debugging information for all #GMemChunk objects currently
in use. It outputs the number of #GMemChunk objects currently
allocated, and calls g_mem_chunk_print() to output information on
each one.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_source_set_priority">
<description>
Sets the priority of a source. While the main loop is being
run, a source will be dispatched if it is ready to be dispatched and no sources 
at a higher (numerically smaller) priority are ready to be dispatched.

</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
<parameter name="priority">
<parameter_description> the new priority.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_checksum_get_digest">
<description>
Gets the digest from @checksum as a raw binary vector and places it
into @buffer. The size of the digest depends on the type of checksum.

Once this function has been called, the #GChecksum is closed and can
no longer be updated with g_checksum_update().

Since: 2.16

</description>
<parameters>
<parameter name="checksum">
<parameter_description> a #GChecksum
</parameter_description>
</parameter>
<parameter name="buffer">
<parameter_description> output buffer
</parameter_description>
</parameter>
<parameter name="digest_len">
<parameter_description> an inout parameter. The caller initializes it to the size of @buffer.
After the call it contains the length of the digest.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_is_basic">
<description>
Determines if the given @type is a basic type.

Basic types are booleans, bytes, integers, doubles, strings, object
paths and signatures.

Only a basic type may be used as the key of a dictionary entry.

This function returns %FALSE for all indefinite types except
%G_VARIANT_TYPE_BASIC.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is a basic type
</return>
</function>

<function name="g_sequence_foreach">
<description>
Calls @func for each item in the sequence passing @user_data
to the function.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each item in @seq
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data passed to @func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hash_table_steal_all">
<description>
Removes all keys and their associated values from a #GHashTable
without calling the key and value destroy functions.

Since: 2.12

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_chunk_new0">
<description>
A convenience macro to allocate an atom of memory from a #GMemChunk.
It calls g_mem_chunk_alloc0() and casts the returned atom to a
pointer to the given type, avoiding a type cast in the source code.

Deprecated:2.10: Use g_slice_new0() instead

</description>
<parameters>
<parameter name="type">
<parameter_description> the type of the #GMemChunk atoms, typically a structure name.
</parameter_description>
</parameter>
<parameter name="chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the allocated atom, cast to a pointer to
@type.
</return>
</function>

<function name="g_completion_new">
<description>
Creates a new #GCompletion.

</description>
<parameters>
<parameter name="func">
<parameter_description> the function to be called to return the string representing
an item in the #GCompletion, or %NULL if strings are going to
be used as the #GCompletion items.
</parameter_description>
</parameter>
</parameters>
<return> the new #GCompletion.
</return>
</function>

<function name="g_variant_new_strv">
<description>
Constructs an array of strings #GVariant from the given array of
strings.

If @length is -1 then @strv is %NULL-terminated.

Since: 2.24

</description>
<parameters>
<parameter name="strv">
<parameter_description> an array of strings
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of @strv, or -1
</parameter_description>
</parameter>
</parameters>
<return> a new floating #GVariant instance
</return>
</function>

<function name="g_quark_to_string">
<description>
Gets the string associated with the given #GQuark.

</description>
<parameters>
<parameter name="quark">
<parameter_description> a #GQuark.
</parameter_description>
</parameter>
</parameters>
<return> the string associated with the #GQuark.
</return>
</function>

<function name="g_hash_table_new">
<description>
Creates a new #GHashTable with a reference count of 1.


</description>
<parameters>
<parameter name="hash_func">
<parameter_description> a function to create a hash value from a key.
Hash values are used to determine where keys are stored within the
#GHashTable data structure. The g_direct_hash(), g_int_hash(),
g_int64_hash(), g_double_hash() and g_str_hash() functions are provided
for some common types of keys.
If hash_func is %NULL, g_direct_hash() is used.
</parameter_description>
</parameter>
<parameter name="key_equal_func">
<parameter_description> a function to check two keys for equality.  This is
used when looking up keys in the #GHashTable.  The g_direct_equal(),
g_int_equal(), g_int64_equal(), g_double_equal() and g_str_equal()
functions are provided for the most common types of keys.
If @key_equal_func is %NULL, keys are compared directly in a similar
fashion to g_direct_equal(), but without the overhead of a function call.
</parameter_description>
</parameter>
</parameters>
<return> a new #GHashTable.
</return>
</function>

<function name="g_tree_nnodes">
<description>
Gets the number of nodes in a #GTree.


</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
</parameters>
<return> the number of nodes in the #GTree.
</return>
</function>

<function name="g_option_context_set_translation_domain">
<description>
A convenience function to use gettext() for translating
user-visible strings. 

Since: 2.12

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="domain">
<parameter_description> the domain to use
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_add_toggle_ref">
<description>
Increases the reference count of the object by one and sets a
callback to be called when all other references to the object are
dropped, or when this is already the last reference to the object
and another reference is established.

This functionality is intended for binding @object to a proxy
object managed by another memory manager. This is done with two
paired references: the strong reference added by
g_object_add_toggle_ref() and a reverse reference to the proxy
object which is either a strong reference or weak reference.

The setup is that when there are no other references to @object,
only a weak reference is held in the reverse direction from @object
to the proxy object, but when there are other references held to
@object, a strong reference is held. The @notify callback is called
when the reference from @object to the proxy object should be
&lt;firstterm&gt;toggled&lt;/firstterm&gt; from strong to weak (@is_last_ref
true) or weak to strong (@is_last_ref false).

Since a (normal) reference must be held to the object before
calling g_object_toggle_ref(), the initial state of the reverse
link is always strong.

Multiple toggle references may be added to the same gobject,
however if there are multiple toggle references to an object, none
of them will ever be notified until all but one are removed.  For
this reason, you should only ever use a toggle reference if there
is important state in the proxy object.

Since: 2.8

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description> a function to call when this reference is the
last reference to the object, or is no longer
the last reference.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to pass to @notify
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_handler_unblock">
<description>
Undoes the effect of a previous g_signal_handler_block() call.  A
blocked handler is skipped during signal emissions and will not be
invoked, unblocking it (for exactly the amount of times it has been
blocked before) reverts its &quot;blocked&quot; state, so the handler will be
recognized by the signal system and is called upon future or
currently ongoing signal emissions (since the order in which
handlers are called during signal emissions is deterministic,
whether the unblocked handler in question is called as part of a
currently ongoing emission depends on how far that emission has
proceeded yet).

The @handler_id has to be a valid id of a signal handler that is
connected to a signal of @instance and is currently blocked.

</description>
<parameters>
<parameter name="instance">
<parameter_description> The instance to unblock the signal handler of.
</parameter_description>
</parameter>
<parameter name="handler_id">
<parameter_description> Handler id of the handler to be unblocked.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_rename">
<description>
A wrapper for the POSIX rename() function. The rename() function 
renames a file, moving it between directories if required.

See your C library manual for more details about how rename() works
on your system. It is not possible in general on Windows to rename
a file that is open to some process.

Since: 2.6

</description>
<parameters>
<parameter name="oldfilename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="newfilename">
<parameter_description> a pathname in the GLib file name encoding
</parameter_description>
</parameter>
</parameters>
<return> 0 if the renaming succeeded, -1 if an error occurred

</return>
</function>

<function name="g_io_channel_get_buffer_size">
<description>
Gets the buffer size.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
</parameters>
<return> the size of the buffer.
</return>
</function>

<function name="g_param_spec_float">
<description>
Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_unichar_digit_value">
<description>
Determines the numeric value of a character as a decimal
digit.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> If @c is a decimal digit (according to
g_unichar_isdigit()), its numeric value. Otherwise, -1.
</return>
</function>

<function name="g_bookmark_file_remove_application">
<description>
Removes application registered with @name from the list of applications
that have registered a bookmark for @uri inside @bookmark.

In the event the URI cannot be found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
In the event that no application with name @app_name has registered
a bookmark for @uri,  %FALSE is returned and error is set to
#G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> the name of the application
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the application was successfully removed.

</return>
</function>

<function name="g_value_get_int64">
<description>
Get the contents of a %G_TYPE_INT64 #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_INT64
</parameter_description>
</parameter>
</parameters>
<return> 64bit integer contents of @value
</return>
</function>

<function name="g_option_context_set_main_group">
<description>
Sets a #GOptionGroup as main group of the @context. 
This has the same effect as calling g_option_context_add_group(), 
the only difference is that the options in the main group are 
treated differently when generating &lt;option&gt;--help&lt;/option&gt; output.

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="group">
<parameter_description> the group to set as main group
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_pool_get_num_unused_threads">
<description>
Returns the number of currently unused threads.


</description>
<parameters>
</parameters>
<return> the number of currently unused threads
</return>
</function>

<function name="g_string_truncate">
<description>
Cuts off the end of the GString, leaving the first @len bytes. 


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the new size of @string
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_list_concat">
<description>
Adds the second #GList onto the end of the first #GList.
Note that the elements of the second #GList are not copied.
They are used directly.


</description>
<parameters>
<parameter name="list1">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="list2">
<parameter_description> the #GList to add to the end of the first #GList
</parameter_description>
</parameter>
</parameters>
<return> the start of the new #GList
</return>
</function>

<function name="g_test_log_buffer_new">
<description>
Internal function for gtester to decode test log messages, no ABI guarantees provided.

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_strdup_printf">
<description>
Similar to the standard C sprintf() function but safer, since it 
calculates the maximum space required and allocates memory to hold 
the result. The returned string should be freed with g_free() when no 
longer needed.


</description>
<parameters>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the parameters to insert into the format string
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string holding the result
</return>
</function>

<function name="g_test_log_buffer_push">
<description>
Internal function for gtester to decode test log messages, no ABI guarantees provided.

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_unichar_iscntrl">
<description>
Determines whether a character is a control character.
Given some UTF-8 text, obtain a character value with
g_utf8_get_char().


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is a control character
</return>
</function>

<function name="g_mapped_file_new">
<description>
Maps a file into memory. On UNIX, this is using the mmap() function.

If @writable is %TRUE, the mapped buffer may be modified, otherwise
it is an error to modify the mapped buffer. Modifications to the buffer 
are not visible to other processes mapping the same file, and are not 
written back to the file.

Note that modifications of the underlying file might affect the contents
of the #GMappedFile. Therefore, mapping should only be used if the file 
will not be modified, or if all modifications of the file are done
atomically (e.g. using g_file_set_contents()). 

Since: 2.8

</description>
<parameters>
<parameter name="filename">
<parameter_description> The path of the file to load, in the GLib filename encoding
</parameter_description>
</parameter>
<parameter name="writable">
<parameter_description> whether the mapping should be writable
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated #GMappedFile which must be unref'd
with g_mapped_file_unref(), or %NULL if the mapping failed.

</return>
</function>

<function name="g_pattern_match_string">
<description>
Matches a string against a compiled pattern. If the string is to be
matched against more than one pattern, consider using
g_pattern_match() instead while supplying the reversed string.

</description>
<parameters>
<parameter name="pspec">
<parameter_description> a #GPatternSpec
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the UTF-8 encoded string to match
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @string matches @pspec
</return>
</function>

<function name="g_variant_type_new">
<description>
Creates a new #GVariantType corresponding to the type string given
by @type_string.  It is appropriate to call g_variant_type_free() on
the return value.

It is a programmer error to call this function with an invalid type
string.  Use g_variant_type_string_is_valid() if you are unsure.

Since: 2.24

</description>
<parameters>
<parameter name="type_string">
<parameter_description> a valid GVariant type string
</parameter_description>
</parameter>
</parameters>
<return> a new #GVariantType
</return>
</function>

<function name="g_source_set_callback">
<description>
Sets the callback function for a source. The callback for a source is
called from the source's dispatch function.

The exact type of @func depends on the type of source; ie. you
should not count on @func being called with @data as its first
parameter.

Typically, you won't use this function. Instead use functions specific
to the type of source you are using.

</description>
<parameters>
<parameter name="source">
<parameter_description> the source
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> a callback function
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to pass to callback function
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description> a function to call when @data is no longer in use, or %NULL.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_sort_iter">
<description>
Like g_sequence_sort(), but uses a #GSequenceIterCompareFunc instead
of a GCompareDataFunc as the compare function

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
<parameter name="cmp_func">
<parameter_description> the #GSequenceItercompare used to compare iterators in the
sequence. It is called with two iterators pointing into @seq. It should
return 0 if the iterators are equal, a negative value if the first
iterator comes before the second, and a positive value if the second
iterator comes before the first.
</parameter_description>
</parameter>
<parameter name="cmp_data">
<parameter_description> user data passed to @cmp_func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_get_user_config_dir">
<description>
Returns a base directory in which to store user-specific application 
configuration information such as user preferences and settings. 

On UNIX platforms this is determined using the mechanisms described in
the &lt;ulink url=&quot;http://www.freedesktop.org/Standards/basedir-spec&quot;&gt;
XDG Base Directory Specification&lt;/ulink&gt;.
In this case the directory retrieved will be XDG_CONFIG_HOME.

On Windows is the directory that serves as a common repository for
application-specific data. A typical path is
C:\Documents and Settings\username\Application. See documentation for
CSIDL_APPDATA.

Since: 2.6

</description>
<parameters>
</parameters>
<return> a string owned by GLib that must not be modified 
or freed.
</return>
</function>

<function name="g_async_queue_lock">
<description>
Acquires the @queue's lock. After that you can only call the
&lt;function&gt;g_async_queue_*_unlocked()&lt;/function&gt; function variants on that
@queue. Otherwise it will deadlock.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_utf8_strup">
<description>
Converts all Unicode characters in the string that have a case
to uppercase. The exact manner that this is done depends
on the current locale, and may result in the number of
characters in the string increasing. (For instance, the
German ess-zet will be changed to SS.)


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> length of @str, in bytes, or -1 if @str is nul-terminated.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string, with all characters
converted to uppercase.  
</return>
</function>

<function name="g_source_set_can_recurse">
<description>
Sets whether a source can be called recursively. If @can_recurse is
%TRUE, then while the source is being dispatched then this source
will be processed normally. Otherwise, all processing of this
source is blocked until the dispatch function returns.

</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
<parameter name="can_recurse">
<parameter_description> whether recursion is allowed for this source
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_parent">
<description>
Return the direct parent type of the passed in type.  If the passed
in type has no parent, i.e. is a fundamental type, 0 is returned.


</description>
<parameters>
<parameter name="type">
<parameter_description> The derived type.
</parameter_description>
</parameter>
</parameters>
<return> The parent type.
</return>
</function>

<function name="g_io_channel_new_file">
<description>
Open a file @filename as a #GIOChannel using mode @mode. This
channel will be closed when the last reference to it is dropped,
so there is no need to call g_io_channel_close() (though doing
so will not cause problems, as long as no attempt is made to
access the channel after it is closed).


</description>
<parameters>
<parameter name="filename">
<parameter_description> A string containing the name of a file
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> One of &quot;r&quot;, &quot;w&quot;, &quot;a&quot;, &quot;r+&quot;, &quot;w+&quot;, &quot;a+&quot;. These have
the same meaning as in fopen()
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> A location to return an error of type %G_FILE_ERROR
</parameter_description>
</parameter>
</parameters>
<return> A #GIOChannel on success, %NULL on failure.
</return>
</function>

<function name="g_queue_insert_before">
<description>
Inserts @data into @queue before @sibling.

@sibling must be part of @queue.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="sibling">
<parameter_description> a #GList link that &lt;emphasis&gt;must&lt;/emphasis&gt; be part of @queue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to insert
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_timer_continue">
<description>
Resumes a timer that has previously been stopped with
g_timer_stop(). g_timer_stop() must be called before using this
function.

Since: 2.4

</description>
<parameters>
<parameter name="timer">
<parameter_description> a #GTimer.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_free">
<description>
Frees the memory allocated for @seq. If @seq has a data destroy 
function associated with it, that function is called on all items in
@seq.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_flags">
<description>
Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS
property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="flags_type">
<parameter_description> a #GType derived from %G_TYPE_FLAGS
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_datalist_unset_flags">
<description>
Turns off flag values for a data list. See g_datalist_unset_flags()

Since: 2.8

</description>
<parameters>
<parameter name="datalist">
<parameter_description> pointer to the location that holds a list
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> the flags to turn off. The values of the flags are
restricted by %G_DATALIST_FLAGS_MASK (currently
3: giving two possible boolean flags).
A value for @flags that doesn't fit within the mask is
an error.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_utf8_collate_key_for_filename">
<description>
Converts a string into a collation key that can be compared
with other collation keys produced by the same function using strcmp(). 

In order to sort filenames correctly, this function treats the dot '.' 
as a special case. Most dictionary orderings seem to consider it
insignificant, thus producing the ordering &quot;event.c&quot; &quot;eventgenerator.c&quot;
&quot;event.h&quot; instead of &quot;event.c&quot; &quot;event.h&quot; &quot;eventgenerator.c&quot;. Also, we
would like to treat numbers intelligently so that &quot;file1&quot; &quot;file10&quot; &quot;file5&quot;
is sorted as &quot;file1&quot; &quot;file5&quot; &quot;file10&quot;.

Note that this function depends on the 
&lt;link linkend=&quot;setlocale&quot;&gt;current locale&lt;/link&gt;.

Since: 2.8

</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> length of @str, in bytes, or -1 if @str is nul-terminated.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string. This string should
be freed with g_free() when you are done with it.

</return>
</function>

<function name="g_checksum_update">
<description>
Feeds @data into an existing #GChecksum. The checksum must still be
open, that is g_checksum_get_string() or g_checksum_get_digest() must
not have been called on @checksum.

Since: 2.16

</description>
<parameters>
<parameter name="checksum">
<parameter_description> a #GChecksum
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> buffer used to compute the checksum
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> size of the buffer, or -1 if it is a null-terminated string.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_get_locale_string_list">
<description>
Returns the values associated with @key under @group_name
translated in the given @locale if available.  If @locale is
%NULL then the current locale is assumed.

If @key cannot be found then %NULL is returned and @error is set 
to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the values associated
with @key cannot be interpreted or no suitable translations
can be found then the untranslated values are returned. The 
returned array is %NULL-terminated, so @length may optionally 
be %NULL.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="locale">
<parameter_description> a locale identifier or %NULL
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> return location for the number of returned strings or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated %NULL-terminated string array
or %NULL if the key isn't found. The string array should be freed
with g_strfreev().

</return>
</function>

<function name="g_io_create_watch">
<description>
Creates a #GSource that's dispatched when @condition is met for the 
given @channel. For example, if condition is #G_IO_IN, the source will 
be dispatched when there's data available for reading.

g_io_add_watch() is a simpler interface to this same functionality, for 
the case where you want to add the source to the default main loop context 
at the default priority.

On Windows, polling a #GSource created to watch a channel for a socket
puts the socket in non-blocking mode. This is a side-effect of the
implementation and unavoidable.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel to watch
</parameter_description>
</parameter>
<parameter name="condition">
<parameter_description> conditions to watch for
</parameter_description>
</parameter>
</parameters>
<return> a new #GSource
</return>
</function>

<function name="g_array_append_val">
<description>
Adds the value on to the end of the array. The array will grow in
size automatically if necessary.

&lt;note&gt;&lt;para&gt;g_array_append_val() is a macro which uses a reference
to the value parameter @v. This means that you cannot use it with
literal values such as &quot;27&quot;. You must use variables.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="a">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="v">
<parameter_description> the value to append to the #GArray.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_array_unref">
<description>
Atomically decrements the reference count of @array by one. If the
reference count drops to 0, all memory allocated by the array is
released. This function is MT-safe and may be called from any
thread.

Since: 2.22

</description>
<parameters>
<parameter name="array">
<parameter_description> A #GArray.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_get_blurb">
<description>
Get the short description of a #GParamSpec.


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
</parameters>
<return> the short description of @pspec.
</return>
</function>

<function name="g_slist_remove_all">
<description>
Removes all list nodes with data equal to @data. 
Returns the new head of the list. Contrast with 
g_slist_remove() which removes only the first node 
matching the given data.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to remove
</parameter_description>
</parameter>
</parameters>
<return> new head of @list
</return>
</function>

<function name="g_bit_unlock">
<description>
Clears the indicated @lock_bit in @address.  If another thread is
currently blocked in g_bit_lock() on this same bit then it will be
woken up.

This function accesses @address atomically.  All other accesses to
@address must be atomic in order for this function to work
reliably.

Since: 2.24

</description>
<parameters>
<parameter name="address">
<parameter_description> a pointer to an integer
</parameter_description>
</parameter>
<parameter name="lock_bit">
<parameter_description> a bit value between 0 and 31
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_delete_link">
<description>
Removes @link_ from @queue and frees it.

@link_ must be part of @queue.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="link_">
<parameter_description> a #GList link that &lt;emphasis&gt;must&lt;/emphasis&gt; be part of @queue
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_get_bytestring_array">
<description>
Gets the contents of an array of array of bytes #GVariant.  This call
makes a shallow copy; the return result should be released with
g_free(), but the individual strings must not be modified.

If @length is non-%NULL then the number of elements in the result is
stored there.  In any case, the resulting array will be
%NULL-terminated.

For an empty array, @length will be set to 0 and a pointer to a
%NULL pointer will be returned.

Since: 2.26

</description>
<parameters>
<parameter name="value">
<parameter_description> an array of array of bytes #GVariant ('aay')
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of the result, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> an array of constant strings
</return>
</function>

<function name="g_io_add_watch">
<description>
Adds the #GIOChannel into the default main loop context
with the default priority.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="condition">
<parameter_description> the condition to watch for
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call when the condition is satisfied
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to @func
</parameter_description>
</parameter>
</parameters>
<return> the event source id
</return>
</function>

<function name="g_variant_new_bytestring">
<description>
Creates an array-of-bytes #GVariant with the contents of @string.
This function is just like g_variant_new_string() except that the
string need not be valid utf8.

The nul terminator character at the end of the string is stored in
the array.

Since: 2.26

</description>
<parameters>
<parameter name="string">
<parameter_description> a normal nul-terminated string in no particular encoding
</parameter_description>
</parameter>
</parameters>
<return> a new bytestring #GVariant instance
</return>
</function>

<function name="g_list_foreach">
<description>
Calls a function for each element of a #GList.

</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call with each element's data
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_child_index">
<description>
Gets the position of the first child of a #GNode 
which contains the given data.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to find
</parameter_description>
</parameter>
</parameters>
<return> the index of the child of @node which contains 
@data, or -1 if the data is not found
</return>
</function>

<function name="g_hostname_is_ip_address">
<description>
Tests if @hostname is the string form of an IPv4 or IPv6 address.
(Eg, &quot;192.168.0.1&quot;.)

Since: 2.22

</description>
<parameters>
<parameter name="hostname">
<parameter_description> a hostname (or IP address in string form)
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @hostname is an IP address

</return>
</function>

<function name="g_string_insert_unichar">
<description>
Converts a Unicode character into UTF-8, and insert it
into the string at the given position.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="pos">
<parameter_description> the position at which to insert character, or -1 to
append at the end of the string
</parameter_description>
</parameter>
<parameter name="wc">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_mutex_lock">
<description>
Locks @mutex. If @mutex is already locked by another thread, the
current thread will block until @mutex is unlocked by the other
thread.

This function can be used even if g_thread_init() has not yet been
called, and, in that case, will do nothing.

&lt;note&gt;&lt;para&gt;#GMutex is neither guaranteed to be recursive nor to be
non-recursive, i.e. a thread could deadlock while calling
g_mutex_lock(), if it already has locked @mutex. Use
#GStaticRecMutex, if you need recursive mutexes.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GMutex.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_append">
<description>
Adds a new element on to the end of the list.

&lt;note&gt;&lt;para&gt;
The return value is the new start of the list, which may 
have changed, so make sure you store the new value.
&lt;/para&gt;&lt;/note&gt;

&lt;note&gt;&lt;para&gt;
Note that g_slist_append() has to traverse the entire list 
to find the end, which is inefficient when adding multiple 
elements. A common idiom to avoid the inefficiency is to prepend 
the elements and reverse the list when all elements have been added.
&lt;/para&gt;&lt;/note&gt;

|[
/ * Notice that these are initialized to the empty list. * /
GSList *list = NULL, *number_list = NULL;

/ * This is a list of strings. * /
list = g_slist_append (list, &quot;first&quot;);
list = g_slist_append (list, &quot;second&quot;);

/ * This is a list of integers. * /
number_list = g_slist_append (number_list, GINT_TO_POINTER (27));
number_list = g_slist_append (number_list, GINT_TO_POINTER (14));
]|


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GSList
</return>
</function>

<function name="g_relation_select">
<description>
Returns all of the tuples which have the given key in the given
field. Use g_tuples_index() to access the returned records. The
returned records should be freed with g_tuples_destroy().

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="relation">
<parameter_description> a #GRelation.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the value to compare with.
</parameter_description>
</parameter>
<parameter name="field">
<parameter_description> the field of each record to match.
</parameter_description>
</parameter>
</parameters>
<return> the records (tuples) that matched.
</return>
</function>

<function name="g_variant_new_boolean">
<description>
Creates a new boolean #GVariant instance -- either %TRUE or %FALSE.

Since: 2.24

</description>
<parameters>
<parameter name="boolean">
<parameter_description> a #gboolean value
</parameter_description>
</parameter>
</parameters>
<return> a new boolean #GVariant instance
</return>
</function>

<function name="g_unichar_islower">
<description>
Determines whether a character is a lowercase letter.
Given some UTF-8 text, obtain a character value with
g_utf8_get_char().


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is a lowercase letter
</return>
</function>

<function name="g_variant_store">
<description>
Stores the serialised form of @value at @data.  @data should be
large enough.  See g_variant_get_size().

The stored data is in machine native byte order but may not be in
fully-normalised form if read from an untrusted source.  See
g_variant_normalise() for a solution.

This function is approximately O(n) in the size of @data.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> the #GVariant to store
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the location to store the serialised data at
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_get">
<description>
Gets properties of an object.

In general, a copy is made of the property contents and the caller
is responsible for freeing the memory in the appropriate manner for
the type, for instance by calling g_free() or g_object_unref().

&lt;example&gt;
&lt;title&gt;Using g_object_get(&lt;!-- --&gt;)&lt;/title&gt;
An example of using g_object_get() to get the contents
of three properties - one of type #G_TYPE_INT,
one of type #G_TYPE_STRING, and one of type #G_TYPE_OBJECT:
&lt;programlisting&gt;
gint intval;
gchar *strval;
GObject *objval;

g_object_get (my_object,
&quot;int-property&quot;, &amp;intval,
&quot;str-property&quot;, &amp;strval,
&quot;obj-property&quot;, &amp;objval,
NULL);

// Do something with intval, strval, objval

g_free (strval);
g_object_unref (objval);
&lt;/programlisting&gt;
&lt;/example&gt;

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="first_property_name">
<parameter_description> name of the first property to get
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> return location for the first property, followed optionally by more
name/return location pairs, followed by %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_push_allocator">
<description>
Sets the allocator to use to allocate #GNode elements. Use
g_node_pop_allocator() to restore the previous allocator.

Note that this function is not available if GLib has been compiled
with &lt;option&gt;--disable-mem-pools&lt;/option&gt;

Deprecated:2.10: It does nothing, since #GNode has been converted to
the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt;

</description>
<parameters>
<parameter name="dummy">
<parameter_description> the #GAllocator to use when allocating #GNode elements.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_pool_new">
<description>
Creates a new #GParamSpecPool.

If @type_prefixing is %TRUE, lookups in the newly created pool will
allow to specify the owner as a colon-separated prefix of the
property name, like &quot;GtkContainer:border-width&quot;. This feature is
deprecated, so you should always set @type_prefixing to %FALSE.


</description>
<parameters>
<parameter name="type_prefixing">
<parameter_description> Whether the pool will support type-prefixed property names.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated #GParamSpecPool.
</return>
</function>

<function name="g_sequence_insert_sorted">
<description>
Inserts @data into @sequence using @func to determine the new position.
The sequence must already be sorted according to @cmp_func; otherwise the
new position of @data is undefined.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to insert
</parameter_description>
</parameter>
<parameter name="cmp_func">
<parameter_description> the #GCompareDataFunc used to compare items in the sequence. It
is called with two items of the @seq and @user_data. It should
return 0 if the items are equal, a negative value if the first
item comes before the second, and a positive value if the second
item comes before the first.
</parameter_description>
</parameter>
<parameter name="cmp_data">
<parameter_description> user data passed to @cmp_func.
</parameter_description>
</parameter>
</parameters>
<return> a #GSequenceIter pointing to the new item.

</return>
</function>

<function name="g_value_set_boxed_take_ownership">
<description>
This is an internal function introduced mainly for C marshallers.

Deprecated: 2.4: Use g_value_take_boxed() instead.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_BOXED derived type
</parameter_description>
</parameter>
<parameter name="v_boxed">
<parameter_description> duplicated unowned boxed value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_get_int16">
<description>
Returns the 16-bit signed integer value of @value.

It is an error to call this function with a @value of any type
other than %G_VARIANT_TYPE_INT16.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a int16 #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> a #gint16
</return>
</function>

<function name="g_sequence_iter_next">
<description>
Returns an iterator pointing to the next position after @iter. If
@iter is the end iterator, the end iterator is returned.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return> a #GSequenceIter pointing to the next position after @iter.

</return>
</function>

<function name="g_ptr_array_sized_new">
<description>
Creates a new #GPtrArray with @reserved_size pointers preallocated
and a reference count of 1. This avoids frequent reallocation, if
you are going to add many pointers to the array. Note however that
the size of the array is still 0.

</description>
<parameters>
<parameter name="reserved_size">
<parameter_description> number of pointers preallocated.
</parameter_description>
</parameter>
</parameters>
<return> the new #GPtrArray.
</return>
</function>

<function name="g_object_remove_toggle_ref">
<description>
Removes a reference added with g_object_add_toggle_ref(). The
reference count of the object is decreased by one.

Since: 2.8

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description> a function to call when this reference is the
last reference to the object, or is no longer
the last reference.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to pass to @notify
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_strdup_value_contents">
<description>
Return a newly allocated string, which describes the contents of a
#GValue.  The main purpose of this function is to describe #GValue
contents for debugging output, the way in which the contents are
described may change between different GLib versions.


</description>
<parameters>
<parameter name="value">
<parameter_description> #GValue which contents are to be described.
</parameter_description>
</parameter>
</parameters>
<return> Newly allocated string.
</return>
</function>

<function name="g_option_context_parse">
<description>
Parses the command line arguments, recognizing options
which have been added to @context. A side-effect of 
calling this function is that g_set_prgname() will be
called.

If the parsing is successful, any parsed arguments are
removed from the array and @argc and @argv are updated 
accordingly. A '--' option is stripped from @argv
unless there are unparsed options before and after it, 
or some of the options after it start with '-'. In case 
of an error, @argc and @argv are left unmodified. 

If automatic &lt;option&gt;--help&lt;/option&gt; support is enabled
(see g_option_context_set_help_enabled()), and the 
@argv array contains one of the recognized help options,
this function will produce help output to stdout and
call &lt;literal&gt;exit (0)&lt;/literal&gt;.

Note that function depends on the 
&lt;link linkend=&quot;setlocale&quot;&gt;current locale&lt;/link&gt; for 
automatic character set conversion of string and filename
arguments.

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="argc">
<parameter_description> a pointer to the number of command line arguments
</parameter_description>
</parameter>
<parameter name="argv">
<parameter_description> a pointer to the array of command line arguments
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> a return location for errors 
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the parsing was successful, 
%FALSE if an error occurred

</return>
</function>

<function name="g_source_set_name">
<description>
Sets a name for the source, used in debugging and profiling.
The name defaults to #NULL.

The source name should describe in a human-readable way
what the source does. For example, &quot;X11 event queue&quot;
or &quot;GTK+ repaint idle handler&quot; or whatever it is.

It is permitted to call this function multiple times, but is not
recommended due to the potential performance impact.  For example,
one could change the name in the &quot;check&quot; function of a #GSourceFuncs 
to include details like the event type in the source name.

Since: 2.26

</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> debug name for the source
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_set_uint64">
<description>
Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_UINT64
</parameter_description>
</parameter>
<parameter name="v_uint64">
<parameter_description> unsigned 64bit integer value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_search">
<description>
Returns an iterator pointing to the position where @data would
be inserted according to @cmp_func and @cmp_data.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data for the new item
</parameter_description>
</parameter>
<parameter name="cmp_func">
<parameter_description> the #GCompareDataFunc used to compare items in the sequence. It
is called with two items of the @seq and @user_data. It should
return 0 if the items are equal, a negative value if the first
item comes before the second, and a positive value if the second
item comes before the first.
</parameter_description>
</parameter>
<parameter name="cmp_data">
<parameter_description> user data passed to @cmp_func.
</parameter_description>
</parameter>
</parameters>
<return> an #GSequenceIter pointing to the position where @data
would have been inserted according to @cmp_func and @cmp_data.

</return>
</function>

<function name="g_cclosure_marshal_VOID__UINT_POINTER">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 3
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding instance, arg1 and arg2
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_class_unref">
<description>
Decrements the reference count of the class structure being passed in.
Once the last reference count of a class has been released, classes
may be finalized by the type system, so further dereferencing of a
class pointer after g_type_class_unref() are invalid.

</description>
<parameters>
<parameter name="g_class">
<parameter_description> The #GTypeClass structure to unreference.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_set_int">
<description>
Set the contents of a %G_TYPE_INT #GValue to @v_int.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_INT
</parameter_description>
</parameter>
<parameter name="v_int">
<parameter_description> integer value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_mapped_file_unref">
<description>
Decrements the reference count of @file by one.  If the reference count
drops to 0, unmaps the buffer of @file and frees it.

It is safe to call this function from any thread.

Since 2.22

</description>
<parameters>
<parameter name="file">
<parameter_description> a #GMappedFile
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_match_info_is_partial_match">
<description>
Usually if the string passed to g_regex_match*() matches as far as
it goes, but is too short to match the entire pattern, %FALSE is
returned. There are circumstances where it might be helpful to
distinguish this case from other cases in which there is no match.

Consider, for example, an application where a human is required to
type in data for a field with specific formatting requirements. An
example might be a date in the form ddmmmyy, defined by the pattern
&quot;^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$&quot;.
If the application sees the user’s keystrokes one by one, and can
check that what has been typed so far is potentially valid, it is
able to raise an error as soon as a mistake is made.

GRegex supports the concept of partial matching by means of the
#G_REGEX_MATCH_PARTIAL flag. When this is set the return code for
g_regex_match() or g_regex_match_full() is, as usual, %TRUE
for a complete match, %FALSE otherwise. But, when these functions
return %FALSE, you can check if the match was partial calling
g_match_info_is_partial_match().

When using partial matching you cannot use g_match_info_fetch*().

Because of the way certain internal optimizations are implemented
the partial matching algorithm cannot be used with all patterns.
So repeated single characters such as &quot;a{2,4}&quot; and repeated single
meta-sequences such as &quot;\d+&quot; are not permitted if the maximum number
of occurrences is greater than one. Optional items such as &quot;\d?&quot;
(where the maximum is one) are permitted. Quantifiers with any values
are permitted after parentheses, so the invalid examples above can be
coded thus &quot;(a){2,4}&quot; and &quot;(\d)+&quot;. If #G_REGEX_MATCH_PARTIAL is set
for a pattern that does not conform to the restrictions, matching
functions return an error.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> a #GMatchInfo structure
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the match was partial, %FALSE otherwise

</return>
</function>

<function name="g_timer_stop">
<description>
Marks an end time, so calls to g_timer_elapsed() will return the
difference between this end time and the start time.

</description>
<parameters>
<parameter name="timer">
<parameter_description> a #GTimer.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_match_info_fetch_all">
<description>
Bundles up pointers to each of the matching substrings from a match
and stores them in an array of gchar pointers. The first element in
the returned array is the match number 0, i.e. the entire matched
text.

If a sub pattern didn't match anything (e.g. sub pattern 1, matching
&quot;b&quot; against &quot;(a)?b&quot;) then an empty string is inserted.

If the last match was obtained using the DFA algorithm, that is using
g_regex_match_all() or g_regex_match_all_full(), the retrieved
strings are not that matched by sets of parentheses but that of the
matched substring. Substrings are matched in reverse order of length,
so the first one is the longest match.

The strings are fetched from the string passed to the match function,
so you cannot call this function after freeing the string.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> a #GMatchInfo structure
</parameter_description>
</parameter>
</parameters>
<return> a %NULL-terminated array of gchar * pointers.
It must be freed using g_strfreev(). If the previous match failed
%NULL is returned

</return>
</function>

<function name="g_signal_get_invocation_hint">
<description>
Returns the invocation hint of the innermost signal emission of instance.


</description>
<parameters>
<parameter name="instance">
<parameter_description> the instance to query
</parameter_description>
</parameter>
</parameters>
<return> the invocation hint of the innermost signal emission.
</return>
</function>

<function name="g_type_get_plugin">
<description>
Returns the #GTypePlugin structure for @type or
%NULL if @type does not have a #GTypePlugin structure.


</description>
<parameters>
<parameter name="type">
<parameter_description> The #GType to retrieve the plugin for.
</parameter_description>
</parameter>
</parameters>
<return> The corresponding plugin if @type is a dynamic type,
%NULL otherwise.
</return>
</function>

<function name="g_utf8_get_char">
<description>
Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
If @p does not point to a valid UTF-8 encoded character, results are
undefined. If you are not sure that the bytes are complete
valid Unicode characters, you should use g_utf8_get_char_validated()
instead.


</description>
<parameters>
<parameter name="p">
<parameter_description> a pointer to Unicode character encoded as UTF-8
</parameter_description>
</parameter>
</parameters>
<return> the resulting character
</return>
</function>

<function name="g_open">
<description>
A wrapper for the POSIX open() function. The open() function is
used to convert a pathname into a file descriptor.

On POSIX systems file descriptors are implemented by the operating
system. On Windows, it's the C library that implements open() and
file descriptors. The actual Win32 API for opening files is quite
different, see MSDN documentation for CreateFile(). The Win32 API
uses file handles, which are more randomish integers, not small
integers like file descriptors.

Because file descriptors are specific to the C library on Windows,
the file descriptor returned by this function makes sense only to
functions in the same C library. Thus if the GLib-using code uses a
different C library than GLib does, the file descriptor returned by
this function cannot be passed to C library functions like write()
or read().

See your C library manual for more details about open().

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> as in open()
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> as in open()
</parameter_description>
</parameter>
</parameters>
<return> a new file descriptor, or -1 if an error occurred. The
return value can be used exactly like the return value from open().

</return>
</function>

<function name="g_variant_is_floating">
<description>
Checks whether @value has a floating reference count.

This function should only ever be used to assert that a given variant
is or is not floating, or for debug purposes. To acquire a reference
to a variant that might be floating, always use g_variant_ref_sink().

See g_variant_ref_sink() for more information about floating reference
counts.

Since: 2.26

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return> whether @value is floating
</return>
</function>

<function name="g_ascii_toupper">
<description>
Convert a character to ASCII upper case.

Unlike the standard C library toupper() function, this only
recognizes standard ASCII letters and ignores the locale, returning
all non-ASCII characters unchanged, even if they are upper case
letters in a particular character set. Also unlike the standard
library function, this takes and returns a char, not an int, so
don't call it on %EOF but no need to worry about casting to #guchar
before passing a possibly non-ASCII character in.


</description>
<parameters>
<parameter name="c">
<parameter_description> any character.
</parameter_description>
</parameter>
</parameters>
<return> the result of converting @c to upper case.
If @c is not an ASCII lower case letter,
@c is returned unchanged.
</return>
</function>

<function name="g_flags_register_static">
<description>
Registers a new static flags type with the name @name.

It is normally more convenient to let &lt;link
linkend=&quot;glib-mkenums&quot;&gt;glib-mkenums&lt;/link&gt; generate a
my_flags_get_type() function from a usual C enumeration definition
than to write one yourself using g_flags_register_static().


</description>
<parameters>
<parameter name="name">
<parameter_description> A nul-terminated string used as the name of the new type.
</parameter_description>
</parameter>
<parameter name="const_static_values">
<parameter_description> An array of #GFlagsValue structs for the possible
flags values. The array is terminated by a struct with all members being 0.
GObject keeps a reference to the data, so it cannot be stack-allocated.
</parameter_description>
</parameter>
</parameters>
<return> The new type identifier.
</return>
</function>

<function name="g_cclosure_marshal_VOID__FLAGS">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gint arg1, gpointer user_data)&lt;/literal&gt; where the #gint parameter denotes a flags type.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the flags parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_mem_chunk_free">
<description>
Frees an atom in a #GMemChunk. This should only be called if the
#GMemChunk was created with #G_ALLOC_AND_FREE. Otherwise it will
simply return.

Deprecated:2.10: Use g_slice_free1() instead

</description>
<parameters>
<parameter name="mem_chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
<parameter name="mem">
<parameter_description> a pointer to the atom to free.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_is_maybe">
<description>
Determines if the given @type is a maybe type.  This is true if the
type string for @type starts with an 'm'.

This function returns %TRUE for any indefinite type for which every
definite subtype is a maybe type -- %G_VARIANT_TYPE_MAYBE, for
example.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is a maybe type
</return>
</function>

<function name="g_base64_decode_inplace">
<description>
Decode a sequence of Base-64 encoded text into binary data
by overwriting the input data.

Since: 2.20

</description>
<parameters>
<parameter name="text">
<parameter_description> zero-terminated string with base64 text to decode
</parameter_description>
</parameter>
<parameter name="out_len">
<parameter_description> The length of the decoded data is written here
</parameter_description>
</parameter>
</parameters>
<return> The binary data that @text responds. This pointer
is the same as the input @text.

</return>
</function>

<function name="g_type_add_class_cache_func">
<description>
Adds a #GTypeClassCacheFunc to be called before the reference count of a
class goes from one to zero. This can be used to prevent premature class
destruction. All installed #GTypeClassCacheFunc functions will be chained
until one of them returns %TRUE. The functions have to check the class id
passed in to figure whether they actually want to cache the class of this
type, since all classes are routed through the same #GTypeClassCacheFunc
chain.

</description>
<parameters>
<parameter name="cache_data">
<parameter_description> data to be passed to @cache_func
</parameter_description>
</parameter>
<parameter name="cache_func">
<parameter_description> a #GTypeClassCacheFunc
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_prefix_error">
<description>
Formats a string according to @format and
prefix it to an existing error message.  If
@err is %NULL (ie: no error variable) then do
nothing.

If *@err is %NULL (ie: an error variable is
present but there is no error condition) then
also do nothing.  Whether or not it makes
sense to take advantage of this feature is up
to you.

Since: 2.16

</description>
<parameters>
<parameter name="err">
<parameter_description> a return location for a #GError, or %NULL
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> printf()-style format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments to @format
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hash_table_get_values">
<description>
Retrieves every value inside @hash_table. The returned data is
valid until @hash_table is modified.

Since: 2.14

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable
</parameter_description>
</parameter>
</parameters>
<return> a #GList containing all the values inside the hash
table. The content of the list is owned by the hash table and
should not be modified or freed. Use g_list_free() when done
using the list.

</return>
</function>

<function name="g_object_interface_find_property">
<description>
Find the #GParamSpec with the given name for an
interface. Generally, the interface vtable passed in as @g_iface
will be the default vtable from g_type_default_interface_ref(), or,
if you know the interface has already been loaded,
g_type_default_interface_peek().

Since: 2.4


</description>
<parameters>
<parameter name="g_iface">
<parameter_description> any interface vtable for the interface, or the default
vtable for the interface
</parameter_description>
</parameter>
<parameter name="property_name">
<parameter_description> name of a property to lookup.
</parameter_description>
</parameter>
</parameters>
<return> the #GParamSpec for the property of the interface with the
name @property_name, or %NULL if no such property exists.
</return>
</function>

<function name="g_node_new">
<description>
Creates a new #GNode containing the given data.
Used to create the first node in a tree.


</description>
<parameters>
<parameter name="data">
<parameter_description> the data of the new node
</parameter_description>
</parameter>
</parameters>
<return> a new #GNode
</return>
</function>

<function name="g_main_context_get_thread_default">
<description>
Gets the thread-default #GMainContext for this thread. Asynchronous
operations that want to be able to be run in contexts other than
the default one should call this method to get a #GMainContext to
add their #GSource&lt;!-- --&gt;s to. (Note that even in single-threaded
programs applications may sometimes want to temporarily push a
non-default context, so it is not safe to assume that this will
always return %NULL if threads are not initialized.)

Since: 2.22

</description>
<parameters>
</parameters>
<return> the thread-default #GMainContext, or %NULL if the
thread-default context is the global default context.

</return>
</function>

<function name="g_slist_insert_sorted">
<description>
Inserts a new element into the list, using the given 
comparison function to determine its position.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to compare elements in the list. 
It should return a number &gt; 0 if the first parameter 
comes after the second parameter in the sort order.
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GSList
</return>
</function>

<function name="g_hash_table_foreach_steal">
<description>
Calls the given function for each key/value pair in the #GHashTable.
If the function returns %TRUE, then the key/value pair is removed from the
#GHashTable, but no key or value destroy functions are called.

See #GHashTableIter for an alternative way to loop over the 
key/value pairs in the hash table.


</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each key/value pair.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return> the number of key/value pairs removed.
</return>
</function>

<function name="g_base64_encode_close">
<description>
Flush the status from a sequence of calls to g_base64_encode_step().

The output buffer must be large enough to fit all the data that will
be written to it. It will need up to 4 bytes, or up to 5 bytes if
line-breaking is enabled.

Since: 2.12

</description>
<parameters>
<parameter name="break_lines">
<parameter_description> whether to break long lines
</parameter_description>
</parameter>
<parameter name="out">
<parameter_description> pointer to destination buffer
</parameter_description>
</parameter>
<parameter name="state">
<parameter_description> Saved state from g_base64_encode_step()
</parameter_description>
</parameter>
<parameter name="save">
<parameter_description> Saved state from g_base64_encode_step()
</parameter_description>
</parameter>
</parameters>
<return> The number of bytes of output that was written

</return>
</function>

<function name="g_datalist_id_set_data">
<description>
Sets the data corresponding to the given #GQuark id. Any previous
data with the same key is removed, and its destroy function is
called.

</description>
<parameters>
<parameter name="dl">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="q">
<parameter_description> the #GQuark to identify the data element.
</parameter_description>
</parameter>
<parameter name="d">
<parameter_description> the data element, or %NULL to remove any previous element
corresponding to @q.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_str_has_suffix">
<description>
Looks whether the string @str ends with @suffix.

Since: 2.2

</description>
<parameters>
<parameter name="str">
<parameter_description> a nul-terminated string.
</parameter_description>
</parameter>
<parameter name="suffix">
<parameter_description> the nul-terminated suffix to look for.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @str end with @suffix, %FALSE otherwise.

</return>
</function>

<function name="g_path_get_dirname">
<description>
Gets the directory components of a file name.  If the file name has no
directory components &quot;.&quot; is returned.  The returned string should be
freed when no longer needed.


</description>
<parameters>
<parameter name="file_name">
<parameter_description> the name of the file.
</parameter_description>
</parameter>
</parameters>
<return> the directory components of the file.
</return>
</function>

<function name="g_option_context_set_description">
<description>
Adds a string to be displayed in &lt;option&gt;--help&lt;/option&gt; output
after the list of options. This text often includes a bug reporting
address.

Note that the summary is translated (see 
g_option_context_set_translate_func()).

Since: 2.12

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="description">
<parameter_description> a string to be shown in &lt;option&gt;--help&lt;/option&gt; output 
after the list of options, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_get_uint16">
<description>
Returns the 16-bit unsigned integer value of @value.

It is an error to call this function with a @value of any type
other than %G_VARIANT_TYPE_UINT16.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a uint16 #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> a #guint16
</return>
</function>

<function name="g_pattern_match_simple">
<description>
Matches a string against a pattern given as a string. If this
function is to be called in a loop, it's more efficient to compile
the pattern once with g_pattern_spec_new() and call
g_pattern_match_string() repeatedly.

</description>
<parameters>
<parameter name="pattern">
<parameter_description> the UTF-8 encoded pattern
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the UTF-8 encoded string to match
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @string matches @pspec
</return>
</function>

<function name="g_bookmark_file_set_visited">
<description>
Sets the time the bookmark for @uri was last visited.

If no bookmark for @uri is found then it is created.

The &quot;visited&quot; time should only be set if the bookmark was launched, 
either using the command line retrieved by g_bookmark_file_get_app_info()
or by the default application for the bookmark's MIME type, retrieved
using g_bookmark_file_get_mime_type().  Changing the &quot;visited&quot; time
does not affect the &quot;modified&quot; time.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="visited">
<parameter_description> a timestamp or -1 to use the current time
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_insert">
<description>
Inserts a new element into the list at the given position.


</description>
<parameters>
<parameter name="list">
<parameter_description> a pointer to a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
<parameter name="position">
<parameter_description> the position to insert the element. If this is 
negative, or is larger than the number of elements in the 
list, the new element is added on to the end of the list.
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GList
</return>
</function>

<function name="g_build_filenamev">
<description>
Behaves exactly like g_build_filename(), but takes the path elements 
as a string array, instead of varargs. This function is mainly
meant for language bindings.

Since: 2.8

</description>
<parameters>
<parameter name="args">
<parameter_description> %NULL-terminated array of strings containing the path elements.
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string that must be freed with g_free().

</return>
</function>

<function name="g_string_append_uri_escaped">
<description>
Appends @unescaped to @string, escaped any characters that
are reserved in URIs using URI-style escape sequences.

Since: 2.16

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="unescaped">
<parameter_description> a string
</parameter_description>
</parameter>
<parameter name="reserved_chars_allowed">
<parameter_description> a string of reserved characters allowed to be used, or %NULL
</parameter_description>
</parameter>
<parameter name="allow_utf8">
<parameter_description> set %TRUE if the escaped string may include UTF8 characters
</parameter_description>
</parameter>
</parameters>
<return> @string

</return>
</function>

<function name="g_queue_get_length">
<description>
Returns the number of items in @queue.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
</parameters>
<return> The number of items in @queue.

</return>
</function>

<function name="g_variant_get_data">
<description>
Returns a pointer to the serialised form of a #GVariant instance.
The returned data may not be in fully-normalised form if read from an
untrusted source.  The returned data must not be freed; it remains
valid for as long as @value exists.

If @value is a fixed-sized value that was deserialised from a
corrupted serialised container then %NULL may be returned.  In this
case, the proper thing to do is typically to use the appropriate
number of nul bytes in place of @value.  If @value is not fixed-sized
then %NULL is never returned.

In the case that @value is already in serialised form, this function
is O(1).  If the value is not already in serialised form,
serialisation occurs implicitly and is approximately O(n) in the size
of the result.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> the serialised form of @value, or %NULL
</return>
</function>

<function name="g_utf8_strreverse">
<description>
Reverses a UTF-8 string. @str must be valid UTF-8 encoded text. 
(Use g_utf8_validate() on all text before trying to use UTF-8 
utility functions with it.)

This function is intended for programmatic uses of reversed strings.
It pays no attention to decomposed characters, combining marks, byte 
order marks, directional indicators (LRM, LRO, etc) and similar 
characters which might need special handling when reversing a string 
for display purposes.

Note that unlike g_strreverse(), this function returns
newly-allocated memory, which should be freed with g_free() when
no longer needed. 

Since: 2.2

</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length of @str to use, in bytes. If @len &lt; 0,
then the string is nul-terminated.
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string which is the reverse of @str.

</return>
</function>

<function name="g_idle_remove_by_data">
<description>
Removes the idle function with the given data.


</description>
<parameters>
<parameter name="data">
<parameter_description> the data for the idle source's callback.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if an idle source was found and removed.
</return>
</function>

<function name="g_mutex_trylock">
<description>
Tries to lock @mutex. If @mutex is already locked by another thread,
it immediately returns %FALSE. Otherwise it locks @mutex and returns
%TRUE.

This function can be used even if g_thread_init() has not yet been
called, and, in that case, will immediately return %TRUE.

&lt;note&gt;&lt;para&gt;#GMutex is neither guaranteed to be recursive nor to be
non-recursive, i.e. the return value of g_mutex_trylock() could be
both %FALSE or %TRUE, if the current thread already has locked
@mutex. Use #GStaticRecMutex, if you need recursive
mutexes.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GMutex.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE, if @mutex could be locked.
</return>
</function>

<function name="g_variant_is_normal_form">
<description>
Checks if @value is in normal form.

The main reason to do this is to detect if a given chunk of
serialised data is in normal form: load the data into a #GVariant
using g_variant_create_from_data() and then use this function to
check.

If @value is found to be in normal form then it will be marked as
being trusted.  If the value was already marked as being trusted then
this function will immediately return %TRUE.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @value is in normal form
</return>
</function>

<function name="g_static_rw_lock_writer_trylock">
<description>
Tries to lock @lock for writing. If @lock is already locked (for
either reading or writing) by another thread, it immediately returns
%FALSE. Otherwise it locks @lock for writing and returns %TRUE. This
lock has to be unlocked by g_static_rw_lock_writer_unlock().

</description>
<parameters>
<parameter name="lock">
<parameter_description> a #GStaticRWLock to lock for writing.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE, if @lock could be locked for writing.
</return>
</function>

<function name="g_list_previous">
<description>
A convenience macro to get the previous element in a #GList.

</description>
<parameters>
<parameter name="list">
<parameter_description> an element in a #GList.
</parameter_description>
</parameter>
</parameters>
<return> the previous element, or %NULL if there are no previous
elements.
</return>
</function>

<function name="g_key_file_set_list_separator">
<description>
Sets the character which is used to separate
values in lists. Typically ';' or ',' are used
as separators. The default list separator is ';'.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile 
</parameter_description>
</parameter>
<parameter name="separator">
<parameter_description> the separator
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_rand_double_range">
<description>
Returns the next random #gdouble from @rand_ equally distributed over
the range [@begin..@end).


</description>
<parameters>
<parameter name="rand_">
<parameter_description> a #GRand.
</parameter_description>
</parameter>
<parameter name="begin">
<parameter_description> lower closed bound of the interval.
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> upper open bound of the interval.
</parameter_description>
</parameter>
</parameters>
<return> A random number.
</return>
</function>

<function name="g_variant_builder_init">
<description>
Initialises a #GVariantBuilder structure.

@type must be non-%NULL.  It specifies the type of container to
construct.  It can be an indefinite type such as
%G_VARIANT_TYPE_ARRAY or a definite type such as &quot;as&quot; or &quot;(ii)&quot;.
Maybe, array, tuple, dictionary entry and variant-typed values may be
constructed.

After the builder is initialised, values are added using
g_variant_builder_add_value() or g_variant_builder_add().

After all the child values are added, g_variant_builder_end() frees
the memory associated with the builder and returns the #GVariant that
was created.

This function completely ignores the previous contents of @builder.
On one hand this means that it is valid to pass in completely
uninitialised memory.  On the other hand, this means that if you are
initialising over top of an existing #GVariantBuilder you need to
first call g_variant_builder_clear() in order to avoid leaking
memory.

You must not call g_variant_builder_ref() or
g_variant_builder_unref() on a #GVariantBuilder that was initialised
with this function.  If you ever pass a reference to a
#GVariantBuilder outside of the control of your own code then you
should assume that the person receiving that reference may try to use
reference counting; you should use g_variant_builder_new() instead of
this function.

Since: 2.24

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder
</parameter_description>
</parameter>
<parameter name="type">
<parameter_description> a container type
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_option_context_add_main_entries">
<description>
A convenience function which creates a main group if it doesn't 
exist, adds the @entries to it and sets the translation domain.

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="entries">
<parameter_description> a %NULL-terminated array of #GOptionEntry&lt;!-- --&gt;s
</parameter_description>
</parameter>
<parameter name="translation_domain">
<parameter_description> a translation domain to use for translating
the &lt;option&gt;--help&lt;/option&gt; output for the options in @entries
with gettext(), or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_flags_complete_type_info">
<description>
This function is meant to be called from the complete_type_info()
function of a #GTypePlugin implementation, see the example for
g_enum_complete_type_info() above.

</description>
<parameters>
<parameter name="g_flags_type">
<parameter_description> the type identifier of the type being completed
</parameter_description>
</parameter>
<parameter name="info">
<parameter_description> the #GTypeInfo struct to be filled in
</parameter_description>
</parameter>
<parameter name="const_values">
<parameter_description> An array of #GFlagsValue structs for the possible
enumeration values. The array is terminated by a struct with all
members being 0.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_pool_push">
<description>
Inserts @data into the list of tasks to be executed by @pool. When
the number of currently running threads is lower than the maximal
allowed number of threads, a new thread is started (or reused) with
the properties given to g_thread_pool_new (). Otherwise @data stays
in the queue until a thread in this pool finishes its previous task
and processes @data. 

@error can be %NULL to ignore errors, or non-%NULL to report
errors. An error can only occur when a new thread couldn't be
created. In that case @data is simply appended to the queue of work
to do.  

</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GThreadPool
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> a new task for @pool
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for error
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_read_line">
<description>
Reads a line, including the terminating character(s),
from a #GIOChannel into a newly-allocated string.
@str_return will contain allocated memory if the return
is %G_IO_STATUS_NORMAL.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="str_return">
<parameter_description> The line read from the #GIOChannel, including the
line terminator. This data should be freed with g_free()
when no longer needed. This is a nul-terminated string. 
If a @length of zero is returned, this will be %NULL instead.
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> location to store length of the read data, or %NULL
</parameter_description>
</parameter>
<parameter name="terminator_pos">
<parameter_description> location to store position of line terminator, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> A location to return an error of type #GConvertError
or #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> the status of the operation.
</return>
</function>

<function name="g_param_spec_uchar">
<description>
Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_get_home_dir">
<description>
Gets the current user's home directory as defined in the 
password database.

Note that in contrast to traditional UNIX tools, this function 
prefers &lt;filename&gt;passwd&lt;/filename&gt; entries over the &lt;envar&gt;HOME&lt;/envar&gt; 
environment variable. 

One of the reasons for this decision is that applications in many 
cases need special handling to deal with the case where 
&lt;envar&gt;HOME&lt;/envar&gt; is
&lt;simplelist&gt;
&lt;member&gt;Not owned by the user&lt;/member&gt;
&lt;member&gt;Not writeable&lt;/member&gt;
&lt;member&gt;Not even readable&lt;/member&gt;
&lt;/simplelist&gt;
Since applications are in general &lt;emphasis&gt;not&lt;/emphasis&gt; written 
to deal with these situations it was considered better to make 
g_get_home_dir() not pay attention to &lt;envar&gt;HOME&lt;/envar&gt; and to 
return the real home directory for the user. If applications
want to pay attention to &lt;envar&gt;HOME&lt;/envar&gt;, they can do:
|[
const char *homedir = g_getenv (&quot;HOME&quot;);
if (!homedir)
homedir = g_get_home_dir (&lt;!-- --&gt;);
]|


</description>
<parameters>
</parameters>
<return> the current user's home directory
</return>
</function>

<function name="g_sequence_move_range">
<description>
Inserts the (@begin, @end) range at the destination pointed to by ptr.
The @begin and @end iters must point into the same sequence. It is
allowed for @dest to point to a different sequence than the one pointed
into by @begin and @end.

If @dest is NULL, the range indicated by @begin and @end is
removed from the sequence. If @dest iter points to a place within
the (@begin, @end) range, the range does not move.

Since: 2.14

</description>
<parameters>
<parameter name="dest">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="begin">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_load_from_data">
<description>
Loads a key file from memory into an empty #GKeyFile structure.  
If the object cannot be created then %error is set to a #GKeyFileError. 

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> an empty #GKeyFile struct
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> key file loaded in memory
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of @data in bytes
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags from #GKeyFileFlags
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a key file could be loaded, %FALSE otherwise

</return>
</function>

<function name="g_completion_set_compare">
<description>
Sets the function to use for string comparisons. The default string
comparison function is strncmp().

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="cmp">
<parameter_description> a #GCompletion.
</parameter_description>
</parameter>
<parameter name="strncmp_func">
<parameter_description> the string comparison function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_async_queue_new_full">
<description>
Creates a new asynchronous queue with an initial reference count of 1 and
sets up a destroy notify function that is used to free any remaining
queue items when the queue is destroyed after the final unref.

Since: 2.16

</description>
<parameters>
<parameter name="item_free_func">
<parameter_description> function to free queue elements
</parameter_description>
</parameter>
</parameters>
<return> the new #GAsyncQueue.

</return>
</function>

<function name="g_value_reset">
<description>
Clears the current value in @value and resets it to the default value
(as if the value had just been initialized).


</description>
<parameters>
<parameter name="value">
<parameter_description> An initialized #GValue structure.
</parameter_description>
</parameter>
</parameters>
<return> the #GValue structure that has been passed in
</return>
</function>

<function name="g_type_module_register_enum">
<description>
Looks up or registers an enumeration that is implemented with a particular
type plugin. If a type with name @type_name was previously registered,
the #GType identifier for the type is returned, otherwise the type
is newly registered, and the resulting #GType identifier returned.

As long as any instances of the type exist, the type plugin will
not be unloaded.

Since: 2.6


</description>
<parameters>
<parameter name="module">
<parameter_description> a #GTypeModule
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> name for the type
</parameter_description>
</parameter>
<parameter name="const_static_values">
<parameter_description> an array of #GEnumValue structs for the
possible enumeration values. The array is
terminated by a struct with all members being
0.
</parameter_description>
</parameter>
</parameters>
<return> the new or existing type ID
</return>
</function>

<function name="g_variant_byteswap">
<description>
Performs a byteswapping operation on the contents of @value.  The
result is that all multi-byte numeric data contained in @value is
byteswapped.  That includes 16, 32, and 64bit signed and unsigned
integers as well as file handles and double precision floating point
values.

This function is an identity mapping on any value that does not
contain multi-byte numeric data.  That include strings, booleans,
bytes and containers containing only these things (recursively).

The returned value is always in normal form and is marked as trusted.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return> the byteswapped form of @value
</return>
</function>

<function name="g_signal_stop_emission_by_name">
<description>
Stops a signal's current emission.

This is just like g_signal_stop_emission() except it will look up the
signal id for you.

</description>
<parameters>
<parameter name="instance">
<parameter_description> the object whose signal handlers you wish to stop.
</parameter_description>
</parameter>
<parameter name="detailed_signal">
<parameter_description> a string of the form &quot;signal-name::detail&quot;.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_date_set_time_val">
<description>
Sets the value of a date from a #GTimeVal value.  Note that the
@tv_usec member is ignored, because #GDate can't make use of the
additional precision.

The time to date conversion is done using the user's current timezone.

Since: 2.10

</description>
<parameters>
<parameter name="date">
<parameter_description> a #GDate 
</parameter_description>
</parameter>
<parameter name="timeval">
<parameter_description> #GTimeVal value to set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_iter_next">
<description>
Gets the next item in the container and unpacks it into the variable
argument list according to @format_string, returning %TRUE.

If no more items remain then %FALSE is returned.

All of the pointers given on the variable arguments list of this
function are assumed to point at uninitialised memory.  It is the
responsibility of the caller to free all of the values returned by
the unpacking process.

See the section on &lt;link linkend='gvariant-format-strings'&gt;GVariant
Format Strings&lt;/link&gt;.

&lt;example&gt;
&lt;title&gt;Memory management with g_variant_iter_next()&lt;/title&gt;
&lt;programlisting&gt;
/&lt;!-- --&gt;* Iterates a dictionary of type 'a{sv}' *&lt;!-- --&gt;/
void
iterate_dictionary (GVariant *dictionary)
{
GVariantIter iter;
GVariant *value;
gchar *key;

g_variant_iter_init (&amp;iter, dictionary);
while (g_variant_iter_next (&amp;iter, &quot;{sv}&quot;, &amp;key, &amp;value))
{
g_print (&quot;Item '%s' has type '%s'\n&quot;, key,
g_variant_get_type_string (value));

/&lt;!-- --&gt;* must free data for ourselves *&lt;!-- --&gt;/
g_variant_unref (value);
g_free (key);
}
}
&lt;/programlisting&gt;
&lt;/example&gt;

For a solution that is likely to be more convenient to C programmers
when dealing with loops, see g_variant_iter_loop().

Since: 2.24

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GVariantIter
</parameter_description>
</parameter>
<parameter name="format_string">
<parameter_description> a GVariant format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the arguments to unpack the value into
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a value was unpacked, or %FALSE if there as no
value
</return>
</function>

<function name="g_variant_type_is_subtype_of">
<description>
Checks if @type is a subtype of @supertype.

This function returns %TRUE if @type is a subtype of @supertype.  All
types are considered to be subtypes of themselves.  Aside from that,
only indefinite types can have subtypes.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
<parameter name="supertype">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is a subtype of @supertype
</return>
</function>

<function name="g_relation_destroy">
<description>
Destroys the #GRelation, freeing all memory allocated. However, it
does not free memory allocated for the tuple data, so you should
free that first if appropriate.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="relation">
<parameter_description> a #GRelation.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_regex_check_replacement">
<description>
Checks whether @replacement is a valid replacement string
(see g_regex_replace()), i.e. that all escape sequences in
it are valid.

If @has_references is not %NULL then @replacement is checked
for pattern references. For instance, replacement text 'foo\n'
does not contain references and may be evaluated without information
about actual match, but '\0\1' (whole match followed by first
subpattern) requires valid #GMatchInfo object.

Since: 2.14

</description>
<parameters>
<parameter name="replacement">
<parameter_description> the replacement string
</parameter_description>
</parameter>
<parameter name="has_references">
<parameter_description> location to store information about
references in @replacement or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store error
</parameter_description>
</parameter>
</parameters>
<return> whether @replacement is a valid replacement string

</return>
</function>

<function name="g_base64_decode">
<description>
Decode a sequence of Base-64 encoded text into binary data

Since: 2.12

</description>
<parameters>
<parameter name="text">
<parameter_description> zero-terminated string with base64 text to decode
</parameter_description>
</parameter>
<parameter name="out_len">
<parameter_description> The length of the decoded data is written here
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated buffer containing the binary data
that @text represents. The returned buffer must
be freed with g_free().

</return>
</function>

<function name="g_file_test">
<description>
Returns %TRUE if any of the tests in the bitfield @test are
%TRUE. For example, &lt;literal&gt;(G_FILE_TEST_EXISTS | 
G_FILE_TEST_IS_DIR)&lt;/literal&gt; will return %TRUE if the file exists; 
the check whether it's a directory doesn't matter since the existence 
test is %TRUE. With the current set of available tests, there's no point
passing in more than one test at a time.

Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,
so for a symbolic link to a regular file g_file_test() will return
%TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.

Note, that for a dangling symbolic link g_file_test() will return
%TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags.

You should never use g_file_test() to test whether it is safe
to perform an operation, because there is always the possibility
of the condition changing before you actually perform the operation.
For example, you might think you could use %G_FILE_TEST_IS_SYMLINK
to know whether it is safe to write to a file without being
tricked into writing into a different location. It doesn't work!
|[
/ * DON'T DO THIS * /
if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK)) 
{
fd = g_open (filename, O_WRONLY);
/ * write to fd * /
}
]|

Another thing to note is that %G_FILE_TEST_EXISTS and
%G_FILE_TEST_IS_EXECUTABLE are implemented using the access()
system call. This usually doesn't matter, but if your program
is setuid or setgid it means that these tests will give you
the answer for the real user ID and group ID, rather than the
effective user ID and group ID.

On Windows, there are no symlinks, so testing for
%G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for
%G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and
its name indicates that it is executable, checking for well-known
extensions and those listed in the %PATHEXT environment variable.


</description>
<parameters>
<parameter name="filename">
<parameter_description> a filename to test in the GLib file name encoding
</parameter_description>
</parameter>
<parameter name="test">
<parameter_description> bitfield of #GFileTest flags
</parameter_description>
</parameter>
</parameters>
<return> whether a test was %TRUE
</return>
</function>

<function name="g_thread_pool_set_max_threads">
<description>
Sets the maximal allowed number of threads for @pool. A value of -1
means, that the maximal number of threads is unlimited.

Setting @max_threads to 0 means stopping all work for @pool. It is
effectively frozen until @max_threads is set to a non-zero value
again.

A thread is never terminated while calling @func, as supplied by
g_thread_pool_new (). Instead the maximal number of threads only
has effect for the allocation of new threads in g_thread_pool_push(). 
A new thread is allocated, whenever the number of currently
running threads in @pool is smaller than the maximal number.

@error can be %NULL to ignore errors, or non-%NULL to report
errors. An error can only occur when a new thread couldn't be
created. 

</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GThreadPool
</parameter_description>
</parameter>
<parameter name="max_threads">
<parameter_description> a new maximal number of threads for @pool
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for error
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_utf8_find_next_char">
<description>
Finds the start of the next UTF-8 character in the string after @p.

@p does not have to be at the beginning of a UTF-8 character. No check
is made to see if the character found is actually valid other than
it starts with an appropriate byte.


</description>
<parameters>
<parameter name="p">
<parameter_description> a pointer to a position within a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> a pointer to the byte following the end of the string,
or %NULL to indicate that the string is nul-terminated.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the found character or %NULL
</return>
</function>

<function name="g_unichar_isspace">
<description>
Determines whether a character is a space, tab, or line separator
(newline, carriage return, etc.).  Given some UTF-8 text, obtain a
character value with g_utf8_get_char().

(Note: don't use this to do word breaking; you have to use
Pango or equivalent to get word breaking right, the algorithm
is fairly complex.)


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is a space character
</return>
</function>

<function name="g_utf8_to_ucs4">
<description>
Convert a string from UTF-8 to a 32-bit fixed width
representation as UCS-4. A trailing 0 will be added to the
string after the converted text.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length of @str to use, in bytes. If @len &lt; 0,
then the string is nul-terminated.
</parameter_description>
</parameter>
<parameter name="items_read">
<parameter_description> location to store number of bytes read, or %NULL.
If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be
returned in case @str contains a trailing partial
character. If an error occurs then the index of the
invalid input is stored here.
</parameter_description>
</parameter>
<parameter name="items_written">
<parameter_description> location to store number of characters written or %NULL.
The value here stored does not include the trailing 0
character. 
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError other than
%G_CONVERT_ERROR_NO_CONVERSION may occur.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to a newly allocated UCS-4 string.
This value must be freed with g_free(). If an
error occurs, %NULL will be returned and
@error set.
</return>
</function>

<function name="g_node_first_sibling">
<description>
Gets the first sibling of a #GNode.
This could possibly be the node itself.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
</parameters>
<return> the first sibling of @node
</return>
</function>

<function name="g_tree_search">
<description>
Searches a #GTree using @search_func.

The @search_func is called with a pointer to the key of a key/value pair in 
the tree, and the passed in @user_data. If @search_func returns 0 for a 
key/value pair, then g_tree_search_func() will return the value of that 
pair. If @search_func returns -1,  searching will proceed among the 
key/value pairs that have a smaller key; if @search_func returns 1, 
searching will proceed among the key/value pairs that have a larger key.


</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
<parameter name="search_func">
<parameter_description> a function used to search the #GTree. 
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> the data passed as the second argument to the @search_func 
function.
</parameter_description>
</parameter>
</parameters>
<return> the value corresponding to the found key, or %NULL if the key 
was not found.
</return>
</function>

<function name="g_string_insert_len">
<description>
Inserts @len bytes of @val into @string at @pos.
Because @len is provided, @val may contain embedded
nuls and need not be nul-terminated. If @pos is -1,
bytes are inserted at the end of the string.

Since this function does not stop at nul bytes, it is
the caller's responsibility to ensure that @val has at
least @len addressable bytes.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="pos">
<parameter_description> position in @string where insertion should
happen, or -1 for at the end
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> bytes to insert
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> number of bytes of @val to insert
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_cache_new">
<description>
Creates a new #GCache.

</description>
<parameters>
<parameter name="value_new_func">
<parameter_description> a function to create a new object given a key.
This is called by g_cache_insert() if an object
with the given key does not already exist.
</parameter_description>
</parameter>
<parameter name="value_destroy_func">
<parameter_description> a function to destroy an object. It is called
by g_cache_remove() when the object is no
longer needed (i.e. its reference count drops
to 0).
</parameter_description>
</parameter>
<parameter name="key_dup_func">
<parameter_description> a function to copy a key. It is called by
g_cache_insert() if the key does not already exist in
the #GCache.
</parameter_description>
</parameter>
<parameter name="key_destroy_func">
<parameter_description> a function to destroy a key. It is called by
g_cache_remove() when the object is no longer
needed (i.e. its reference count drops to 0).
</parameter_description>
</parameter>
<parameter name="hash_key_func">
<parameter_description> a function to create a hash value from a key.
</parameter_description>
</parameter>
<parameter name="hash_value_func">
<parameter_description> a function to create a hash value from a value.
</parameter_description>
</parameter>
<parameter name="key_equal_func">
<parameter_description> a function to compare two keys. It should return
%TRUE if the two keys are equivalent.
</parameter_description>
</parameter>
</parameters>
<return> a new #GCache.
</return>
</function>

<function name="g_value_get_string">
<description>
Get the contents of a %G_TYPE_STRING #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_STRING
</parameter_description>
</parameter>
</parameters>
<return> string content of @value
</return>
</function>

<function name="g_key_file_set_locale_string_list">
<description>
Associates a list of string values for @key and @locale under
@group_name.  If the translation for @key cannot be found then
it is created. 

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="locale">
<parameter_description> a locale identifier
</parameter_description>
</parameter>
<parameter name="list">
<parameter_description> a %NULL-terminated array of locale string values
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of @list
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_rmdir">
<description>
A wrapper for the POSIX rmdir() function. The rmdir() function
deletes a directory from the filesystem.

See your C library manual for more details about how rmdir() works
on your system.

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
</parameters>
<return> 0 if the directory was successfully removed, -1 if an error 
occurred

</return>
</function>

<function name="glib_check_version">
<description>
Checks that the GLib library in use is compatible with the
given version. Generally you would pass in the constants
#GLIB_MAJOR_VERSION, #GLIB_MINOR_VERSION, #GLIB_MICRO_VERSION
as the three arguments to this function; that produces
a check that the library in use is compatible with
the version of GLib the application or module was compiled
against.

Compatibility is defined by two things: first the version
of the running library is newer than the version
@required_major.required_minor.@required_micro. Second
the running library must be binary compatible with the
version @required_major.required_minor.@required_micro
(same major version.)

Since: 2.6

</description>
<parameters>
<parameter name="required_major">
<parameter_description> the required major version.
</parameter_description>
</parameter>
<parameter name="required_minor">
<parameter_description> the required minor version.
</parameter_description>
</parameter>
<parameter name="required_micro">
<parameter_description> the required micro version.
</parameter_description>
</parameter>
</parameters>
<return> %NULL if the GLib library is compatible with the
given version, or a string describing the version mismatch.
The returned string is owned by GLib and must not be modified
or freed.

</return>
</function>

<function name="g_date_get_iso8601_week_of_year">
<description>
Returns the week of the year, where weeks are interpreted according
to ISO 8601. 

Since: 2.6

</description>
<parameters>
<parameter name="date">
<parameter_description> a valid #GDate
</parameter_description>
</parameter>
</parameters>
<return> ISO 8601 week number of the year.

</return>
</function>

<function name="g_atomic_int_get">
<description>
Reads the value of the integer pointed to by @atomic.
Also acts as a memory barrier.

Since: 2.4

</description>
<parameters>
<parameter name="atomic">
<parameter_description> a pointer to an integer
</parameter_description>
</parameter>
</parameters>
<return> the value of *@atomic

</return>
</function>

<function name="g_main_context_pending">
<description>
Checks if any sources have pending events for the given context.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext (if %NULL, the default context will be used)
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if events are pending.
</return>
</function>

<function name="g_spawn_close_pid">
<description>
On some platforms, notably Windows, the #GPid type represents a resource
which must be closed to prevent resource leaking. g_spawn_close_pid()
is provided for this purpose. It should be used on all platforms, even
though it doesn't do anything under UNIX.

</description>
<parameters>
<parameter name="pid">
<parameter_description> The process reference to close
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_string_free">
<description>
Frees the memory allocated for the #GString.
If @free_segment is %TRUE it also frees the character data.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="free_segment">
<parameter_description> if %TRUE the actual character data is freed as well
</parameter_description>
</parameter>
</parameters>
<return> the character data of @string 
(i.e. %NULL if @free_segment is %TRUE)
</return>
</function>

<function name="g_array_new">
<description>
Creates a new #GArray with a reference count of 1.

</description>
<parameters>
<parameter name="zero_terminated">
<parameter_description> %TRUE if the array should have an extra element at
the end which is set to 0.
</parameter_description>
</parameter>
<parameter name="clear_">
<parameter_description> %TRUE if #GArray elements should be automatically cleared
to 0 when they are allocated.
</parameter_description>
</parameter>
<parameter name="element_size">
<parameter_description> the size of each element in bytes.
</parameter_description>
</parameter>
</parameters>
<return> the new #GArray.
</return>
</function>

<function name="g_sequence_remove_range">
<description>
Removes all items in the (@begin, @end) range.

If the sequence has a data destroy function associated with it, this
function is called on the data for the removed items.

Since: 2.14

</description>
<parameters>
<parameter name="begin">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_set_ulong">
<description>
Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_ULONG
</parameter_description>
</parameter>
<parameter name="v_ulong">
<parameter_description> unsigned long integer value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_tree_new_with_data">
<description>
Creates a new #GTree with a comparison function that accepts user data.
See g_tree_new() for more details.


</description>
<parameters>
<parameter name="key_compare_func">
<parameter_description> qsort()-style comparison function.
</parameter_description>
</parameter>
<parameter name="key_compare_data">
<parameter_description> data to pass to comparison function.
</parameter_description>
</parameter>
</parameters>
<return> a new #GTree.
</return>
</function>

<function name="g_unichar_iswide_cjk">
<description>
Determines if a character is typically rendered in a double-width
cell under legacy East Asian locales.  If a character is wide according to
g_unichar_iswide(), then it is also reported wide with this function, but
the converse is not necessarily true.  See the
&lt;ulink url=&quot;http://www.unicode.org/reports/tr11/&quot;&gt;Unicode Standard
Annex #11&lt;/ulink&gt; for details.

If a character passes the g_unichar_iswide() test then it will also pass
this test, but not the other way around.  Note that some characters may
pas both this test and g_unichar_iszerowidth().

Since: 2.12

</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the character is wide in legacy East Asian locales

</return>
</function>

<function name="g_markup_parse_context_pop">
<description>
Completes the process of a temporary sub-parser redirection.

This function exists to collect the user_data allocated by a
matching call to g_markup_parse_context_push().  It must be called
in the end_element handler corresponding to the start_element
handler during which g_markup_parse_context_push() was called.  You
must not call this function from the error callback -- the
@user_data is provided directly to the callback in that case.

This function is not intended to be directly called by users
interested in invoking subparsers.  Instead, it is intended to be
used by the subparsers themselves to implement a higher-level
interface.

Since: 2.18

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMarkupParseContext
</parameter_description>
</parameter>
</parameters>
<return> the user_data passed to g_markup_parse_context_push().

</return>
</function>

<function name="g_test_create_suite">
<description>
Create a new test suite with the name @suite_name.

Since: 2.16

</description>
<parameters>
<parameter name="suite_name">
<parameter_description> a name for the suite
</parameter_description>
</parameter>
</parameters>
<return> A newly allocated #GTestSuite instance.

</return>
</function>

<function name="g_type_module_unuse">
<description>
Decreases the use count of a #GTypeModule by one. If the
result is zero, the module will be unloaded. (However, the
#GTypeModule will not be freed, and types associated with the
#GTypeModule are not unregistered. Once a #GTypeModule is
initialized, it must exist forever.)

</description>
<parameters>
<parameter name="module">
<parameter_description> a #GTypeModule
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_builder_open">
<description>
Opens a subcontainer inside the given @builder.  When done adding
items to the subcontainer, g_variant_builder_close() must be called.

It is an error to call this function in any way that would cause an
inconsistent value to be constructed (ie: adding too many values or
a value of an incorrect type).

Since: 2.24

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder
</parameter_description>
</parameter>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_async_queue_sort_unlocked">
<description>
Sorts @queue using @func. 

This function is called while holding the @queue's lock.

Since: 2.10

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the #GCompareDataFunc is used to sort @queue. This
function is passed two elements of the @queue. The function
should return 0 if they are equal, a negative value if the
first element should be higher in the @queue or a positive
value if the first element should be lower in the @queue than
the second element. 
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data passed to @func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_set_static_string">
<description>
Set the contents of a %G_TYPE_STRING #GValue to @v_string.
The string is assumed to be static, and is thus not duplicated
when setting the #GValue.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_STRING
</parameter_description>
</parameter>
<parameter name="v_string">
<parameter_description> static string to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_type_compatible">
<description>
Returns whether a #GValue of type @src_type can be copied into
a #GValue of type @dest_type.


</description>
<parameters>
<parameter name="src_type">
<parameter_description> source type to be copied.
</parameter_description>
</parameter>
<parameter name="dest_type">
<parameter_description> destination type for copying.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if g_value_copy() is possible with @src_type and @dest_type.
</return>
</function>

<function name="g_shell_quote">
<description>
Quotes a string so that the shell (/bin/sh) will interpret the
quoted string to mean @unquoted_string. If you pass a filename to
the shell, for example, you should first quote it with this
function.  The return value must be freed with g_free(). The
quoting style used is undefined (single or double quotes may be
used).


</description>
<parameters>
<parameter name="unquoted_string">
<parameter_description> a literal string
</parameter_description>
</parameter>
</parameters>
<return> quoted string
</return>
</function>

<function name="g_signal_new">
<description>
Creates a new signal. (This is usually done in the class initializer.)

A signal name consists of segments consisting of ASCII letters and
digits, separated by either the '-' or '_' character. The first
character of a signal name must be a letter. Names which violate these
rules lead to undefined behaviour of the GSignal system.

When registering a signal and looking up a signal, either separator can
be used, but they cannot be mixed.

If 0 is used for @class_offset subclasses cannot override the class handler
in their &lt;code&gt;class_init&lt;/code&gt; method by doing
&lt;code&gt;super_class-&gt;signal_handler = my_signal_handler&lt;/code&gt;. Instead they
will have to use g_signal_override_class_handler().


</description>
<parameters>
<parameter name="signal_name">
<parameter_description> the name for the signal
</parameter_description>
</parameter>
<parameter name="itype">
<parameter_description> the type this signal pertains to. It will also pertain to
types which are derived from this type.
</parameter_description>
</parameter>
<parameter name="signal_flags">
<parameter_description> a combination of #GSignalFlags specifying detail of when
the default handler is to be invoked. You should at least specify
%G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST.
</parameter_description>
</parameter>
<parameter name="class_offset">
<parameter_description> The offset of the function pointer in the class structure
for this type. Used to invoke a class method generically. Pass 0 to
not associate a class method slot with this signal.
</parameter_description>
</parameter>
<parameter name="accumulator">
<parameter_description> the accumulator for this signal; may be %NULL.
</parameter_description>
</parameter>
<parameter name="accu_data">
<parameter_description> user data for the @accumulator.
</parameter_description>
</parameter>
<parameter name="c_marshaller">
<parameter_description> the function to translate arrays of parameter values to
signal emissions into C language callback invocations.
</parameter_description>
</parameter>
<parameter name="return_type">
<parameter_description> the type of return value, or #G_TYPE_NONE for a signal
without a return value.
</parameter_description>
</parameter>
<parameter name="n_params">
<parameter_description> the number of parameter types to follow.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> a list of types, one for each parameter.
</parameter_description>
</parameter>
</parameters>
<return> the signal id
</return>
</function>

<function name="g_strcmp0">
<description>
Compares @str1 and @str2 like strcmp(). Handles %NULL 
gracefully by sorting it before non-%NULL strings.
Comparing two %NULL pointers returns 0.

Since: 2.16

</description>
<parameters>
<parameter name="str1">
<parameter_description> a C string or %NULL
</parameter_description>
</parameter>
<parameter name="str2">
<parameter_description> another C string or %NULL
</parameter_description>
</parameter>
</parameters>
<return> -1, 0 or 1, if @str1 is &lt;, == or &gt; than @str2.

</return>
</function>

<function name="g_value_set_string">
<description>
Set the contents of a %G_TYPE_STRING #GValue to @v_string.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_STRING
</parameter_description>
</parameter>
<parameter name="v_string">
<parameter_description> caller-owned string to be duplicated for the #GValue
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_locale_from_utf8">
<description>
Converts a string from UTF-8 to the encoding used for strings by
the C runtime (usually the same as that used by the operating
system) in the &lt;link linkend=&quot;setlocale&quot;&gt;current locale&lt;/link&gt;. On
Windows this means the system codepage.


</description>
<parameters>
<parameter name="utf8string">
<parameter_description>    a UTF-8 encoded string 
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description>           the length of the string, or -1 if the string is
nul-terminated&lt;footnoteref linkend=&quot;nul-unsafe&quot;/&gt;. 
</parameter_description>
</parameter>
<parameter name="bytes_read">
<parameter_description>    location to store the number of bytes in the
input string that were successfully converted, or %NULL.
Even if the conversion was successful, this may be 
less than @len if there were partial characters
at the end of the input. If the error
#G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
stored will the byte offset after the last valid
input sequence.
</parameter_description>
</parameter>
<parameter name="bytes_written">
<parameter_description> the number of bytes stored in the output buffer (not 
including the terminating nul).
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description>         location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError may occur.
</parameter_description>
</parameter>
</parameters>
<return> The converted string, or %NULL on an error.
</return>
</function>

<function name="g_byte_array_remove_range">
<description>
Removes the given number of bytes starting at the given index from a
#GByteArray.  The following elements are moved to close the gap.

Since: 2.4

</description>
<parameters>
<parameter name="array">
<parameter_description> a @GByteArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the first byte to remove.
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the number of bytes to remove.
</parameter_description>
</parameter>
</parameters>
<return> the #GByteArray.
</return>
</function>

<function name="g_key_file_get_value">
<description>
Returns the raw value associated with @key under @group_name. 
Use g_key_file_get_string() to retrieve an unescaped UTF-8 string. 

In the event the key cannot be found, %NULL is returned and 
@error is set to #G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the 
event that the @group_name cannot be found, %NULL is returned 
and @error is set to #G_KEY_FILE_ERROR_GROUP_NOT_FOUND.


Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string or %NULL if the specified 
key cannot be found.

</return>
</function>

<function name="g_closure_remove_finalize_notifier">
<description>
Removes a finalization notifier.

Notice that notifiers are automatically removed after they are run.

</description>
<parameters>
<parameter name="closure">
<parameter_description> a #GClosure
</parameter_description>
</parameter>
<parameter name="notify_data">
<parameter_description> data which was passed to g_closure_add_finalize_notifier()
when registering @notify_func
</parameter_description>
</parameter>
<parameter name="notify_func">
<parameter_description> the callback function to remove
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_pattern_spec_new">
<description>
Compiles a pattern to a #GPatternSpec.

</description>
<parameters>
<parameter name="pattern">
<parameter_description> a zero-terminated UTF-8 encoded string
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated #GPatternSpec
</return>
</function>

<function name="g_variant_new_signature">
<description>
Creates a DBus type signature #GVariant with the contents of
@string.  @string must be a valid DBus type signature.  Use
g_variant_is_signature() if you're not sure.

Since: 2.24

</description>
<parameters>
<parameter name="signature">
<parameter_description> a normal C nul-terminated string
</parameter_description>
</parameter>
</parameters>
<return> a new signature #GVariant instance
</return>
</function>

<function name="g_queue_reverse">
<description>
Reverses the order of the items in @queue.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_last">
<description>
Gets the last element in a #GList.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
</parameters>
<return> the last element in the #GList, 
or %NULL if the #GList has no elements
</return>
</function>

<function name="g_regex_escape_string">
<description>
Escapes the special characters used for regular expressions
in @string, for instance &quot;a.b*c&quot; becomes &quot;a\.b\*c&quot;. This
function is useful to dynamically generate regular expressions.

@string can contain nul characters that are replaced with &quot;\0&quot;,
in this case remember to specify the correct length of @string
in @length.

Since: 2.14

</description>
<parameters>
<parameter name="string">
<parameter_description> the string to escape
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of @string, or -1 if @string is nul-terminated
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated escaped string

</return>
</function>

<function name="g_value_get_flags">
<description>
Get the contents of a %G_TYPE_FLAGS #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue whose type is derived from %G_TYPE_FLAGS
</parameter_description>
</parameter>
</parameters>
<return> flags contents of @value
</return>
</function>

<function name="g_source_set_funcs">
<description>
Sets the source functions (can be used to override 
default implementations) of an unattached source.

Since: 2.12

</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
<parameter name="funcs">
<parameter_description> the new #GSourceFuncs
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_direct_hash">
<description>
Converts a gpointer to a hash value.
It can be passed to g_hash_table_new() as the @hash_func parameter, 
when using pointers as keys in a #GHashTable.


</description>
<parameters>
<parameter name="v">
<parameter_description> a #gpointer key
</parameter_description>
</parameter>
</parameters>
<return> a hash value corresponding to the key.
</return>
</function>

<function name="g_bookmark_file_get_visited">
<description>
Gets the time the bookmark for @uri was last visited.

In the event the URI cannot be found, -1 is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a timestamp.

</return>
</function>

<function name="g_test_queue_free">
<description>
Enqueue a pointer to be released with g_free() during the next
teardown phase. This is equivalent to calling g_test_queue_destroy()
with a destroy callback of g_free().

Since: 2.16

</description>
<parameters>
<parameter name="gfree_pointer">
<parameter_description> the pointer to be stored.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_array_remove_index">
<description>
Removes the element at the given index from a #GArray. The following
elements are moved down one place.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the element to remove.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_io_channel_ref">
<description>
Increments the reference count of a #GIOChannel.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
</parameters>
<return> the @channel that was passed in (since 2.6)
</return>
</function>

<function name="g_unichar_isdigit">
<description>
Determines whether a character is numeric (i.e. a digit).  This
covers ASCII 0-9 and also digits in other languages/scripts.  Given
some UTF-8 text, obtain a character value with g_utf8_get_char().


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is a digit
</return>
</function>

<function name="g_value_get_ulong">
<description>
Get the contents of a %G_TYPE_ULONG #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_ULONG
</parameter_description>
</parameter>
</parameters>
<return> unsigned long integer contents of @value
</return>
</function>

<function name="g_value_array_sort_with_data">
<description>
Sort @value_array using @compare_func to compare the elements accoring
to the semantics of #GCompareDataFunc.

The current implementation uses Quick-Sort as sorting algorithm.


</description>
<parameters>
<parameter name="value_array">
<parameter_description> #GValueArray to sort
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> function to compare elements
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> extra data argument provided for @compare_func
</parameter_description>
</parameter>
</parameters>
<return> the #GValueArray passed in as @value_array
</return>
</function>

<function name="g_cclosure_marshal_VOID__UCHAR">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, guchar arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #guchar parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_get_child_value">
<description>
Reads a child item out of a container #GVariant instance.  This
includes variants, maybes, arrays, tuples and dictionary
entries.  It is an error to call this function on any other type of
#GVariant.

It is an error if @index_ is greater than the number of child items
in the container.  See g_variant_n_children().

This function is O(1).

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a container #GVariant
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the child to fetch
</parameter_description>
</parameter>
</parameters>
<return> the child at the specified index
</return>
</function>

<function name="g_sequence_new">
<description>
Creates a new GSequence. The @data_destroy function, if non-%NULL will
be called on all items when the sequence is destroyed and on items that
are removed from the sequence.

Since: 2.14

</description>
<parameters>
<parameter name="data_destroy">
<parameter_description> a #GDestroyNotify function, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a new #GSequence

</return>
</function>

<function name="g_io_channel_close">
<description>
Close an IO channel. Any pending data to be written will be
flushed, ignoring errors. The channel will not be freed until the
last reference is dropped using g_io_channel_unref(). 

Deprecated:2.2: Use g_io_channel_shutdown() instead.

</description>
<parameters>
<parameter name="channel">
<parameter_description> A #GIOChannel
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_set_double">
<description>
Associates a new double value with @key under @group_name.
If @key cannot be found then it is created. 

Since: 2.12

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> an double value
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_values_cmp">
<description>
Compares @value1 with @value2 according to @pspec, and return -1, 0 or +1,
if @value1 is found to be less than, equal to or greater than @value2,
respectively.


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
<parameter name="value1">
<parameter_description> a #GValue of correct type for @pspec
</parameter_description>
</parameter>
<parameter name="value2">
<parameter_description> a #GValue of correct type for @pspec
</parameter_description>
</parameter>
</parameters>
<return> -1, 0 or +1, for a less than, equal to or greater than result
</return>
</function>

<function name="g_variant_new_va">
<description>
This function is intended to be used by libraries based on
#GVariant that want to provide g_variant_new()-like functionality
to their users.

The API is more general than g_variant_new() to allow a wider range
of possible uses.

@format_string must still point to a valid format string, but it only
needs to be nul-terminated if @endptr is %NULL.  If @endptr is
non-%NULL then it is updated to point to the first character past the
end of the format string.

@app is a pointer to a #va_list.  The arguments, according to
@format_string, are collected from this #va_list and the list is left
pointing to the argument following the last.

These two generalisations allow mixing of multiple calls to
g_variant_new_va() and g_variant_get_va() within a single actual
varargs call by the user.

The return value will be floating if it was a newly created GVariant
instance (for example, if the format string was &quot;(ii)&quot;).  In the case
that the format_string was '*', '?', 'r', or a format starting with
'@' then the collected #GVariant pointer will be returned unmodified,
without adding any additional references.

In order to behave correctly in all cases it is necessary for the
calling function to g_variant_ref_sink() the return result before
returning control to the user that originally provided the pointer.
At this point, the caller will have their own full reference to the
result.  This can also be done by adding the result to a container,
or by passing it to another g_variant_new() call.

Since: 2.24

</description>
<parameters>
<parameter name="format_string">
<parameter_description> a string that is prefixed with a format string
</parameter_description>
</parameter>
<parameter name="endptr">
<parameter_description> location to store the end pointer,
or %NULL
</parameter_description>
</parameter>
<parameter name="app">
<parameter_description> a pointer to a #va_list
</parameter_description>
</parameter>
</parameters>
<return> a new, usually floating, #GVariant
</return>
</function>

<function name="g_completion_remove_items">
<description>
Removes items from a #GCompletion.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="cmp">
<parameter_description> the #GCompletion.
</parameter_description>
</parameter>
<parameter name="items">
<parameter_description> the items to remove.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_interface_prerequisites">
<description>
Returns the prerequisites of an interfaces type.

Since: 2.2


</description>
<parameters>
<parameter name="interface_type">
<parameter_description> an interface type
</parameter_description>
</parameter>
<parameter name="n_prerequisites">
<parameter_description> location to return the number of prerequisites, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated zero-terminated array of #GType containing
the prerequisites of @interface_type
</return>
</function>

<function name="g_signal_connect_closure_by_id">
<description>
Connects a closure to a signal for a particular object.


</description>
<parameters>
<parameter name="instance">
<parameter_description> the instance to connect to.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> the id of the signal.
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> the detail.
</parameter_description>
</parameter>
<parameter name="closure">
<parameter_description> the closure to connect.
</parameter_description>
</parameter>
<parameter name="after">
<parameter_description> whether the handler should be called before or after the
default handler of the signal.
</parameter_description>
</parameter>
</parameters>
<return> the handler id
</return>
</function>

<function name="g_error_new_valist">
<description>
Creates a new #GError with the given @domain and @code,
and a message formatted with @format.

Since: 2.22

</description>
<parameters>
<parameter name="domain">
<parameter_description> error domain
</parameter_description>
</parameter>
<parameter name="code">
<parameter_description> error code
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> printf()-style format for error message
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> #va_list of parameters for the message format
</parameter_description>
</parameter>
</parameters>
<return> a new #GError

</return>
</function>

<function name="g_snprintf">
<description>
A safer form of the standard sprintf() function. The output is guaranteed
to not exceed @n characters (including the terminating nul character), so
it is easy to ensure that a buffer overflow cannot occur.

See also g_strdup_printf().

In versions of GLib prior to 1.2.3, this function may return -1 if the
output was truncated, and the truncated string may not be nul-terminated.
In versions prior to 1.3.12, this function returns the length of the output
string.

The return value of g_snprintf() conforms to the snprintf()
function as standardized in ISO C99. Note that this is different from
traditional snprintf(), which returns the length of the output string.

The format string may contain positional parameters, as specified in
the Single Unix Specification.


</description>
<parameters>
<parameter name="string">
<parameter_description> the buffer to hold the output.
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the maximum number of bytes to produce (including the
terminating nul character).
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the arguments to insert in the output.
</parameter_description>
</parameter>
</parameters>
<return> the number of bytes which would be produced if the buffer 
was large enough.
</return>
</function>

<function name="g_variant_new_uint16">
<description>
Creates a new uint16 #GVariant instance.

Since: 2.24

</description>
<parameters>
<parameter name="uint16">
<parameter_description> a #guint16 value
</parameter_description>
</parameter>
</parameters>
<return> a new uint16 #GVariant instance
</return>
</function>

<function name="g_value_set_pointer">
<description>
Set the contents of a pointer #GValue to @v_pointer.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_POINTER
</parameter_description>
</parameter>
<parameter name="v_pointer">
<parameter_description> pointer value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_set_char">
<description>
Set the contents of a %G_TYPE_CHAR #GValue to @v_char.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_CHAR
</parameter_description>
</parameter>
<parameter name="v_char">
<parameter_description> character value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cache_key_foreach">
<description>
Calls the given function for each of the keys in the #GCache.

NOTE @func is passed three parameters, the value and key of a cache
entry and the @user_data. The order of value and key is different
from the order in which g_hash_table_foreach() passes key-value
pairs to its callback function !

</description>
<parameters>
<parameter name="cache">
<parameter_description> a #GCache.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call with each #GCache key.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_dpgettext2">
<description>
This function is a variant of g_dgettext() which supports
a disambiguating message context. GNU gettext uses the
'\004' character to separate the message context and
message id in @msgctxtid.

This uses g_dgettext() internally.  See that functions for differences
with dgettext() proper.

This function differs from C_() in that it is not a macro and 
thus you may use non-string-literals as context and msgid arguments.

Since: 2.18

</description>
<parameters>
<parameter name="domain">
<parameter_description> the translation domain to use, or %NULL to use
the domain set with textdomain()
</parameter_description>
</parameter>
<parameter name="context">
<parameter_description> the message context
</parameter_description>
</parameter>
<parameter name="msgid">
<parameter_description> the message
</parameter_description>
</parameter>
</parameters>
<return> The translated string

</return>
</function>

<function name="g_get_system_config_dirs">
<description>
Returns an ordered list of base directories in which to access 
system-wide configuration information.

On UNIX platforms this is determined using the mechanisms described in
the &lt;ulink url=&quot;http://www.freedesktop.org/Standards/basedir-spec&quot;&gt;
XDG Base Directory Specification&lt;/ulink&gt;.
In this case the list of directories retrieved will be XDG_CONFIG_DIRS.

On Windows is the directory that contains application data for all users.
A typical path is C:\Documents and Settings\All Users\Application Data.
This folder is used for application data that is not user specific.
For example, an application can store a spell-check dictionary, a database
of clip art, or a log file in the CSIDL_COMMON_APPDATA folder.
This information will not roam and is available to anyone using the computer.

Since: 2.6

</description>
<parameters>
</parameters>
<return> a %NULL-terminated array of strings owned by GLib that must 
not be modified or freed.
</return>
</function>

<function name="g_async_queue_ref">
<description>
Increases the reference count of the asynchronous @queue by 1. You
do not need to hold the lock to call this function.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return> the @queue that was passed in (since 2.6)
</return>
</function>

<function name="g_io_channel_read_chars">
<description>
Replacement for g_io_channel_read() with the new API.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="buf">
<parameter_description> a buffer to read data into
</parameter_description>
</parameter>
<parameter name="count">
<parameter_description> the size of the buffer. Note that the buffer may
not be complelely filled even if there is data
in the buffer if the remaining data is not a
complete character.
</parameter_description>
</parameter>
<parameter name="bytes_read">
<parameter_description> The number of bytes read. This may be zero even on
success if count &lt; 6 and the channel's encoding is non-%NULL.
This indicates that the next UTF-8 character is too wide for
the buffer.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> a location to return an error of type #GConvertError
or #GIOChannelError.
</parameter_description>
</parameter>
</parameters>
<return> the status of the operation.
</return>
</function>

<function name="g_variant_get_va">
<description>
This function is intended to be used by libraries based on #GVariant
that want to provide g_variant_get()-like functionality to their
users.

The API is more general than g_variant_get() to allow a wider range
of possible uses.

@format_string must still point to a valid format string, but it only
need to be nul-terminated if @endptr is %NULL.  If @endptr is
non-%NULL then it is updated to point to the first character past the
end of the format string.

@app is a pointer to a #va_list.  The arguments, according to
@format_string, are collected from this #va_list and the list is left
pointing to the argument following the last.

These two generalisations allow mixing of multiple calls to
g_variant_new_va() and g_variant_get_va() within a single actual
varargs call by the user.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
<parameter name="format_string">
<parameter_description> a string that is prefixed with a format string
</parameter_description>
</parameter>
<parameter name="endptr">
<parameter_description> location to store the end pointer,
or %NULL
</parameter_description>
</parameter>
<parameter name="app">
<parameter_description> a pointer to a #va_list
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_main_context_iteration">
<description>
Runs a single iteration for the given main loop. This involves
checking to see if any event sources are ready to be processed,
then if no events sources are ready and @may_block is %TRUE, waiting
for a source to become ready, then dispatching the highest priority
events sources that are ready. Otherwise, if @may_block is %FALSE 
sources are not waited to become ready, only those highest priority 
events sources will be dispatched (if any), that are ready at this 
given moment without further waiting.

Note that even when @may_block is %TRUE, it is still possible for 
g_main_context_iteration() to return %FALSE, since the the wait may 
be interrupted for other reasons than an event source becoming ready.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext (if %NULL, the default context will be used) 
</parameter_description>
</parameter>
<parameter name="may_block">
<parameter_description> whether the call may block.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if events were dispatched.
</return>
</function>

<function name="g_param_spec_pool_list">
<description>
Gets an array of all #GParamSpec&lt;!-- --&gt;s owned by @owner_type in
the pool.


</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GParamSpecPool
</parameter_description>
</parameter>
<parameter name="owner_type">
<parameter_description> the owner to look for
</parameter_description>
</parameter>
<parameter name="n_pspecs_p">
<parameter_description> return location for the length of the returned array
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated array containing pointers to all
#GParamSpec&lt;!-- --&gt;s owned by @owner_type in the pool
</return>
</function>

<function name="g_variant_get_gtype">
<description>
Since: 2.24
Deprecated: 2.26

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_key_file_get_integer_list">
<description>
Returns the values associated with @key under @group_name as
integers. 

If @key cannot be found then %NULL is returned and @error is set to
#G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
with @key cannot be interpreted as integers then %NULL is returned
and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the number of integers returned
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> the values associated with the key as a list of
integers, or %NULL if the key was not found or could not be parsed.

</return>
</function>

<function name="g_file_error_from_errno">
<description>
Gets a #GFileError constant based on the passed-in @errno.
For example, if you pass in %EEXIST this function returns
#G_FILE_ERROR_EXIST. Unlike @errno values, you can portably
assume that all #GFileError values will exist.

Normally a #GFileError value goes into a #GError returned
from a function that manipulates files. So you would use
g_file_error_from_errno() when constructing a #GError.


</description>
<parameters>
<parameter name="err_no">
<parameter_description> an &quot;errno&quot; value
</parameter_description>
</parameter>
</parameters>
<return> #GFileError corresponding to the given @errno
</return>
</function>

<function name="g_main_context_find_source_by_funcs_user_data">
<description>
Finds a source with the given source functions and user data.  If
multiple sources exist with the same source function and user data,
the first one found will be returned.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext (if %NULL, the default context will be used).
</parameter_description>
</parameter>
<parameter name="funcs">
<parameter_description> the @source_funcs passed to g_source_new().
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> the user data from the callback.
</parameter_description>
</parameter>
</parameters>
<return> the source, if one was found, otherwise %NULL
</return>
</function>

<function name="g_object_get_valist">
<description>
Gets properties of an object.

In general, a copy is made of the property contents and the caller
is responsible for freeing the memory in the appropriate manner for
the type, for instance by calling g_free() or g_object_unref().

See g_object_get().

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="first_property_name">
<parameter_description> name of the first property to get
</parameter_description>
</parameter>
<parameter name="var_args">
<parameter_description> return location for the first property, followed optionally by more
name/return location pairs, followed by %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cond_timed_wait">
<description>
Waits until this thread is woken up on @cond, but not longer than
until the time specified by @abs_time. The @mutex is unlocked before
falling asleep and locked again before resuming.

If @abs_time is %NULL, g_cond_timed_wait() acts like g_cond_wait().

This function can be used even if g_thread_init() has not yet been
called, and, in that case, will immediately return %TRUE.

To easily calculate @abs_time a combination of g_get_current_time()
and g_time_val_add() can be used.

</description>
<parameters>
<parameter name="cond">
<parameter_description> a #GCond.
</parameter_description>
</parameter>
<parameter name="mutex">
<parameter_description> a #GMutex that is currently locked.
</parameter_description>
</parameter>
<parameter name="abs_time">
<parameter_description> a #GTimeVal, determining the final time.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @cond was signalled, or %FALSE on timeout.
</return>
</function>

<function name="g_slist_nth">
<description>
Gets the element at the given position in a #GSList.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position of the element, counting from 0
</parameter_description>
</parameter>
</parameters>
<return> the element, or %NULL if the position is off 
the end of the #GSList
</return>
</function>

<function name="g_unicode_canonical_ordering">
<description>
Computes the canonical ordering of a string in-place.  
This rearranges decomposed characters in the string 
according to their combining classes.  See the Unicode 
manual for more information. 

</description>
<parameters>
<parameter name="string">
<parameter_description> a UCS-4 encoded string.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length of @string to use.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_position">
<description>
Gets the position of the given element 
in the #GSList (starting from 0).


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="llink">
<parameter_description> an element in the #GSList
</parameter_description>
</parameter>
</parameters>
<return> the position of the element in the #GSList, 
or -1 if the element is not found
</return>
</function>

<function name="g_variant_new_object_path">
<description>
Creates a DBus object path #GVariant with the contents of @string.
@string must be a valid DBus object path.  Use
g_variant_is_object_path() if you're not sure.

Since: 2.24

</description>
<parameters>
<parameter name="object_path">
<parameter_description> a normal C nul-terminated string
</parameter_description>
</parameter>
</parameters>
<return> a new object path #GVariant instance
</return>
</function>

<function name="g_rand_boolean">
<description>
Returns a random #gboolean from @rand_. This corresponds to a
unbiased coin toss.

</description>
<parameters>
<parameter name="rand_">
<parameter_description> a #GRand.
</parameter_description>
</parameter>
</parameters>
<return> a random #gboolean.
</return>
</function>

<function name="g_variant_unref">
<description>
Decreases the reference count of @value.  When its reference count
drops to 0, the memory used by the variant is freed.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_remove">
<description>
Removes the first element in @queue that contains @data. 

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to remove.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_iter_get_sequence">
<description>
Returns the #GSequence that @iter points into.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return> the #GSequence that @iter points into.

</return>
</function>

<function name="g_hash_table_iter_get_hash_table">
<description>
Returns the #GHashTable associated with @iter.

Since: 2.16

</description>
<parameters>
<parameter name="iter">
<parameter_description> an initialized #GHashTableIter.
</parameter_description>
</parameter>
</parameters>
<return> the #GHashTable associated with @iter.

</return>
</function>

<function name="g_key_file_get_double">
<description>
Returns the value associated with @key under @group_name as a
double. If @group_name is %NULL, the start_group is used.

If @key cannot be found then 0.0 is returned and @error is set to
#G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
with @key cannot be interpreted as a double then 0.0 is returned
and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.

Since: 2.12

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> the value associated with the key as a double, or
0.0 if the key was not found or could not be parsed.

</return>
</function>

<function name="g_hostname_to_ascii">
<description>
Converts @hostname to its canonical ASCII form; an ASCII-only
string containing no uppercase letters and not ending with a
trailing dot.

Since: 2.22

</description>
<parameters>
<parameter name="hostname">
<parameter_description> a valid UTF-8 or ASCII hostname
</parameter_description>
</parameter>
</parameters>
<return> an ASCII hostname, which must be freed, or %NULL if
@hostname is in some way invalid.

</return>
</function>

<function name="g_test_log_msg_free">
<description>
Internal function for gtester to free test log messages, no ABI guarantees provided.

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_byte_array_new">
<description>
Creates a new #GByteArray with a reference count of 1.

</description>
<parameters>
</parameters>
<return> the new #GByteArray.
</return>
</function>

<function name="g_variant_type_dup_string">
<description>
Returns a newly-allocated copy of the type string corresponding to
@type.  The returned string is nul-terminated.  It is appropriate to
call g_free() on the return value.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> the corresponding type string
</return>
</function>

<function name="g_value_set_int64">
<description>
Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_INT64
</parameter_description>
</parameter>
<parameter name="v_int64">
<parameter_description> 64bit integer value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_atomic_int_compare_and_exchange">
<description>
Compares @oldval with the integer pointed to by @atomic and
if they are equal, atomically exchanges *@atomic with @newval.
Also acts as a memory barrier.

Since: 2.4

</description>
<parameters>
<parameter name="atomic">
<parameter_description> a pointer to an integer
</parameter_description>
</parameter>
<parameter name="oldval">
<parameter_description> the assumed old value of *@atomic
</parameter_description>
</parameter>
<parameter name="newval">
<parameter_description> the new value of *@atomic
</parameter_description>
</parameter>
</parameters>
<return> %TRUE, if *@atomic was equal @oldval. %FALSE otherwise.

</return>
</function>

<function name="g_unichar_validate">
<description>
Checks whether @ch is a valid Unicode character. Some possible
integer values of @ch will not be valid. 0 is considered a valid
character, though it's normally a string terminator.


</description>
<parameters>
<parameter name="ch">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @ch is a valid Unicode character
</return>
</function>

<function name="g_type_default_interface_unref">
<description>
Decrements the reference count for the type corresponding to the
interface default vtable @g_iface. If the type is dynamic, then
when no one is using the interface and all references have
been released, the finalize function for the interface's default
vtable (the &lt;structfield&gt;class_finalize&lt;/structfield&gt; member of
#GTypeInfo) will be called.

Since: 2.4

</description>
<parameters>
<parameter name="g_iface">
<parameter_description> the default vtable structure for a interface, as
returned by g_type_default_interface_ref()
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_int64">
<description>
Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_cclosure_marshal_VOID__OBJECT">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, GObject *arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #GObject* parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_spawn_command_line_async">
<description>
A simple version of g_spawn_async() that parses a command line with
g_shell_parse_argv() and passes it to g_spawn_async(). Runs a
command line in the background. Unlike g_spawn_async(), the
%G_SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note
that %G_SPAWN_SEARCH_PATH can have security implications, so
consider using g_spawn_async() directly if appropriate. Possible
errors are those from g_shell_parse_argv() and g_spawn_async().

The same concerns on Windows apply as for g_spawn_command_line_sync().


</description>
<parameters>
<parameter name="command_line">
<parameter_description> a command line
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for errors
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success, %FALSE if error is set.
</return>
</function>

<function name="g_value_set_instance">
<description>
Sets @value from an instantiatable type via the
value_table's collect_value() function.

</description>
<parameters>
<parameter name="value">
<parameter_description> An initialized #GValue structure.
</parameter_description>
</parameter>
<parameter name="instance">
<parameter_description> the instance
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_plugin_complete_interface_info">
<description>
Calls the @complete_interface_info function from the
#GTypePluginClass of @plugin. There should be no need to use this
function outside of the GObject type system itself.

</description>
<parameters>
<parameter name="plugin">
<parameter_description> the #GTypePlugin
</parameter_description>
</parameter>
<parameter name="instance_type">
<parameter_description> the #GType of an instantiable type to which the interface
is added
</parameter_description>
</parameter>
<parameter name="interface_type">
<parameter_description> the #GType of the interface whose info is completed
</parameter_description>
</parameter>
<parameter name="info">
<parameter_description> the #GInterfaceInfo to fill in
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_chain_from_overridden">
<description>
Calls the original class closure of a signal. This function should only
be called from an overridden class closure; see
g_signal_override_class_closure() and
g_signal_override_class_handler().

</description>
<parameters>
<parameter name="instance_and_params">
<parameter_description> the argument list of the signal emission. The first
element in the array is a #GValue for the instance the signal is being
emitted on. The rest are any arguments to be passed to the signal.
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> Location for the return value.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_new_byte">
<description>
Creates a new byte #GVariant instance.

Since: 2.24

</description>
<parameters>
<parameter name="byte">
<parameter_description> a #guint8 value
</parameter_description>
</parameter>
</parameters>
<return> a new byte #GVariant instance
</return>
</function>

<function name="g_source_get_name">
<description>
Gets a name for the source, used in debugging and profiling.
The name may be #NULL if it has never been set with
g_source_set_name().

Since: 2.26

</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
</parameters>
<return> the name of the source
</return>
</function>

<function name="g_value_set_uint">
<description>
Set the contents of a %G_TYPE_UINT #GValue to @v_uint.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_UINT
</parameter_description>
</parameter>
<parameter name="v_uint">
<parameter_description> unsigned integer value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_set_flags">
<description>
Sets the (writeable) flags in @channel to (@flags &amp; %G_IO_CHANNEL_SET_MASK).


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> the flags to set on the IO channel
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> A location to return an error of type #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> the status of the operation. 
</return>
</function>

<function name="g_idle_add">
<description>
Adds a function to be called whenever there are no higher priority
events pending to the default main loop. The function is given the
default idle priority, #G_PRIORITY_DEFAULT_IDLE.  If the function
returns %FALSE it is automatically removed from the list of event
sources and will not be called again.

This internally creates a main loop source using g_idle_source_new()
and attaches it to the main loop context using g_source_attach(). 
You can do these steps manually if you need greater control.


</description>
<parameters>
<parameter name="function">
<parameter_description> function to call 
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to pass to @function.
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) of the event source.
</return>
</function>

<function name="g_string_append_printf">
<description>
Appends a formatted string onto the end of a #GString.
This function is similar to g_string_printf() except 
that the text is appended to the #GString.

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> the string format. See the printf() documentation
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the parameters to insert into the format string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_new_int64">
<description>
Creates a new int64 #GVariant instance.

Since: 2.24

</description>
<parameters>
<parameter name="int64">
<parameter_description> a #gint64 value
</parameter_description>
</parameter>
</parameters>
<return> a new int64 #GVariant instance
</return>
</function>

<function name="g_cclosure_marshal_VOID__PARAM">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, GParamSpec *arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #GParamSpec* parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_dup_object">
<description>
Get the contents of a %G_TYPE_OBJECT derived #GValue, increasing
its reference count.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue whose type is derived from %G_TYPE_OBJECT
</parameter_description>
</parameter>
</parameters>
<return> object content of @value, should be unreferenced when no
longer needed.
</return>
</function>

<function name="g_enum_get_value_by_nick">
<description>
Looks up a #GEnumValue by nickname.


</description>
<parameters>
<parameter name="enum_class">
<parameter_description> a #GEnumClass
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> the nickname to look up
</parameter_description>
</parameter>
</parameters>
<return> the #GEnumValue with nickname @nick, or %NULL if the
enumeration doesn't have a member with that nickname
</return>
</function>

<function name="g_variant_type_copy">
<description>
Makes a copy of a #GVariantType.  It is appropriate to call
g_variant_type_free() on the return value.  @type may not be %NULL.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> a new #GVariantType
</return>
</function>

<function name="g_key_file_new">
<description>
Creates a new empty #GKeyFile object. Use
g_key_file_load_from_file(), g_key_file_load_from_data(),
g_key_file_load_from_dirs() or g_key_file_load_from_data_dirs() to
read an existing key file.

Since: 2.6

</description>
<parameters>
</parameters>
<return> an empty #GKeyFile.

</return>
</function>

<function name="g_sequence_search_iter">
<description>
Like g_sequence_search(), but uses
a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
the compare function.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data for the new item
</parameter_description>
</parameter>
<parameter name="iter_cmp">
<parameter_description> the #GSequenceIterCompare function used to compare iterators
in the sequence. It is called with two iterators pointing into @seq.
It should return 0 if the iterators are equal, a negative value if the
first iterator comes before the second, and a positive value if the
second iterator comes before the first.
</parameter_description>
</parameter>
<parameter name="cmp_data">
<parameter_description> user data passed to @iter_cmp
</parameter_description>
</parameter>
</parameters>
<return> a #GSequenceIter pointing to the position in @seq
where @data would have been inserted according to @iter_cmp and @cmp_data.

</return>
</function>

<function name="g_main_context_unref">
<description>
Decreases the reference count on a #GMainContext object by one. If
the result is zero, free the context and free all associated memory.

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_get_char">
<description>
Get the contents of a %G_TYPE_CHAR #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_CHAR
</parameter_description>
</parameter>
</parameters>
<return> character contents of @value
</return>
</function>

<function name="g_sequence_range_get_midpoint">
<description>
Finds an iterator somewhere in the range (@begin, @end). This
iterator will be close to the middle of the range, but is not
guaranteed to be &lt;emphasis&gt;exactly&lt;/emphasis&gt; in the middle.

The @begin and @end iterators must both point to the same sequence and
@begin must come before or be equal to @end in the sequence.

Since: 2.14

</description>
<parameters>
<parameter name="begin">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return> A #GSequenceIter pointing somewhere in the
(@begin, @end) range.

</return>
</function>

<function name="g_get_current_time">
<description>
Equivalent to the UNIX gettimeofday() function, but portable.

</description>
<parameters>
<parameter name="result">
<parameter_description> #GTimeVal structure in which to store current time.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_double_hash">
<description>
Converts a pointer to a #gdouble to a hash value.
It can be passed to g_hash_table_new() as the @hash_func parameter, 
when using pointers to doubles as keys in a #GHashTable.

Since: 2.22

</description>
<parameters>
<parameter name="v">
<parameter_description> a pointer to a #gdouble key
</parameter_description>
</parameter>
</parameters>
<return> a hash value corresponding to the key.

</return>
</function>

<function name="g_sequence_iter_prev">
<description>
Returns an iterator pointing to the previous position before @iter. If
@iter is the begin iterator, the begin iterator is returned.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return> a #GSequenceIter pointing to the previous position before
@iter.

</return>
</function>

<function name="g_queue_pop_head">
<description>
Removes the first element of the queue.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
</parameters>
<return> the data of the first element in the queue, or %NULL if the queue
is empty.
</return>
</function>

<function name="g_static_private_free">
<description>
Releases all resources allocated to @private_key.

You don't have to call this functions for a #GStaticPrivate with an
unbounded lifetime, i.e. objects declared 'static', but if you have
a #GStaticPrivate as a member of a structure and the structure is
freed, you should also free the #GStaticPrivate.

</description>
<parameters>
<parameter name="private_key">
<parameter_description> a #GStaticPrivate to be freed.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_regex_replace">
<description>
Replaces all occurrences of the pattern in @regex with the
replacement text. Backreferences of the form '\number' or
'\g&lt;number&gt;' in the replacement text are interpolated by the
number-th captured subexpression of the match, '\g&lt;name&gt;' refers
to the captured subexpression with the given name. '\0' refers to the
complete match, but '\0' followed by a number is the octal representation
of a character. To include a literal '\' in the replacement, write '\\'.
There are also escapes that changes the case of the following text:

&lt;variablelist&gt;
&lt;varlistentry&gt;&lt;term&gt;\l&lt;/term&gt;
&lt;listitem&gt;
&lt;para&gt;Convert to lower case the next character&lt;/para&gt;
&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;&lt;term&gt;\u&lt;/term&gt;
&lt;listitem&gt;
&lt;para&gt;Convert to upper case the next character&lt;/para&gt;
&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;&lt;term&gt;\L&lt;/term&gt;
&lt;listitem&gt;
&lt;para&gt;Convert to lower case till \E&lt;/para&gt;
&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;&lt;term&gt;\U&lt;/term&gt;
&lt;listitem&gt;
&lt;para&gt;Convert to upper case till \E&lt;/para&gt;
&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;&lt;term&gt;\E&lt;/term&gt;
&lt;listitem&gt;
&lt;para&gt;End case modification&lt;/para&gt;
&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;/variablelist&gt;

If you do not need to use backreferences use g_regex_replace_literal().

The @replacement string must be UTF-8 encoded even if #G_REGEX_RAW was
passed to g_regex_new(). If you want to use not UTF-8 encoded stings
you can use g_regex_replace_literal().

Setting @start_position differs from just passing over a shortened
string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern that
begins with any kind of lookbehind assertion, such as &quot;\b&quot;.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to perform matches against
</parameter_description>
</parameter>
<parameter name="string_len">
<parameter_description> the length of @string, or -1 if @string is nul-terminated
</parameter_description>
</parameter>
<parameter name="start_position">
<parameter_description> starting index of the string to match
</parameter_description>
</parameter>
<parameter name="replacement">
<parameter_description> text to replace each match with
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> options for the match
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore errors
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string containing the replacements

</return>
</function>

<function name="g_markup_parse_context_new">
<description>
Creates a new parse context. A parse context is used to parse
marked-up documents. You can feed any number of documents into
a context, as long as no errors occur; once an error occurs,
the parse context can't continue to parse text (you have to free it
and create a new parse context).


</description>
<parameters>
<parameter name="parser">
<parameter_description> a #GMarkupParser
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> one or more #GMarkupParseFlags
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to #GMarkupParser functions
</parameter_description>
</parameter>
<parameter name="user_data_dnotify">
<parameter_description> user data destroy notifier called when the parse context is freed
</parameter_description>
</parameter>
</parameters>
<return> a new #GMarkupParseContext
</return>
</function>

<function name="g_unichar_get_script">
<description>
Looks up the #GUnicodeScript for a particular character (as defined 
by Unicode Standard Annex #24). No check is made for @ch being a
valid Unicode character; if you pass in invalid character, the
result is undefined.

This function is equivalent to pango_script_for_unichar() and the
two are interchangeable.

Since: 2.14

</description>
<parameters>
<parameter name="ch">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> the #GUnicodeScript for the character.

</return>
</function>

<function name="g_tree_destroy">
<description>
Removes all keys and values from the #GTree and decreases its
reference count by one. If keys and/or values are dynamically
allocated, you should either free them first or create the #GTree
using g_tree_new_full().  In the latter case the destroy functions
you supplied will be called on all keys and values before destroying
the #GTree.

</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_dir_close">
<description>
Closes the directory and deallocates all related resources.

</description>
<parameters>
<parameter name="dir">
<parameter_description> a #GDir* created by g_dir_open()
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_closure_invalidate">
<description>
Sets a flag on the closure to indicate that its calling
environment has become invalid, and thus causes any future
invocations of g_closure_invoke() on this @closure to be
ignored. Also, invalidation notifiers installed on the closure will
be called at this point. Note that unless you are holding a
reference to the closure yourself, the invalidation notifiers may
unref the closure and cause it to be destroyed, so if you need to
access the closure after calling g_closure_invalidate(), make sure
that you've previously called g_closure_ref().

Note that g_closure_invalidate() will also be called when the
reference count of a closure drops to zero (unless it has already
been invalidated before).

</description>
<parameters>
<parameter name="closure">
<parameter_description> GClosure to invalidate
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_set_application_name">
<description>
Sets a human-readable name for the application. This name should be
localized if possible, and is intended for display to the user.
Contrast with g_set_prgname(), which sets a non-localized name.
g_set_prgname() will be called automatically by gtk_init(),
but g_set_application_name() will not.

Note that for thread safety reasons, this function can only
be called once.

The application name will be used in contexts such as error messages,
or when displaying an application's name in the task list.

Since: 2.2

</description>
<parameters>
<parameter name="application_name">
<parameter_description> localized name of the application
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_plugin_unuse">
<description>
Calls the @unuse_plugin function from the #GTypePluginClass of
@plugin.  There should be no need to use this function outside of
the GObject type system itself.

</description>
<parameters>
<parameter name="plugin">
<parameter_description> a #GTypePlugin
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_regex_split_full">
<description>
Breaks the string on the pattern, and returns an array of the tokens.
If the pattern contains capturing parentheses, then the text for each
of the substrings will also be returned. If the pattern does not match
anywhere in the string, then the whole string is returned as the first
token.

As a special case, the result of splitting the empty string &quot;&quot; is an
empty vector, not a vector containing a single string. The reason for
this special case is that being able to represent a empty vector is
typically more useful than consistent handling of empty elements. If
you do need to represent empty elements, you'll need to check for the
empty string before calling this function.

A pattern that can match empty strings splits @string into separate
characters wherever it matches the empty string between characters.
For example splitting &quot;ab c&quot; using as a separator &quot;\s*&quot;, you will get
&quot;a&quot;, &quot;b&quot; and &quot;c&quot;.

Setting @start_position differs from just passing over a shortened
string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
that begins with any kind of lookbehind assertion, such as &quot;\b&quot;.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to split with the pattern
</parameter_description>
</parameter>
<parameter name="string_len">
<parameter_description> the length of @string, or -1 if @string is nul-terminated
</parameter_description>
</parameter>
<parameter name="start_position">
<parameter_description> starting index of the string to match
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> match time option flags
</parameter_description>
</parameter>
<parameter name="max_tokens">
<parameter_description> the maximum number of tokens to split @string into.
If this is less than 1, the string is split completely
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> a %NULL-terminated gchar ** array. Free it using g_strfreev()

</return>
</function>

<function name="g_signal_connect_data">
<description>
Connects a #GCallback function to a signal for a particular object. Similar
to g_signal_connect(), but allows to provide a #GClosureNotify for the data
which will be called when the signal handler is disconnected and no longer
used. Specify @connect_flags if you need &lt;literal&gt;..._after()&lt;/literal&gt; or
&lt;literal&gt;..._swapped()&lt;/literal&gt; variants of this function.


</description>
<parameters>
<parameter name="instance">
<parameter_description> the instance to connect to.
</parameter_description>
</parameter>
<parameter name="detailed_signal">
<parameter_description> a string of the form &quot;signal-name::detail&quot;.
</parameter_description>
</parameter>
<parameter name="c_handler">
<parameter_description> the #GCallback to connect.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to pass to @c_handler calls.
</parameter_description>
</parameter>
<parameter name="destroy_data">
<parameter_description> a #GClosureNotify for @data.
</parameter_description>
</parameter>
<parameter name="connect_flags">
<parameter_description> a combination of #GConnectFlags.
</parameter_description>
</parameter>
</parameters>
<return> the handler id
</return>
</function>

<function name="g_chmod">
<description>
A wrapper for the POSIX chmod() function. The chmod() function is
used to set the permissions of a file system object.

On Windows the file protection mechanism is not at all POSIX-like,
and the underlying chmod() function in the C library just sets or
clears the FAT-style READONLY attribute. It does not touch any
ACL. Software that needs to manage file permissions on Windows
exactly should use the Win32 API.

See your C library manual for more details about chmod().

Since: 2.8

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> as in chmod()
</parameter_description>
</parameter>
</parameters>
<return> zero if the operation succeeded, -1 on error.

</return>
</function>

<function name="g_match_info_fetch_named">
<description>
Retrieves the text matching the capturing parentheses named @name.

If @name is a valid sub pattern name but it didn't match anything
(e.g. sub pattern &quot;X&quot;, matching &quot;b&quot; against &quot;(?P&lt;X&gt;a)?b&quot;)
then an empty string is returned.

The string is fetched from the string passed to the match function,
so you cannot call this function after freeing the string.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> #GMatchInfo structure
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> name of the subexpression
</parameter_description>
</parameter>
</parameters>
<return> The matched substring, or %NULL if an error
occurred. You have to free the string yourself

</return>
</function>

<function name="g_bookmark_file_add_group">
<description>
Adds @group to the list of groups to which the bookmark for @uri
belongs to.

If no bookmark for @uri is found then it is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="group">
<parameter_description> the group name to be added
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_prepend">
<description>
Adds a new item to the front of @seq

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new item
</parameter_description>
</parameter>
</parameters>
<return> an iterator pointing to the new item

</return>
</function>

<function name="g_utf8_to_utf16">
<description>
Convert a string from UTF-8 to UTF-16. A 0 character will be
added to the result after the converted text.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length (number of bytes) of @str to use.
If @len &lt; 0, then the string is nul-terminated.
</parameter_description>
</parameter>
<parameter name="items_read">
<parameter_description> location to store number of bytes read, or %NULL.
If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be
returned in case @str contains a trailing partial
character. If an error occurs then the index of the
invalid input is stored here.
</parameter_description>
</parameter>
<parameter name="items_written">
<parameter_description> location to store number of &lt;type&gt;gunichar2&lt;/type&gt; written,
or %NULL.
The value stored here does not include the trailing 0.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError other than
%G_CONVERT_ERROR_NO_CONVERSION may occur.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to a newly allocated UTF-16 string.
This value must be freed with g_free(). If an
error occurs, %NULL will be returned and
@error set.
</return>
</function>

<function name="g_object_interface_install_property">
<description>
Add a property to an interface; this is only useful for interfaces
that are added to GObject-derived types. Adding a property to an
interface forces all objects classes with that interface to have a
compatible property. The compatible property could be a newly
created #GParamSpec, but normally
g_object_class_override_property() will be used so that the object
class only needs to provide an implementation and inherits the
property description, default value, bounds, and so forth from the
interface property.

This function is meant to be called from the interface's default
vtable initialization function (the @class_init member of
#GTypeInfo.) It must not be called after after @class_init has
been called for any object types implementing this interface.

Since: 2.4

</description>
<parameters>
<parameter name="g_iface">
<parameter_description> any interface vtable for the interface, or the default
vtable for the interface.
</parameter_description>
</parameter>
<parameter name="pspec">
<parameter_description> the #GParamSpec for the new property
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_format_size_for_display">
<description>
Formats a size (for example the size of a file) into a human readable string.
Sizes are rounded to the nearest size prefix (KB, MB, GB) and are displayed 
rounded to the nearest  tenth. E.g. the file size 3292528 bytes will be
converted into the string &quot;3.1 MB&quot;.

The prefix units base is 1024 (i.e. 1 KB is 1024 bytes).

This string should be freed with g_free() when not needed any longer.

Since: 2.16

</description>
<parameters>
<parameter name="size">
<parameter_description> a size in bytes.
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated formatted string containing a human readable
file size.

</return>
</function>

<function name="g_list_remove">
<description>
Removes an element from a #GList.
If two elements contain the same data, only the first is removed.
If none of the elements contain the data, the #GList is unchanged.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data of the element to remove
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GList
</return>
</function>

<function name="g_cclosure_marshal_VOID__POINTER">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gpointer arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #gpointer parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_child_watch_add_full">
<description>
Sets a function to be called when the child indicated by @pid 
exits, at the priority @priority.

If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes() 
you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to 
the spawn function for the child watching to work.

Note that on platforms where #GPid must be explicitly closed
(see g_spawn_close_pid()) @pid must not be closed while the
source is still active. Typically, you will want to call
g_spawn_close_pid() in the callback function for the source.

GLib supports only a single callback per process id.

This internally creates a main loop source using 
g_child_watch_source_new() and attaches it to the main loop context 
using g_source_attach(). You can do these steps manually if you 
need greater control.

Since: 2.4

</description>
<parameters>
<parameter name="priority">
<parameter_description> the priority of the idle source. Typically this will be in the
range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
</parameter_description>
</parameter>
<parameter name="pid">
<parameter_description>      process to watch. On POSIX the pid of a child process. On
Windows a handle for a process (which doesn't have to be a child).
</parameter_description>
</parameter>
<parameter name="function">
<parameter_description> function to call
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description>     data to pass to @function
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description>   function to call when the idle is removed, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) of the event source.

</return>
</function>

<function name="g_option_context_free">
<description>
Frees context and all the groups which have been 
added to it.

Please note that parsed arguments need to be freed separately (see
#GOptionEntry).

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext 
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_seek">
<description>
Sets the current position in the #GIOChannel, similar to the standard 
library function fseek(). 

Deprecated:2.2: Use g_io_channel_seek_position() instead.

</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="offset">
<parameter_description> an offset, in bytes, which is added to the position specified 
by @type
</parameter_description>
</parameter>
<parameter name="type">
<parameter_description> the position in the file, which can be %G_SEEK_CUR (the current
position), %G_SEEK_SET (the start of the file), or %G_SEEK_END 
(the end of the file)
</parameter_description>
</parameter>
</parameters>
<return> %G_IO_ERROR_NONE if the operation was successful.

</return>
</function>

<function name="g_utf8_strdown">
<description>
Converts all Unicode characters in the string that have a case
to lowercase. The exact manner that this is done depends
on the current locale, and may result in the number of
characters in the string changing.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> length of @str, in bytes, or -1 if @str is nul-terminated.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string, with all characters
converted to lowercase.  
</return>
</function>

<function name="g_match_info_get_match_count">
<description>
Retrieves the number of matched substrings (including substring 0,
that is the whole matched text), so 1 is returned if the pattern
has no substrings in it and 0 is returned if the match failed.

If the last match was obtained using the DFA algorithm, that is
using g_regex_match_all() or g_regex_match_all_full(), the retrieved
count is not that of the number of capturing parentheses but that of
the number of matched substrings.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> a #GMatchInfo structure
</parameter_description>
</parameter>
</parameters>
<return> Number of matched substrings, or -1 if an error occurred

</return>
</function>

<function name="g_cclosure_marshal_VOID__STRING">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, const gchar *arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #gchar* parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_filename_display_basename">
<description>
Returns the display basename for the particular filename, guaranteed
to be valid UTF-8. The display name might not be identical to the filename,
for instance there might be problems converting it to UTF-8, and some files
can be translated in the display.

If GLib can not make sense of the encoding of @filename, as a last resort it 
replaces unknown characters with U+FFFD, the Unicode replacement character.
You can search the result for the UTF-8 encoding of this character (which is
&quot;\357\277\275&quot; in octal notation) to find out if @filename was in an invalid
encoding.

You must pass the whole absolute pathname to this functions so that
translation of well known locations can be done.

This function is preferred over g_filename_display_name() if you know the
whole path, as it allows translation.

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> an absolute pathname in the GLib file name encoding
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string containing
a rendition of the basename of the filename in valid UTF-8

</return>
</function>

<function name="g_bookmark_file_to_file">
<description>
This function outputs @bookmark into a file.  The write process is
guaranteed to be atomic by using g_file_set_contents() internally.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="filename">
<parameter_description> path of the output file
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the file was successfully written.

</return>
</function>

<function name="g_datalist_set_flags">
<description>
Turns on flag values for a data list. This function is used
to keep a small number of boolean flags in an object with
a data list without using any additional space. It is
not generally useful except in circumstances where space
is very tight. (It is used in the base #GObject type, for
example.)

Since: 2.8

</description>
<parameters>
<parameter name="datalist">
<parameter_description> pointer to the location that holds a list
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> the flags to turn on. The values of the flags are
restricted by %G_DATALIST_FLAGS_MASK (currently
3; giving two possible boolean flags).
A value for @flags that doesn't fit within the mask is
an error.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_set_qdata_full">
<description>
This function works like g_param_spec_set_qdata(), but in addition,
a &lt;literal&gt;void (*destroy) (gpointer)&lt;/literal&gt; function may be
specified which is called with @data as argument when the @pspec is
finalized, or the data is being overwritten by a call to
g_param_spec_set_qdata() with the same @quark.

</description>
<parameters>
<parameter name="pspec">
<parameter_description> the #GParamSpec to set store a user data pointer
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> a #GQuark, naming the user data pointer
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> an opaque user data pointer
</parameter_description>
</parameter>
<parameter name="destroy">
<parameter_description> function to invoke with @data as argument, when @data needs to
be freed
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hash_table_unref">
<description>
Atomically decrements the reference count of @hash_table by one.
If the reference count drops to 0, all keys and values will be
destroyed, and all memory allocated by the hash table is released.
This function is MT-safe and may be called from any thread.

Since: 2.10

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a valid #GHashTable.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_dup_strv">
<description>
Gets the contents of an array of strings #GVariant.  This call
makes a deep copy; the return result should be released with
g_strfreev().

If @length is non-%NULL then the number of elements in the result
is stored there.  In any case, the resulting array will be
%NULL-terminated.

For an empty array, @length will be set to 0 and a pointer to a
%NULL pointer will be returned.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> an array of strings #GVariant
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of the result, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> an array of strings
</return>
</function>

<function name="g_dataset_id_get_data">
<description>
Gets the data element corresponding to a #GQuark.

</description>
<parameters>
<parameter name="dataset_location">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="key_id">
<parameter_description> the #GQuark id to identify the data element.
</parameter_description>
</parameter>
</parameters>
<return> the data element corresponding to the #GQuark, or %NULL if
it is not found.
</return>
</function>

<function name="g_strdupv">
<description>
Copies %NULL-terminated array of strings. The copy is a deep copy;
the new array should be freed by first freeing each string, then
the array itself. g_strfreev() does this for you. If called
on a %NULL value, g_strdupv() simply returns %NULL.


</description>
<parameters>
<parameter name="str_array">
<parameter_description> %NULL-terminated array of strings.
</parameter_description>
</parameter>
</parameters>
<return> a new %NULL-terminated array of strings.
</return>
</function>

<function name="g_string_append">
<description>
Adds a string onto the end of a #GString, expanding 
it if necessary.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> the string to append onto the end of @string
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_bookmark_file_get_size">
<description>
Gets the number of bookmarks inside @bookmark.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
</parameters>
<return> the number of bookmarks

</return>
</function>

<function name="g_bookmark_file_get_uris">
<description>
Returns all URIs of the bookmarks in the bookmark file @bookmark.
The array of returned URIs will be %NULL-terminated, so @length may
optionally be %NULL.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> return location for the number of returned URIs, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated %NULL-terminated array of strings.
Use g_strfreev() to free it.

</return>
</function>

<function name="g_param_value_convert">
<description>
Transforms @src_value into @dest_value if possible, and then
validates @dest_value, in order for it to conform to @pspec.  If
@strict_validation is %TRUE this function will only succeed if the
transformed @dest_value complied to @pspec without modifications.

See also g_value_type_transformable(), g_value_transform() and
g_param_value_validate().


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
<parameter name="src_value">
<parameter_description> souce #GValue
</parameter_description>
</parameter>
<parameter name="dest_value">
<parameter_description> destination #GValue of correct type for @pspec
</parameter_description>
</parameter>
<parameter name="strict_validation">
<parameter_description> %TRUE requires @dest_value to conform to @pspec
without modifications
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if transformation and validation were successful,
%FALSE otherwise and @dest_value is left untouched.
</return>
</function>

<function name="g_sequence_insert_sorted_iter">
<description>
Like g_sequence_insert_sorted(), but uses
a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
the compare function.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data for the new item
</parameter_description>
</parameter>
<parameter name="iter_cmp">
<parameter_description> the #GSequenceItercompare used to compare iterators in the
sequence. It is called with two iterators pointing into @seq. It should
return 0 if the iterators are equal, a negative value if the first
iterator comes before the second, and a positive value if the second
iterator comes before the first.
</parameter_description>
</parameter>
<parameter name="cmp_data">
<parameter_description> user data passed to @cmp_func
</parameter_description>
</parameter>
</parameters>
<return> a #GSequenceIter pointing to the new item

</return>
</function>

<function name="g_queue_push_tail_link">
<description>
Adds a new element at the tail of the queue.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
<parameter name="link_">
<parameter_description> a single #GList element, &lt;emphasis&gt;not&lt;/emphasis&gt; a list with
more than one element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_atomic_int_set">
<description>
Sets the value of the integer pointed to by @atomic.
Also acts as a memory barrier.

Since: 2.10

</description>
<parameters>
<parameter name="atomic">
<parameter_description> a pointer to an integer
</parameter_description>
</parameter>
<parameter name="newval">
<parameter_description> the new value
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_get_uint32">
<description>
Returns the 32-bit unsigned integer value of @value.

It is an error to call this function with a @value of any type
other than %G_VARIANT_TYPE_UINT32.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a uint32 #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> a #guint32
</return>
</function>

<function name="g_child_watch_source_new">
<description>
Creates a new child_watch source.

The source will not initially be associated with any #GMainContext
and must be added to one with g_source_attach() before it will be
executed.

Note that child watch sources can only be used in conjunction with
&lt;literal&gt;g_spawn...&lt;/literal&gt; when the %G_SPAWN_DO_NOT_REAP_CHILD
flag is used.

Note that on platforms where #GPid must be explicitly closed
(see g_spawn_close_pid()) @pid must not be closed while the
source is still active. Typically, you will want to call
g_spawn_close_pid() in the callback function for the source.

Note further that using g_child_watch_source_new() is not 
compatible with calling &lt;literal&gt;waitpid(-1)&lt;/literal&gt; in 
the application. Calling waitpid() for individual pids will
still work fine. 

Since: 2.4

</description>
<parameters>
<parameter name="pid">
<parameter_description> process to watch. On POSIX the pid of a child process. On
Windows a handle for a process (which doesn't have to be a child).
</parameter_description>
</parameter>
</parameters>
<return> the newly-created child watch source

</return>
</function>

<function name="g_variant_get_child">
<description>
Reads a child item out of a container #GVariant instance and
deconstructs it according to @format_string.  This call is
essentially a combination of g_variant_get_child_value() and
g_variant_get().

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a container #GVariant
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the child to deconstruct
</parameter_description>
</parameter>
<parameter name="format_string">
<parameter_description> a #GVariant format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments, as per @format_string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_string_scan">
<description>
Scan for a single complete and valid GVariant type string in @string.
The memory pointed to by @limit (or bytes beyond it) is never
accessed.

If a valid type string is found, @endptr is updated to point to the
first character past the end of the string that was found and %TRUE
is returned.

If there is no valid type string starting at @string, or if the type
string does not end before @limit then %FALSE is returned.

For the simple case of checking if a string is a valid type string,
see g_variant_type_string_is_valid().

Since: 2.24

</description>
<parameters>
<parameter name="string">
<parameter_description> a pointer to any string
</parameter_description>
</parameter>
<parameter name="limit">
<parameter_description> the end of @string, or %NULL
</parameter_description>
</parameter>
<parameter name="endptr">
<parameter_description> location to store the end pointer, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a valid type string was found
</return>
</function>

<function name="g_thread_create_full">
<description>
This function creates a new thread with the priority @priority. If
the underlying thread implementation supports it, the thread gets a
stack size of @stack_size or the default value for the current
platform, if @stack_size is 0.

If @joinable is %TRUE, you can wait for this threads termination
calling g_thread_join(). Otherwise the thread will just disappear
when it terminates. If @bound is %TRUE, this thread will be
scheduled in the system scope, otherwise the implementation is free
to do scheduling in the process scope. The first variant is more
expensive resource-wise, but generally faster. On some systems (e.g.
Linux) all threads are bound.

The new thread executes the function @func with the argument @data.
If the thread was created successfully, it is returned.

@error can be %NULL to ignore errors, or non-%NULL to report errors.
The error is set, if and only if the function returns %NULL.

&lt;note&gt;&lt;para&gt;It is not guaranteed that threads with different priorities
really behave accordingly. On some systems (e.g. Linux) there are no
thread priorities. On other systems (e.g. Solaris) there doesn't
seem to be different scheduling for different priorities. All in all
try to avoid being dependent on priorities. Use
%G_THREAD_PRIORITY_NORMAL here as a default.&lt;/para&gt;&lt;/note&gt;

&lt;note&gt;&lt;para&gt;Only use g_thread_create_full() if you really can't use
g_thread_create() instead. g_thread_create() does not take
@stack_size, @bound, and @priority as arguments, as they should only
be used in cases in which it is unavoidable.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="func">
<parameter_description> a function to execute in the new thread.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> an argument to supply to the new thread.
</parameter_description>
</parameter>
<parameter name="stack_size">
<parameter_description> a stack size for the new thread.
</parameter_description>
</parameter>
<parameter name="joinable">
<parameter_description> should this thread be joinable?
</parameter_description>
</parameter>
<parameter name="bound">
<parameter_description> should this thread be bound to a system thread?
</parameter_description>
</parameter>
<parameter name="priority">
<parameter_description> a priority for the thread.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for error.
</parameter_description>
</parameter>
</parameters>
<return> the new #GThread on success.
</return>
</function>

<function name="g_boxed_type_register_static">
<description>
This function creates a new %G_TYPE_BOXED derived type id for a new
boxed type with name @name. Boxed type handling functions have to be
provided to copy and free opaque boxed structures of this type.


</description>
<parameters>
<parameter name="name">
<parameter_description> Name of the new boxed type.
</parameter_description>
</parameter>
<parameter name="boxed_copy">
<parameter_description> Boxed structure copy function.
</parameter_description>
</parameter>
<parameter name="boxed_free">
<parameter_description> Boxed structure free function.
</parameter_description>
</parameter>
</parameters>
<return> New %G_TYPE_BOXED derived type id for @name.
</return>
</function>

<function name="g_idle_source_new">
<description>
Creates a new idle source.

The source will not initially be associated with any #GMainContext
and must be added to one with g_source_attach() before it will be
executed. Note that the default priority for idle sources is
%G_PRIORITY_DEFAULT_IDLE, as compared to other sources which
have a default priority of %G_PRIORITY_DEFAULT.


</description>
<parameters>
</parameters>
<return> the newly-created idle source
</return>
</function>

<function name="g_object_set_property">
<description>
Sets a property on an object.

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="property_name">
<parameter_description> the name of the property to set
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> the value
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_string_chunk_insert_len">
<description>
Adds a copy of the first @len bytes of @string to the #GStringChunk.
The copy is nul-terminated.

Since this function does not stop at nul bytes, it is the caller's
responsibility to ensure that @string has at least @len addressable
bytes.

The characters in the returned string can be changed, if necessary,
though you should not change anything after the end of the string.

Since: 2.4

</description>
<parameters>
<parameter name="chunk">
<parameter_description> a #GStringChunk
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> bytes to insert
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> number of bytes of @string to insert, or -1 to insert a
nul-terminated string
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the copy of @string within the #GStringChunk

</return>
</function>

<function name="g_list_delete_link">
<description>
Removes the node link_ from the list and frees it. 
Compare this to g_list_remove_link() which removes the node 
without freeing it.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="link_">
<parameter_description> node to delete from @list
</parameter_description>
</parameter>
</parameters>
<return> the new head of @list
</return>
</function>

<function name="g_value_get_uchar">
<description>
Get the contents of a %G_TYPE_UCHAR #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_UCHAR
</parameter_description>
</parameter>
</parameters>
<return> unsigned character contents of @value
</return>
</function>

<function name="g_bookmark_file_set_is_private">
<description>
Sets the private flag of the bookmark for @uri.

If a bookmark for @uri cannot be found then it is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="is_private">
<parameter_description> %TRUE if the bookmark should be marked as private
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_get_boolean">
<description>
Returns the value associated with @key under @group_name as a
boolean. 

If @key cannot be found then %FALSE is returned and @error is set
to #G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value
associated with @key cannot be interpreted as a boolean then %FALSE
is returned and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> the value associated with the key as a boolean, 
or %FALSE if the key was not found or could not be parsed.

</return>
</function>

<function name="g_value_array_new">
<description>
Allocate and initialize a new #GValueArray, optionally preserve space
for @n_prealloced elements. New arrays always contain 0 elements,
regardless of the value of @n_prealloced.


</description>
<parameters>
<parameter name="n_prealloced">
<parameter_description> number of values to preallocate space for
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated #GValueArray with 0 values
</return>
</function>

<function name="g_string_down">
<description>
Converts a #GString to lowercase.

Deprecated:2.2: This function uses the locale-specific 
tolower() function, which is almost never the right thing. 
Use g_string_ascii_down() or g_utf8_strdown() instead.

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
</parameters>
<return> the #GString.

</return>
</function>

<function name="g_strup">
<description>
Converts a string to upper case. 

Deprecated:2.2: This function is totally broken for the reasons discussed 
in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead.

</description>
<parameters>
<parameter name="string">
<parameter_description> the string to convert.
</parameter_description>
</parameter>
</parameters>
<return> the string

</return>
</function>

<function name="g_static_private_init">
<description>
Initializes @private_key. Alternatively you can initialize it with
#G_STATIC_PRIVATE_INIT.

</description>
<parameters>
<parameter name="private_key">
<parameter_description> a #GStaticPrivate to be initialized.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hash_table_size">
<description>
Returns the number of elements contained in the #GHashTable.


</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
</parameters>
<return> the number of key/value pairs in the #GHashTable.
</return>
</function>

<function name="g_type_class_peek">
<description>
This function is essentially the same as g_type_class_ref(), except that
the classes reference count isn't incremented. As a consequence, this function
may return %NULL if the class of the type passed in does not currently
exist (hasn't been referenced before).


</description>
<parameters>
<parameter name="type">
<parameter_description> Type ID of a classed type.
</parameter_description>
</parameter>
</parameters>
<return> The #GTypeClass structure for the given type ID or %NULL
if the class does not currently exist.
</return>
</function>

<function name="g_chunk_free">
<description>
A convenience macro to free an atom of memory from a #GMemChunk. It
simply switches the arguments and calls g_mem_chunk_free() It is
included simply to complement the other convenience macros,
g_chunk_new() and g_chunk_new0().

Deprecated:2.10: Use g_slice_free() instead

</description>
<parameters>
<parameter name="mem">
<parameter_description> a pointer to the atom to be freed.
</parameter_description>
</parameter>
<parameter name="mem_chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_has_application">
<description>
Checks whether the bookmark for @uri inside @bookmark has been
registered by application @name.

In the event the URI cannot be found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> the name of the application
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the application @name was found

</return>
</function>

<function name="g_memmove">
<description>
Copies a block of memory @len bytes long, from @src to @dest.
The source and destination areas may overlap.

In order to use this function, you must include 
&lt;filename&gt;string.h&lt;/filename&gt; yourself, because this macro will 
typically simply resolve to memmove() and GLib does not include 
&lt;filename&gt;string.h&lt;/filename&gt; for you.

</description>
<parameters>
<parameter name="dest">
<parameter_description> the destination address to copy the bytes to.
</parameter_description>
</parameter>
<parameter name="src">
<parameter_description> the source address to copy the bytes from.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the number of bytes to copy.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cclosure_marshal_BOOLEAN__FLAGS">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;gboolean (*callback) (gpointer instance, gint arg1, gpointer user_data)&lt;/literal&gt; where the #gint parameter
denotes a flags type.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> a #GValue which can store the returned #gboolean
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding instance and arg1
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_new_maybe">
<description>
Constructs the type corresponding to a maybe instance containing
type @type or Nothing.

It is appropriate to call g_variant_type_free() on the return value.

Since 2.24

</description>
<parameters>
<parameter name="element">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> a new maybe #GVariantType
</return>
</function>

<function name="g_random_boolean">
<description>
Returns a random #gboolean. This corresponds to a unbiased coin toss.

</description>
<parameters>
</parameters>
<return> a random #gboolean.
</return>
</function>

<function name="g_type_query">
<description>
Queries the type system for information about a specific type.
This function will fill in a user-provided structure to hold
type-specific information. If an invalid #GType is passed in, the
@type member of the #GTypeQuery is 0. All members filled into the
#GTypeQuery structure should be considered constant and have to be
left untouched.

</description>
<parameters>
<parameter name="type">
<parameter_description> the #GType value of a static, classed type.
</parameter_description>
</parameter>
<parameter name="query">
<parameter_description> A user provided structure that is filled in with constant values
upon success.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cond_free">
<description>
Destroys the #GCond.

</description>
<parameters>
<parameter name="cond">
<parameter_description> a #GCond.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_set_int64">
<description>
Associates a new integer value with @key under @group_name.
If @key cannot be found then it is created.

Since: 2.26

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> an integer value
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_strv_length">
<description>
Returns the length of the given %NULL-terminated 
string array @str_array.

Since: 2.6

</description>
<parameters>
<parameter name="str_array">
<parameter_description> a %NULL-terminated array of strings.
</parameter_description>
</parameter>
</parameters>
<return> length of @str_array.

</return>
</function>

<function name="g_thread_pool_set_max_unused_threads">
<description>
Sets the maximal number of unused threads to @max_threads. If
@max_threads is -1, no limit is imposed on the number of unused
threads.

</description>
<parameters>
<parameter name="max_threads">
<parameter_description> maximal number of unused threads
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_freeze_notify">
<description>
Increases the freeze count on @object. If the freeze count is
non-zero, the emission of &quot;notify&quot; signals on @object is
stopped. The signals are queued until the freeze count is decreased
to zero.

This is necessary for accessors that modify multiple properties to prevent
premature notification while the object is still being modified.

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_set_groups">
<description>
Sets a list of group names for the item with URI @uri.  Each previously
set group name list is removed.

If @uri cannot be found then an item for it is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> an item's URI
</parameter_description>
</parameter>
<parameter name="groups">
<parameter_description> an array of group names, or %NULL to remove all groups
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> number of group name values in @groups
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_n_nodes">
<description>
Gets the number of nodes in a tree.


</description>
<parameters>
<parameter name="root">
<parameter_description> a #GNode
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> which types of children are to be counted, one of 
%G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
</parameter_description>
</parameter>
</parameters>
<return> the number of nodes in the tree
</return>
</function>

<function name="g_relation_count">
<description>
Returns the number of tuples in a #GRelation that have the given
value in the given field.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="relation">
<parameter_description> a #GRelation.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the value to compare with.
</parameter_description>
</parameter>
<parameter name="field">
<parameter_description> the field of each record to match.
</parameter_description>
</parameter>
</parameters>
<return> the number of matches.
</return>
</function>

<function name="g_source_ref">
<description>
Increases the reference count on a source by one.


</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
</parameters>
<return> @source
</return>
</function>

<function name="g_main_context_wait">
<description>
Tries to become the owner of the specified context,
as with g_main_context_acquire(). But if another thread
is the owner, atomically drop @mutex and wait on @cond until 
that owner releases ownership or until @cond is signaled, then
try again (once) to become the owner.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
<parameter name="cond">
<parameter_description> a condition variable
</parameter_description>
</parameter>
<parameter name="mutex">
<parameter_description> a mutex, currently held
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the operation succeeded, and
this thread is now the owner of @context.
</return>
</function>

<function name="g_value_peek_pointer">
<description>
Return the value contents as pointer. This function asserts that
g_value_fits_pointer() returned %TRUE for the passed in value.
This is an internal function introduced mainly for C marshallers.


</description>
<parameters>
<parameter name="value">
<parameter_description> An initialized #GValue structure.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @value will fit inside a pointer value.
</return>
</function>

<function name="g_io_channel_error_quark">
<description>

</description>
<parameters>
</parameters>
<return> the quark used as %G_IO_CHANNEL_ERROR
</return>
</function>

<function name="g_signal_handler_is_connected">
<description>
Returns whether @handler_id is the id of a handler connected to @instance.


</description>
<parameters>
<parameter name="instance">
<parameter_description> The instance where a signal handler is sought.
</parameter_description>
</parameter>
<parameter name="handler_id">
<parameter_description> the handler id.
</parameter_description>
</parameter>
</parameters>
<return> whether @handler_id identifies a handler connected to @instance.
</return>
</function>

<function name="g_intern_static_string">
<description>
Returns a canonical representation for @string. Interned strings can
be compared for equality by comparing the pointers, instead of using strcmp().
g_intern_static_string() does not copy the string, therefore @string must
not be freed or modified. 

Since: 2.10

</description>
<parameters>
<parameter name="string">
<parameter_description> a static string
</parameter_description>
</parameter>
</parameters>
<return> a canonical representation for the string

</return>
</function>

<function name="g_variant_new_maybe">
<description>
Depending on if @child is %NULL, either wraps @child inside of a
maybe container or creates a Nothing instance for the given @type.

At least one of @child_type and @child must be non-%NULL.
If @child_type is non-%NULL then it must be a definite type.
If they are both non-%NULL then @child_type must be the type
of @child.

Since: 2.24

</description>
<parameters>
<parameter name="child_type">
<parameter_description> the #GVariantType of the child, or %NULL
</parameter_description>
</parameter>
<parameter name="child">
<parameter_description> the child value, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a new #GVariant maybe instance
</return>
</function>

<function name="g_unichar_isprint">
<description>
Determines whether a character is printable.
Unlike g_unichar_isgraph(), returns %TRUE for spaces.
Given some UTF-8 text, obtain a character value with
g_utf8_get_char().


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is printable
</return>
</function>

<function name="g_value_get_int">
<description>
Get the contents of a %G_TYPE_INT #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_INT
</parameter_description>
</parameter>
</parameters>
<return> integer contents of @value
</return>
</function>

<function name="g_value_set_enum">
<description>
Set the contents of a %G_TYPE_ENUM #GValue to @v_enum.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue whose type is derived from %G_TYPE_ENUM
</parameter_description>
</parameter>
<parameter name="v_enum">
<parameter_description> enum value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_first">
<description>
Determines the first item type of a tuple or dictionary entry
type.

This function may only be used with tuple or dictionary entry types,
but must not be used with the generic tuple type
%G_VARIANT_TYPE_TUPLE.

In the case of a dictionary entry type, this returns the type of
the key.

%NULL is returned in case of @type being %G_VARIANT_TYPE_UNIT.

This call, together with g_variant_type_next() provides an iterator
interface over tuple and dictionary entry types.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a tuple or dictionary entry #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> the first item type of @type, or %NULL
</return>
</function>

<function name="g_source_remove_poll">
<description>
Removes a file descriptor from the set of file descriptors polled for
this source. 

</description>
<parameters>
<parameter name="source">
<parameter_description>a #GSource 
</parameter_description>
</parameter>
<parameter name="fd">
<parameter_description> a #GPollFD structure previously passed to g_source_add_poll().
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ascii_strtod">
<description>
Converts a string to a #gdouble value.

This function behaves like the standard strtod() function
does in the C locale. It does this without actually changing 
the current locale, since that would not be thread-safe. 
A limitation of the implementation is that this function
will still accept localized versions of infinities and NANs. 

This function is typically used when reading configuration
files or other non-user input that should be locale independent.
To handle input from the user you should normally use the
locale-sensitive system strtod() function.

To convert from a #gdouble to a string in a locale-insensitive
way, use g_ascii_dtostr().

If the correct value would cause overflow, plus or minus %HUGE_VAL
is returned (according to the sign of the value), and %ERANGE is
stored in %errno. If the correct value would cause underflow,
zero is returned and %ERANGE is stored in %errno.

This function resets %errno before calling strtod() so that
you can reliably detect overflow and underflow.


</description>
<parameters>
<parameter name="nptr">
<parameter_description>    the string to convert to a numeric value.
</parameter_description>
</parameter>
<parameter name="endptr">
<parameter_description>  if non-%NULL, it returns the character after
the last character used in the conversion.
</parameter_description>
</parameter>
</parameters>
<return> the #gdouble value.
</return>
</function>

<function name="g_utf8_strlen">
<description>
Computes the length of the string in characters, not including
the terminating nul character.


</description>
<parameters>
<parameter name="p">
<parameter_description> pointer to the start of a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="max">
<parameter_description> the maximum number of bytes to examine. If @max
is less than 0, then the string is assumed to be
nul-terminated. If @max is 0, @p will not be examined and
may be %NULL.
</parameter_description>
</parameter>
</parameters>
<return> the length of the string in characters
</return>
</function>

<function name="g_tuples_destroy">
<description>
Frees the records which were returned by g_relation_select(). This
should always be called after g_relation_select() when you are
finished with the records. The records are not removed from the
#GRelation.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="tuples">
<parameter_description> the tuple data to free.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_main_context_pop_thread_default">
<description>
Pops @context off the thread-default context stack (verifying that
it was on the top of the stack).

Since: 2.22

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext object, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_unichar_xdigit_value">
<description>
Determines the numeric value of a character as a hexidecimal
digit.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> If @c is a hex digit (according to
g_unichar_isxdigit()), its numeric value. Otherwise, -1.
</return>
</function>

<function name="g_queue_remove_all">
<description>
Remove all elemeents in @queue which contains @data.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to remove
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_nth_child">
<description>
Gets a child of a #GNode, using the given index.
The first child is at index 0. If the index is 
too big, %NULL is returned.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the index of the desired child
</parameter_description>
</parameter>
</parameters>
<return> the child of @node at index @n
</return>
</function>

<function name="g_string_sprintf">
<description>
Writes a formatted string into a #GString.
This is similar to the standard sprintf() function,
except that the #GString buffer automatically expands 
to contain the results. The previous contents of the 
#GString are destroyed. 

Deprecated: This function has been renamed to g_string_printf().

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> the string format. See the sprintf() documentation
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the parameters to insert into the format string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_length">
<description>
Gets the number of elements in a #GSList.

&lt;note&gt;&lt;para&gt;
This function iterates over the whole list to 
count its elements.
&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
</parameters>
<return> the number of elements in the #GSList
</return>
</function>

<function name="g_array_sort">
<description>
Sorts a #GArray using @compare_func which should be a qsort()-style
comparison function (returns less than zero for first arg is less
than second arg, zero for equal, greater zero if first arg is
greater than second arg).

If two array elements compare equal, their order in the sorted array
is undefined.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> comparison function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_get_float">
<description>
Get the contents of a %G_TYPE_FLOAT #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_FLOAT
</parameter_description>
</parameter>
</parameters>
<return> float contents of @value
</return>
</function>

<function name="g_regex_get_max_backref">
<description>
Returns the number of the highest back reference
in the pattern, or 0 if the pattern does not contain
back references.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex
</parameter_description>
</parameter>
</parameters>
<return> the number of the highest back reference

</return>
</function>

<function name="g_static_rw_lock_writer_lock">
<description>
Locks @lock for writing. If @lock is already locked for writing or
reading by other threads, this function will block until @lock is
completely unlocked and then lock @lock for writing. While this
functions waits to lock @lock, no other thread can lock @lock for
reading. When @lock is locked for writing, no other thread can lock
@lock (neither for reading nor writing). This lock has to be
unlocked by g_static_rw_lock_writer_unlock().

</description>
<parameters>
<parameter name="lock">
<parameter_description> a #GStaticRWLock to lock for writing.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_set">
<description>
Sets properties on an object.

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="first_property_name">
<parameter_description> name of the first property to set
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> value for the first property, followed optionally by more
name/value pairs, followed by %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_regex_split_simple">
<description>
Breaks the string on the pattern, and returns an array of
the tokens. If the pattern contains capturing parentheses,
then the text for each of the substrings will also be returned.
If the pattern does not match anywhere in the string, then the
whole string is returned as the first token.

This function is equivalent to g_regex_split() but it does
not require to compile the pattern with g_regex_new(), avoiding
some lines of code when you need just to do a split without
extracting substrings, capture counts, and so on.

If this function is to be called on the same @pattern more than
once, it's more efficient to compile the pattern once with
g_regex_new() and then use g_regex_split().

As a special case, the result of splitting the empty string &quot;&quot;
is an empty vector, not a vector containing a single string.
The reason for this special case is that being able to represent
a empty vector is typically more useful than consistent handling
of empty elements. If you do need to represent empty elements,
you'll need to check for the empty string before calling this
function.

A pattern that can match empty strings splits @string into
separate characters wherever it matches the empty string between
characters. For example splitting &quot;ab c&quot; using as a separator
&quot;\s*&quot;, you will get &quot;a&quot;, &quot;b&quot; and &quot;c&quot;.

Since: 2.14

</description>
<parameters>
<parameter name="pattern">
<parameter_description> the regular expression
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to scan for matches
</parameter_description>
</parameter>
<parameter name="compile_options">
<parameter_description> compile options for the regular expression, or 0
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> match options, or 0
</parameter_description>
</parameter>
</parameters>
<return> a %NULL-terminated array of strings. Free it using g_strfreev()

</return>
</function>

<function name="g_test_minimized_result">
<description>
Report the result of a performance or measurement test.
The test should generally strive to minimize the reported
quantities (smaller values are better than larger ones),
this and @minimized_quantity can determine sorting
order for test result reports.

Since: 2.16

</description>
<parameters>
<parameter name="minimized_quantity">
<parameter_description> the reported value
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> the format string of the report message
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments to pass to the printf() function
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_create">
<description>
This function creates a new thread with the default priority.

If @joinable is %TRUE, you can wait for this threads termination
calling g_thread_join(). Otherwise the thread will just disappear
when it terminates.

The new thread executes the function @func with the argument @data.
If the thread was created successfully, it is returned.

@error can be %NULL to ignore errors, or non-%NULL to report errors.
The error is set, if and only if the function returns %NULL.

</description>
<parameters>
<parameter name="func">
<parameter_description> a function to execute in the new thread.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> an argument to supply to the new thread.
</parameter_description>
</parameter>
<parameter name="joinable">
<parameter_description> should this thread be joinable?
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for error.
</parameter_description>
</parameter>
</parameters>
<return> the new #GThread on success.
</return>
</function>

<function name="g_variant_get_boolean">
<description>
Returns the boolean value of @value.

It is an error to call this function with a @value of any type
other than %G_VARIANT_TYPE_BOOLEAN.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a boolean #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> %TRUE or %FALSE
</return>
</function>

<function name="g_object_is_floating">
<description>
Checks wether @object has a &lt;link linkend=&quot;floating-ref&quot;&gt;floating&lt;/link&gt;
reference.

Since: 2.10


</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @object has a floating reference
</return>
</function>

<function name="g_main_context_remove_poll">
<description>
Removes file descriptor from the set of file descriptors to be
polled for a particular context.

</description>
<parameters>
<parameter name="context">
<parameter_description>a #GMainContext 
</parameter_description>
</parameter>
<parameter name="fd">
<parameter_description> a #GPollFD descriptor previously added with g_main_context_add_poll()
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_private_set">
<description>
Sets the pointer keyed to @private_key for the current thread.

This function can be used even if g_thread_init() has not yet been
called, and, in that case, will set @private_key to @data casted to
#GPrivate*. See g_private_get() for resulting caveats.

</description>
<parameters>
<parameter name="private_key">
<parameter_description> a #GPrivate.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the new pointer.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_set_data">
<description>
Each object carries around a table of associations from
strings to pointers.  This function lets you set an association.

If the object already had an association with that name,
the old association will be destroyed.

</description>
<parameters>
<parameter name="object">
<parameter_description> #GObject containing the associations.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> name of the key
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to associate with that key
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_children_foreach">
<description>
Calls a function for each of the children of a #GNode.
Note that it doesn't descend beneath the child nodes.

</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> which types of children are to be visited, one of 
%G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each visited node
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> user data to pass to the function
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_byte_array_sized_new">
<description>
Creates a new #GByteArray with @reserved_size bytes preallocated.
This avoids frequent reallocation, if you are going to add many
bytes to the array. Note however that the size of the array is still
0.

</description>
<parameters>
<parameter name="reserved_size">
<parameter_description> number of bytes preallocated.
</parameter_description>
</parameter>
</parameters>
<return> the new #GByteArray.
</return>
</function>

<function name="g_win32_getlocale">
<description>
The setlocale() function in the Microsoft C library uses locale
names of the form &quot;English_United States.1252&quot; etc. We want the
UNIXish standard form &quot;en_US&quot;, &quot;zh_TW&quot; etc. This function gets the
current thread locale from Windows - without any encoding info -
and returns it as a string of the above form for use in forming
file names etc. The returned string should be deallocated with
g_free().


</description>
<parameters>
</parameters>
<return> newly-allocated locale name.
</return>
</function>

<function name="g_markup_parse_context_get_element">
<description>
Retrieves the name of the currently open element.

If called from the start_element or end_element handlers this will
give the element_name as passed to those functions. For the parent
elements, see g_markup_parse_context_get_element_stack().

Since: 2.2

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMarkupParseContext
</parameter_description>
</parameter>
</parameters>
<return> the name of the currently open element, or %NULL
</return>
</function>

<function name="g_mkdir_with_parents">
<description>
Create a directory if it doesn't already exist. Create intermediate
parent directories as needed, too.

Since: 2.8

</description>
<parameters>
<parameter name="pathname">
<parameter_description> a pathname in the GLib file name encoding
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> permissions to use for newly created directories
</parameter_description>
</parameter>
</parameters>
<return> 0 if the directory already exists, or was successfully
created. Returns -1 if an error occurred, with errno set.

</return>
</function>

<function name="g_regex_get_compile_flags">
<description>
Returns the compile options that @regex was created with.

Since: 2.26

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex
</parameter_description>
</parameter>
</parameters>
<return> flags from #GRegexCompileFlags

</return>
</function>

<function name="g_queue_copy">
<description>
Copies a @queue. Note that is a shallow copy. If the elements in the
queue consist of pointers to data, the pointers are copied, but the
actual data is not.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
</parameters>
<return> A copy of @queue

</return>
</function>

<function name="g_queue_sort">
<description>
Sorts @queue using @compare_func. 

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> the #GCompareDataFunc used to sort @queue. This function
is passed two elements of the queue and should return 0 if they are
equal, a negative value if the first comes before the second, and
a positive value if the second comes before the first.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data passed to @compare_func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_option_context_add_group">
<description>
Adds a #GOptionGroup to the @context, so that parsing with @context
will recognize the options in the group. Note that the group will
be freed together with the context when g_option_context_free() is
called, so you must not free the group yourself after adding it
to a context.

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="group">
<parameter_description> the group to add
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_unichar_isupper">
<description>
Determines if a character is uppercase.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @c is an uppercase character
</return>
</function>

<function name="g_variant_new_dict_entry">
<description>
Creates a new dictionary entry #GVariant.  @key and @value must be
non-%NULL.

@key must be a value of a basic type (ie: not a container).

Since: 2.24

</description>
<parameters>
<parameter name="key">
<parameter_description> a basic #GVariant, the key
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> a #GVariant, the value
</parameter_description>
</parameter>
</parameters>
<return> a new dictionary entry #GVariant
</return>
</function>

<function name="g_cclosure_marshal_VOID__FLOAT">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gfloat arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #gfloat parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_set_string">
<description>
Associates a new string value with @key under @group_name.  
If @key cannot be found then it is created.  
If @group_name cannot be found then it is created.
Unlike g_key_file_set_value(), this function handles characters
that need escaping, such as newlines.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> a string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_get_boolean_list">
<description>
Returns the values associated with @key under @group_name as
booleans. 

If @key cannot be found then %NULL is returned and @error is set to
#G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
with @key cannot be interpreted as booleans then %NULL is returned
and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the number of booleans returned
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> the values associated with the key as a list of
booleans, or %NULL if the key was not found or could not be parsed.

</return>
</function>

<function name="g_variant_get_type">
<description>
Determines the type of @value.

The return value is valid for the lifetime of @value and must not
be freed.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return> a #GVariantType
</return>
</function>

<function name="g_test_create_case">
<description>
Create a new #GTestCase, named @test_name, this API is fairly
low level, calling g_test_add() or g_test_add_func() is preferable.
When this test is executed, a fixture structure of size @data_size
will be allocated and filled with 0s. Then data_setup() is called
to initialize the fixture. After fixture setup, the actual test
function data_test() is called. Once the test run completed, the
fixture structure is torn down  by calling data_teardown() and
after that the memory is released.

Splitting up a test run into fixture setup, test function and
fixture teardown is most usful if the same fixture is used for
multiple tests. In this cases, g_test_create_case() will be
called with the same fixture, but varying @test_name and
@data_test arguments.

Since: 2.16

</description>
<parameters>
<parameter name="test_name">
<parameter_description>     the name for the test case
</parameter_description>
</parameter>
<parameter name="data_size">
<parameter_description>     the size of the fixture data structure
</parameter_description>
</parameter>
<parameter name="test_data">
<parameter_description>     test data argument for the test functions
</parameter_description>
</parameter>
<parameter name="data_setup">
<parameter_description>    the function to set up the fixture data
</parameter_description>
</parameter>
<parameter name="data_test">
<parameter_description>     the actual test function
</parameter_description>
</parameter>
<parameter name="data_teardown">
<parameter_description> the function to teardown the fixture data
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated #GTestCase.

</return>
</function>

<function name="g_markup_parse_context_get_user_data">
<description>
Returns the user_data associated with @context.  This will either
be the user_data that was provided to g_markup_parse_context_new()
or to the most recent call of g_markup_parse_context_push().

Since: 2.18

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMarkupParseContext
</parameter_description>
</parameter>
</parameters>
<return> the provided user_data. The returned data belongs to
the markup context and will be freed when g_markup_context_free()
is called.

</return>
</function>

<function name="g_variant_type_is_array">
<description>
Determines if the given @type is an array type.  This is true if the
type string for @type starts with an 'a'.

This function returns %TRUE for any indefinite type for which every
definite subtype is an array type -- %G_VARIANT_TYPE_ARRAY, for
example.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is an array type
</return>
</function>

<function name="g_value_array_get_nth">
<description>
Return a pointer to the value at @index_ containd in @value_array.


</description>
<parameters>
<parameter name="value_array">
<parameter_description> #GValueArray to get a value from
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> index of the value of interest
</parameter_description>
</parameter>
</parameters>
<return> pointer to a value at @index_ in @value_array
</return>
</function>

<function name="g_static_rec_mutex_trylock">
<description>
Tries to lock @mutex. If @mutex is already locked by another thread,
it immediately returns %FALSE. Otherwise it locks @mutex and returns
%TRUE. If @mutex is already locked by the calling thread, this
functions increases the depth of @mutex and immediately returns
%TRUE.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticRecMutex to lock.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE, if @mutex could be locked.
</return>
</function>

<function name="g_source_remove">
<description>
Removes the source with the given id from the default main context. 
The id of
a #GSource is given by g_source_get_id(), or will be returned by the
functions g_source_attach(), g_idle_add(), g_idle_add_full(),
g_timeout_add(), g_timeout_add_full(), g_child_watch_add(),
g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full().

See also g_source_destroy(). You must use g_source_destroy() for sources
added to a non-default main context.


</description>
<parameters>
<parameter name="tag">
<parameter_description> the ID of the source to remove.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the source was found and removed.
</return>
</function>

<function name="g_ptr_array_set_free_func">
<description>
Sets a function for freeing each element when @array is destroyed
either via g_ptr_array_unref(), when g_ptr_array_free() is called
with @free_segment set to %TRUE or when removing elements.

Since: 2.22

</description>
<parameters>
<parameter name="array">
<parameter_description> A #GPtrArray.
</parameter_description>
</parameter>
<parameter name="element_free_func">
<parameter_description> A function to free elements with destroy @array or %NULL.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_insert_sorted_with_data">
<description>
Inserts a new element into the list, using the given 
comparison function to determine its position.

Since: 2.10

</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to compare elements in the list. 
It should return a number &gt; 0 if the first parameter 
comes after the second parameter in the sort order.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> data to pass to comparison function
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GSList

</return>
</function>

<function name="g_strjoinv">
<description>
Joins a number of strings together to form one long string, with the 
optional @separator inserted between each of them. The returned string
should be freed with g_free().


</description>
<parameters>
<parameter name="separator">
<parameter_description> a string to insert between each of the strings, or %NULL
</parameter_description>
</parameter>
<parameter name="str_array">
<parameter_description> a %NULL-terminated array of strings to join
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string containing all of the strings joined
together, with @separator between them
</return>
</function>

<function name="g_key_file_set_comment">
<description>
Places a comment above @key from @group_name.
If @key is %NULL then @comment will be written above @group_name.  
If both @key and @group_name  are %NULL, then @comment will be 
written above the first group in the file.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name, or %NULL
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="comment">
<parameter_description> a comment
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the comment was written, %FALSE otherwise

</return>
</function>

<function name="g_type_class_add_private">
<description>
Registers a private structure for an instantiatable type;
when an object is allocated, the private structures for
the type and all of its parent types are allocated
sequentially in the same memory block as the public
structures. This function should be called in the
type's class_init() function. The private structure can
be retrieved using the G_TYPE_INSTANCE_GET_PRIVATE() macro.
The following example shows attaching a private structure
&lt;structname&gt;MyObjectPrivate&lt;/structname&gt; to an object
&lt;structname&gt;MyObject&lt;/structname&gt; defined in the standard GObject
fashion.
type's class_init() function.

|[
typedef struct _MyObject        MyObject;
typedef struct _MyObjectPrivate MyObjectPrivate;

struct _MyObject {
GObject parent;

MyObjectPrivate *priv;
};

struct _MyObjectPrivate {
int some_field;
};

static void
my_object_class_init (MyObjectClass *klass)
{
g_type_class_add_private (klass, sizeof (MyObjectPrivate));
}

static void
my_object_init (MyObject *my_object)
{
my_object-&gt;priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object,
MY_TYPE_OBJECT,
MyObjectPrivate);
}

static int
my_object_get_some_field (MyObject *my_object)
{
MyObjectPrivate *priv = my_object-&gt;priv;

return priv-&gt;some_field;
}
]|

Since: 2.4

</description>
<parameters>
<parameter name="g_class">
<parameter_description> class structure for an instantiatable type
</parameter_description>
</parameter>
<parameter name="private_size">
<parameter_description> size of private structure.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_quark_try_string">
<description>
Gets the #GQuark associated with the given string, or 0 if string is
%NULL or it has no associated #GQuark.

If you want the GQuark to be created if it doesn't already exist,
use g_quark_from_string() or g_quark_from_static_string().

</description>
<parameters>
<parameter name="string">
<parameter_description> a string.
</parameter_description>
</parameter>
</parameters>
<return> the #GQuark associated with the string, or 0 if @string is
%NULL or there is no #GQuark associated with it.
</return>
</function>

<function name="g_printf">
<description>
An implementation of the standard printf() function which supports 
positional parameters, as specified in the Single Unix Specification.

Since: 2.2

</description>
<parameters>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice 
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the arguments to insert in the output.
</parameter_description>
</parameter>
</parameters>
<return> the number of bytes printed.

</return>
</function>

<function name="g_queue_clear">
<description>
Removes all the elements in @queue. If queue elements contain
dynamically-allocated memory, they should be freed first.

Since: 2.14

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_setenv">
<description>
Sets an environment variable. Both the variable's name and value
should be in the GLib file name encoding. On UNIX, this means that
they can be any sequence of bytes. On Windows, they should be in
UTF-8.

Note that on some systems, when variables are overwritten, the memory 
used for the previous variables and its value isn't reclaimed.

Since: 2.4

</description>
<parameters>
<parameter name="variable">
<parameter_description> the environment variable to set, must not contain '='.
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> the value for to set the variable to.
</parameter_description>
</parameter>
<parameter name="overwrite">
<parameter_description> whether to change the variable if it already exists.
</parameter_description>
</parameter>
</parameters>
<return> %FALSE if the environment variable couldn't be set.

</return>
</function>

<function name="g_slist_insert">
<description>
Inserts a new element into the list at the given position.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
<parameter name="position">
<parameter_description> the position to insert the element. 
If this is negative, or is larger than the number 
of elements in the list, the new element is added on
to the end of the list.
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GSList
</return>
</function>

<function name="g_node_is_ancestor">
<description>
Returns %TRUE if @node is an ancestor of @descendant.
This is true if node is the parent of @descendant, 
or if node is the grandparent of @descendant etc.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
<parameter name="descendant">
<parameter_description> a #GNode
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @node is an ancestor of @descendant
</return>
</function>

<function name="g_convert_with_fallback">
<description>
Converts a string from one character set to another, possibly
including fallback sequences for characters not representable
in the output. Note that it is not guaranteed that the specification
for the fallback sequences in @fallback will be honored. Some
systems may do an approximate conversion from @from_codeset
to @to_codeset in their iconv() functions, 
in which case GLib will simply return that approximate conversion.

Note that you should use g_iconv() for streaming 
conversions&lt;footnoteref linkend=&quot;streaming-state&quot;/&gt;.


</description>
<parameters>
<parameter name="str">
<parameter_description>          the string to convert
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description>          the length of the string, or -1 if the string is 
nul-terminated&lt;footnoteref linkend=&quot;nul-unsafe&quot;/&gt;. 
</parameter_description>
</parameter>
<parameter name="to_codeset">
<parameter_description>   name of character set into which to convert @str
</parameter_description>
</parameter>
<parameter name="from_codeset">
<parameter_description> character set of @str.
</parameter_description>
</parameter>
<parameter name="fallback">
<parameter_description>     UTF-8 string to use in place of character not
present in the target encoding. (The string must be
representable in the target encoding). 
                  If %NULL, characters not in the target encoding will 
                  be represented as Unicode escapes \uxxxx or \Uxxxxyyyy.
</parameter_description>
</parameter>
<parameter name="bytes_read">
<parameter_description>   location to store the number of bytes in the
input string that were successfully converted, or %NULL.
Even if the conversion was successful, this may be 
less than @len if there were partial characters
at the end of the input.
</parameter_description>
</parameter>
<parameter name="bytes_written">
<parameter_description> the number of bytes stored in the output buffer (not 
including the terminating nul).
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description>        location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError may occur.
</parameter_description>
</parameter>
</parameters>
<return> If the conversion was successful, a newly allocated
nul-terminated string, which must be freed with
g_free(). Otherwise %NULL and @error will be set.
</return>
</function>

<function name="g_object_add_weak_pointer">
<description>
Adds a weak reference from weak_pointer to @object to indicate that
the pointer located at @weak_pointer_location is only valid during
the lifetime of @object. When the @object is finalized,
@weak_pointer will be set to %NULL.

</description>
<parameters>
<parameter name="object">
<parameter_description> The object that should be weak referenced.
</parameter_description>
</parameter>
<parameter name="weak_pointer_location">
<parameter_description> The memory address of a pointer.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_set_modified">
<description>
Sets the last time the bookmark for @uri was last modified.

If no bookmark for @uri is found then it is created.

The &quot;modified&quot; time should only be set when the bookmark's meta-data
was actually changed.  Every function of #GBookmarkFile that
modifies a bookmark also changes the modification time, except for
g_bookmark_file_set_visited().

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="modified">
<parameter_description> a timestamp or -1 to use the current time
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_value_array">
<description>
Creates a new #GParamSpecValueArray instance specifying a
%G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a
%G_TYPE_BOXED type, as such, #GValue structures for this property
can be accessed with g_value_set_boxed() and g_value_get_boxed().

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="element_spec">
<parameter_description> a #GParamSpec describing the elements contained in
arrays of this property, may be %NULL
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_completion_complete">
<description>
Attempts to complete the string @prefix using the #GCompletion
target items.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="cmp">
<parameter_description> the #GCompletion.
</parameter_description>
</parameter>
<parameter name="prefix">
<parameter_description> the prefix string, typically typed by the user, which is
compared with each of the items.
</parameter_description>
</parameter>
<parameter name="new_prefix">
<parameter_description> if non-%NULL, returns the longest prefix which is
common to all items that matched @prefix, or %NULL if
no items matched @prefix.  This string should be freed
when no longer needed.
</parameter_description>
</parameter>
</parameters>
<return> the list of items whose strings begin with @prefix. This
should not be changed.
</return>
</function>

<function name="g_string_ascii_down">
<description>
Converts all upper case ASCII letters to lower case ASCII letters.


</description>
<parameters>
<parameter name="string">
<parameter_description> a GString
</parameter_description>
</parameter>
</parameters>
<return> passed-in @string pointer, with all the upper case
characters converted to lower case in place, with
semantics that exactly match g_ascii_tolower().
</return>
</function>

<function name="g_bookmark_file_get_icon">
<description>
Gets the icon of the bookmark for @uri.

In the event the URI cannot be found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="href">
<parameter_description> return location for the icon's location or %NULL
</parameter_description>
</parameter>
<parameter name="mime_type">
<parameter_description> return location for the icon's MIME type or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the icon for the bookmark for the URI was found.
You should free the returned strings.

</return>
</function>

<function name="g_strdup">
<description>
Duplicates a string. If @str is %NULL it returns %NULL.
The returned string should be freed with g_free() 
when no longer needed.


</description>
<parameters>
<parameter name="str">
<parameter_description> the string to duplicate
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated copy of @str
</return>
</function>

<function name="g_thread_get_initialized">
<description>
Indicates if g_thread_init() has been called.

Since: 2.20

</description>
<parameters>
</parameters>
<return> %TRUE if threads have been initialized.

</return>
</function>

<function name="g_rand_set_seed">
<description>
Sets the seed for the random number generator #GRand to @seed.

</description>
<parameters>
<parameter name="rand_">
<parameter_description> a #GRand.
</parameter_description>
</parameter>
<parameter name="seed">
<parameter_description> a value to reinitialize the random number generator.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_array_free">
<description>
Free a #GValueArray including its contents.

</description>
<parameters>
<parameter name="value_array">
<parameter_description> #GValueArray to free
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_bind_property_full">
<description>
Complete version of g_object_bind_property().

Creates a binding between @source_property on @source and @target_property
on @target, allowing you to set the transformation functions to be used by
the binding.

If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
if @target_property on @target changes then the @source_property on @source
will be updated as well. The @transform_from function is only used in case
of bidirectional bindings, otherwise it will be ignored

The binding will automatically be removed when either the @source or the
@target instances are finalized. To remove the binding without affecting the
@source and the @target you can just call g_object_unref() on the returned
#GBinding instance.

A #GObject can have multiple bindings.

&lt;note&gt;The same @user_data parameter will be used for both @transform_to
and @transform_from transformation functions; the @notify function will
be called once, when the binding is removed. If you need different data
for each transformation function, please use
g_object_bind_property_with_closures() instead.&lt;/note&gt;

Since: 2.26

</description>
<parameters>
<parameter name="source">
<parameter_description> the source #GObject
</parameter_description>
</parameter>
<parameter name="source_property">
<parameter_description> the property on @source to bind
</parameter_description>
</parameter>
<parameter name="target">
<parameter_description> the target #GObject
</parameter_description>
</parameter>
<parameter name="target_property">
<parameter_description> the property on @target to bind
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags to pass to #GBinding
</parameter_description>
</parameter>
<parameter name="transform_to">
<parameter_description> the transformation function
from the @source to the @target, or %NULL to use the default
</parameter_description>
</parameter>
<parameter name="transform_from">
<parameter_description> the transformation function
from the @target to the @source, or %NULL to use the default
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> custom data to be passed to the transformation functions,
or %NULL
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description> function to be called when disposing the binding, to free the
resources used by the transformation functions
</parameter_description>
</parameter>
</parameters>
<return> the #GBinding instance representing the
binding between the two #GObject instances. The binding is released
whenever the #GBinding reference count reaches zero.

</return>
</function>

<function name="g_object_get_data">
<description>
Gets a named field from the objects table of associations (see g_object_set_data()).


</description>
<parameters>
<parameter name="object">
<parameter_description> #GObject containing the associations
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> name of the key for that association
</parameter_description>
</parameter>
</parameters>
<return> the data if found, or %NULL if no such data exists.
</return>
</function>

<function name="g_key_file_get_keys">
<description>
Returns all keys for the group name @group_name.  The array of
returned keys will be %NULL-terminated, so @length may
optionally be %NULL. In the event that the @group_name cannot
be found, %NULL is returned and @error is set to
#G_KEY_FILE_ERROR_GROUP_NOT_FOUND.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> return location for the number of keys returned, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated %NULL-terminated array of strings. 
Use g_strfreev() to free it.

</return>
</function>

<function name="g_value_set_uchar">
<description>
Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_UCHAR
</parameter_description>
</parameter>
<parameter name="v_uchar">
<parameter_description> unsigned character value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_mem_is_system_malloc">
<description>
Checks whether the allocator used by g_malloc() is the system's
malloc implementation. If it returns %TRUE memory allocated with
malloc() can be used interchangeable with memory allocated using g_malloc(). 
This function is useful for avoiding an extra copy of allocated memory returned
by a non-GLib-based API.

A different allocator can be set using g_mem_set_vtable().


</description>
<parameters>
</parameters>
<return> if %TRUE, malloc() and g_malloc() can be mixed.
</return>
</function>

<function name="g_mem_chunk_alloc">
<description>
Allocates an atom of memory from a #GMemChunk.

Deprecated:2.10: Use g_slice_alloc() instead

</description>
<parameters>
<parameter name="mem_chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the allocated atom.
</return>
</function>

<function name="g_parse_debug_string">
<description>
Parses a string containing debugging options
into a %guint containing bit flags. This is used 
within GDK and GTK+ to parse the debug options passed on the
command line or through environment variables.

If @string is equal to &quot;all&quot;, all flags are set.  If @string
is equal to &quot;help&quot;, all the available keys in @keys are printed
out to standard error.


</description>
<parameters>
<parameter name="string">
<parameter_description> a list of debug options separated by colons, spaces, or
commas, or %NULL.
</parameter_description>
</parameter>
<parameter name="keys">
<parameter_description> pointer to an array of #GDebugKey which associate 
strings with bit flags.
</parameter_description>
</parameter>
<parameter name="nkeys">
<parameter_description> the number of #GDebugKey&lt;!-- --&gt;s in the array.
</parameter_description>
</parameter>
</parameters>
<return> the combined set of bit flags.
</return>
</function>

<function name="g_static_mutex_init">
<description>
Initializes @mutex. Alternatively you can initialize it with
#G_STATIC_MUTEX_INIT.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticMutex to be initialized.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_get_nick">
<description>
Get the nickname of a #GParamSpec.


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
</parameters>
<return> the nickname of @pspec.
</return>
</function>

<function name="g_object_force_floating">
<description>
This function is intended for #GObject implementations to re-enforce a
&lt;link linkend=&quot;floating-ref&quot;&gt;floating&lt;/link&gt; object reference.
Doing this is seldomly required, all
#GInitiallyUnowned&lt;!-- --&gt;s are created with a floating reference which
usually just needs to be sunken by calling g_object_ref_sink().

Since: 2.10

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_pointer_type_register_static">
<description>
Creates a new %G_TYPE_POINTER derived type id for a new
pointer type with name @name.


</description>
<parameters>
<parameter name="name">
<parameter_description> the name of the new pointer type.
</parameter_description>
</parameter>
</parameters>
<return> a new %G_TYPE_POINTER derived type id for @name.
</return>
</function>

<function name="g_hash_table_iter_remove">
<description>
Removes the key/value pair currently pointed to by the iterator
from its associated #GHashTable. Can only be called after
g_hash_table_iter_next() returned %TRUE, and cannot be called more
than once for the same key/value pair.

If the #GHashTable was created using g_hash_table_new_full(), the
key and value are freed using the supplied destroy functions, otherwise
you have to make sure that any dynamically allocated values are freed 
yourself.

Since: 2.16

</description>
<parameters>
<parameter name="iter">
<parameter_description> an initialized #GHashTableIter.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_double_equal">
<description>
Compares the two #gdouble values being pointed to and returns 
%TRUE if they are equal.
It can be passed to g_hash_table_new() as the @key_equal_func
parameter, when using pointers to doubles as keys in a #GHashTable.

Since: 2.22

</description>
<parameters>
<parameter name="v1">
<parameter_description> a pointer to a #gdouble key.
</parameter_description>
</parameter>
<parameter name="v2">
<parameter_description> a pointer to a #gdouble key to compare with @v1.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the two keys match.

</return>
</function>

<function name="g_closure_add_marshal_guards">
<description>
Adds a pair of notifiers which get invoked before and after the
closure callback, respectively. This is typically used to protect
the extra arguments for the duration of the callback. See
g_object_watch_closure() for an example of marshal guards.

</description>
<parameters>
<parameter name="closure">
<parameter_description> a #GClosure
</parameter_description>
</parameter>
<parameter name="pre_marshal_data">
<parameter_description> data to pass to @pre_marshal_notify
</parameter_description>
</parameter>
<parameter name="pre_marshal_notify">
<parameter_description> a function to call before the closure callback
</parameter_description>
</parameter>
<parameter name="post_marshal_data">
<parameter_description> data to pass to @post_marshal_notify
</parameter_description>
</parameter>
<parameter name="post_marshal_notify">
<parameter_description> a function to call after the closure callback
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_get_uint">
<description>
Get the contents of a %G_TYPE_UINT #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_UINT
</parameter_description>
</parameter>
</parameters>
<return> unsigned integer contents of @value
</return>
</function>

<function name="g_node_traverse">
<description>
Traverses a tree starting at the given root #GNode.
It calls the given function for each node visited.
The traversal can be halted at any point by returning %TRUE from @func.

</description>
<parameters>
<parameter name="root">
<parameter_description> the root #GNode of the tree to traverse
</parameter_description>
</parameter>
<parameter name="order">
<parameter_description> the order in which nodes are visited - %G_IN_ORDER, 
%G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER.
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> which types of children are to be visited, one of 
%G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
</parameter_description>
</parameter>
<parameter name="max_depth">
<parameter_description> the maximum depth of the traversal. Nodes below this
depth will not be visited. If max_depth is -1 all nodes in 
the tree are visited. If depth is 1, only the root is visited. 
If depth is 2, the root and its children are visited. And so on.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each visited #GNode
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> user data to pass to the function
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_get_user_cache_dir">
<description>
Returns a base directory in which to store non-essential, cached
data specific to particular user.

On UNIX platforms this is determined using the mechanisms described in
the &lt;ulink url=&quot;http://www.freedesktop.org/Standards/basedir-spec&quot;&gt;
XDG Base Directory Specification&lt;/ulink&gt;.
In this case the directory retrieved will be XDG_CACHE_HOME.

On Windows is the directory that serves as a common repository for
temporary Internet files. A typical path is
C:\Documents and Settings\username\Local Settings\Temporary Internet Files.
See documentation for CSIDL_INTERNET_CACHE.

Since: 2.6

</description>
<parameters>
</parameters>
<return> a string owned by GLib that must not be modified 
or freed.
</return>
</function>

<function name="g_markup_parse_context_get_position">
<description>
Retrieves the current line number and the number of the character on
that line. Intended for use in error messages; there are no strict
semantics for what constitutes the &quot;current&quot; line number other than
&quot;the best number we could come up with for error messages.&quot;


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMarkupParseContext
</parameter_description>
</parameter>
<parameter name="line_number">
<parameter_description> return location for a line number, or %NULL
</parameter_description>
</parameter>
<parameter name="char_number">
<parameter_description> return location for a char-on-line number, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_pool_set_max_idle_time">
<description>
This function will set the maximum @interval that a thread waiting
in the pool for new tasks can be idle for before being
stopped. This function is similar to calling
g_thread_pool_stop_unused_threads() on a regular timeout, except,
this is done on a per thread basis.    

By setting @interval to 0, idle threads will not be stopped.

This function makes use of g_async_queue_timed_pop () using
@interval.

Since: 2.10

</description>
<parameters>
<parameter name="interval">
<parameter_description> the maximum @interval (1/1000ths of a second) a thread
can be idle. 
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_print">
<description>
Pretty-prints @value in the format understood by g_variant_parse().

If @type_annotate is %TRUE, then type information is included in
the output.

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
<parameter name="type_annotate">
<parameter_description> %TRUE if type information should be included in
the output
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated string holding the result.
</return>
</function>

<function name="g_io_channel_get_flags">
<description>
Gets the current flags for a #GIOChannel, including read-only
flags such as %G_IO_FLAG_IS_READABLE.

The values of the flags %G_IO_FLAG_IS_READABLE and %G_IO_FLAG_IS_WRITEABLE
are cached for internal use by the channel when it is created.
If they should change at some later point (e.g. partial shutdown
of a socket with the UNIX shutdown() function), the user
should immediately call g_io_channel_get_flags() to update
the internal values of these flags.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
</parameters>
<return> the flags which are set on the channel
</return>
</function>

<function name="g_string_printf">
<description>
Writes a formatted string into a #GString.
This is similar to the standard sprintf() function,
except that the #GString buffer automatically expands 
to contain the results. The previous contents of the 
#GString are destroyed.

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> the string format. See the printf() documentation
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the parameters to insert into the format string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_win32_get_package_installation_subdirectory">
<description>
This function is deprecated. Use
g_win32_get_package_installation_directory_of_module() and
g_build_filename() instead.

Deprecated: 2.18: Pass the HMODULE of a DLL or EXE to
g_win32_get_package_installation_directory_of_module() instead, and
then construct a subdirectory pathname with g_build_filename().

</description>
<parameters>
<parameter name="package">
<parameter_description> You should pass %NULL for this.
</parameter_description>
</parameter>
<parameter name="dll_name">
<parameter_description> The name of a DLL that a package provides, in UTF-8, or %NULL.
</parameter_description>
</parameter>
<parameter name="subdir">
<parameter_description> A subdirectory of the package installation directory, also in UTF-8
</parameter_description>
</parameter>
</parameters>
<return> a string containing the complete path to @subdir inside
the installation directory of @package. The returned string is in
the GLib file name encoding, i.e. UTF-8. The return value should be
freed with g_free() when no longer needed. If something goes wrong,
%NULL is returned.

</return>
</function>

<function name="g_signal_stop_emission">
<description>
Stops a signal's current emission.

This will prevent the default method from running, if the signal was
%G_SIGNAL_RUN_LAST and you connected normally (i.e. without the &quot;after&quot;
flag).

Prints a warning if used on a signal which isn't being emitted.

</description>
<parameters>
<parameter name="instance">
<parameter_description> the object whose signal handlers you wish to stop.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> the signal identifier, as returned by g_signal_lookup().
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> the detail which the signal was emitted with.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_long">
<description>
Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_value_set_object_take_ownership">
<description>
This is an internal function introduced mainly for C marshallers.

Deprecated: 2.4: Use g_value_take_object() instead.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_OBJECT derived type
</parameter_description>
</parameter>
<parameter name="v_object">
<parameter_description> object value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_insert_before">
<description>
Inserts a new element into the list before the given position.


</description>
<parameters>
<parameter name="list">
<parameter_description> a pointer to a #GList
</parameter_description>
</parameter>
<parameter name="sibling">
<parameter_description> the list element before which the new element 
is inserted or %NULL to insert at the end of the list
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GList
</return>
</function>

<function name="g_get_user_name">
<description>
Gets the user name of the current user. The encoding of the returned
string is system-defined. On UNIX, it might be the preferred file name
encoding, or something else, and there is no guarantee that it is even
consistent on a machine. On Windows, it is always UTF-8.


</description>
<parameters>
</parameters>
<return> the user name of the current user.
</return>
</function>

<function name="g_type_plugin_use">
<description>
Calls the @use_plugin function from the #GTypePluginClass of
@plugin.  There should be no need to use this function outside of
the GObject type system itself.

</description>
<parameters>
<parameter name="plugin">
<parameter_description> a #GTypePlugin
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_add_interface_static">
<description>
Adds the static @interface_type to @instantiable_type.  The information
contained in the #GTypeInterfaceInfo structure pointed to by @info
is used to manage the relationship.

</description>
<parameters>
<parameter name="instance_type">
<parameter_description> #GType value of an instantiable type.
</parameter_description>
</parameter>
<parameter name="interface_type">
<parameter_description> #GType value of an interface type.
</parameter_description>
</parameter>
<parameter name="info">
<parameter_description> The #GInterfaceInfo structure for this
(@instance_type, @interface_type) combination.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_is_container">
<description>
Checks if @value is a container.

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @value is a container
</return>
</function>

<function name="g_queue_peek_nth_link">
<description>
Returns the link at the given position

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position of the link
</parameter_description>
</parameter>
</parameters>
<return> The link at the @n'th position, or %NULL if @n is off the
end of the list

</return>
</function>

<function name="g_io_channel_unix_new">
<description>
Creates a new #GIOChannel given a file descriptor. On UNIX systems
this works for plain files, pipes, and sockets.

The returned #GIOChannel has a reference count of 1.

The default encoding for #GIOChannel is UTF-8. If your application
is reading output from a command using via pipe, you may need to set
the encoding to the encoding of the current locale (see
g_get_charset()) with the g_io_channel_set_encoding() function.

If you want to read raw binary data without interpretation, then
call the g_io_channel_set_encoding() function with %NULL for the
encoding argument.

This function is available in GLib on Windows, too, but you should
avoid using it on Windows. The domain of file descriptors and
sockets overlap. There is no way for GLib to know which one you mean
in case the argument you pass to this function happens to be both a
valid file descriptor and socket. If that happens a warning is
issued, and GLib assumes that it is the file descriptor you mean.

</description>
<parameters>
<parameter name="fd">
<parameter_description> a file descriptor.
</parameter_description>
</parameter>
</parameters>
<return> a new #GIOChannel.
</return>
</function>

<function name="g_param_spec_int">
<description>
Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_closure_invoke">
<description>
Invokes the closure, i.e. executes the callback represented by the @closure.

</description>
<parameters>
<parameter name="closure">
<parameter_description> a #GClosure
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> a #GValue to store the return value. May be %NULL if the
callback of @closure doesn't return a value.
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> the length of the @param_values array
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> an array of #GValue&lt;!-- --&gt;s holding the arguments on
which to invoke the callback of @closure
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> a context-dependent invocation hint
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cclosure_marshal_VOID__ULONG">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gulong arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #gulong parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_copy">
<description>
Recursively copies a #GNode (but does not deep-copy the data inside the 
nodes, see g_node_copy_deep() if you need that).


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
</parameters>
<return> a new #GNode containing the same data pointers
</return>
</function>

<function name="g_chdir">
<description>
A wrapper for the POSIX chdir() function. The function changes the
current directory of the process to @path.

See your C library manual for more details about chdir().

Since: 2.8

</description>
<parameters>
<parameter name="path">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
</parameters>
<return> 0 on success, -1 if an error occurred.

</return>
</function>

<function name="g_cclosure_marshal_VOID__INT">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gint arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #gint parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_source_remove_by_funcs_user_data">
<description>
Removes a source from the default main loop context given the
source functions and user data. If multiple sources exist with the
same source functions and user data, only one will be destroyed.


</description>
<parameters>
<parameter name="funcs">
<parameter_description> The @source_funcs passed to g_source_new()
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> the user data for the callback
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a source was found and removed. 
</return>
</function>

<function name="g_object_connect">
<description>
A convenience function to connect multiple signals at once.

The signal specs expected by this function have the form
&quot;modifier::signal_name&quot;, where modifier can be one of the following:
&lt;variablelist&gt;
&lt;varlistentry&gt;
&lt;term&gt;signal&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
equivalent to &lt;literal&gt;g_signal_connect_data (..., NULL, 0)&lt;/literal&gt;
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;object_signal&lt;/term&gt;
&lt;term&gt;object-signal&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
equivalent to &lt;literal&gt;g_signal_connect_object (..., 0)&lt;/literal&gt;
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;swapped_signal&lt;/term&gt;
&lt;term&gt;swapped-signal&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
equivalent to &lt;literal&gt;g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED)&lt;/literal&gt;
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;swapped_object_signal&lt;/term&gt;
&lt;term&gt;swapped-object-signal&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
equivalent to &lt;literal&gt;g_signal_connect_object (..., G_CONNECT_SWAPPED)&lt;/literal&gt;
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;signal_after&lt;/term&gt;
&lt;term&gt;signal-after&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
equivalent to &lt;literal&gt;g_signal_connect_data (..., NULL, G_CONNECT_AFTER)&lt;/literal&gt;
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;object_signal_after&lt;/term&gt;
&lt;term&gt;object-signal-after&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
equivalent to &lt;literal&gt;g_signal_connect_object (..., G_CONNECT_AFTER)&lt;/literal&gt;
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;swapped_signal_after&lt;/term&gt;
&lt;term&gt;swapped-signal-after&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
equivalent to &lt;literal&gt;g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED | G_CONNECT_AFTER)&lt;/literal&gt;
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;varlistentry&gt;
&lt;term&gt;swapped_object_signal_after&lt;/term&gt;
&lt;term&gt;swapped-object-signal-after&lt;/term&gt;
&lt;listitem&gt;&lt;para&gt;
equivalent to &lt;literal&gt;g_signal_connect_object (..., G_CONNECT_SWAPPED | G_CONNECT_AFTER)&lt;/literal&gt;
&lt;/para&gt;&lt;/listitem&gt;
&lt;/varlistentry&gt;
&lt;/variablelist&gt;

|[
menu-&gt;toplevel = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
&quot;type&quot;, GTK_WINDOW_POPUP,
&quot;child&quot;, menu,
NULL),
&quot;signal::event&quot;, gtk_menu_window_event, menu,
&quot;signal::size_request&quot;, gtk_menu_window_size_request, menu,
&quot;signal::destroy&quot;, gtk_widget_destroyed, &amp;menu-&gt;toplevel,
NULL);
]|


</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="signal_spec">
<parameter_description> the spec for the first signal
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> #GCallback for the first signal, followed by data for the
first signal, followed optionally by more signal
spec/callback/data triples, followed by %NULL
</parameter_description>
</parameter>
</parameters>
<return> @object
</return>
</function>

<function name="g_cclosure_marshal_VOID__LONG">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, glong arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #glong parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_main_context_find_source_by_id">
<description>
Finds a #GSource given a pair of context and ID.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext (if %NULL, the default context will be used)
</parameter_description>
</parameter>
<parameter name="source_id">
<parameter_description> the source ID, as returned by g_source_get_id(). 
</parameter_description>
</parameter>
</parameters>
<return> the #GSource if found, otherwise, %NULL
</return>
</function>

<function name="g_main_context_prepare">
<description>
Prepares to poll sources within a main loop. The resulting information
for polling is determined by calling g_main_context_query ().


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
<parameter name="priority">
<parameter_description> location to store priority of highest priority
source already ready.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if some source is ready to be dispatched
prior to polling.
</return>
</function>

<function name="g_type_fundamental">
<description>
Internal function, used to extract the fundamental type ID portion.
use G_TYPE_FUNDAMENTAL() instead.


</description>
<parameters>
<parameter name="type_id">
<parameter_description> valid type ID
</parameter_description>
</parameter>
</parameters>
<return> fundamental type ID
</return>
</function>

<function name="g_node_prepend">
<description>
Inserts a #GNode as the first child of the given parent.


</description>
<parameters>
<parameter name="parent">
<parameter_description> the #GNode to place the new #GNode under
</parameter_description>
</parameter>
<parameter name="node">
<parameter_description> the #GNode to insert
</parameter_description>
</parameter>
</parameters>
<return> the inserted #GNode
</return>
</function>

<function name="g_async_queue_timed_pop_unlocked">
<description>
Pops data from the @queue. If no data is received before @end_time,
%NULL is returned. This function must be called while holding the
@queue's lock.

To easily calculate @end_time a combination of g_get_current_time()
and g_time_val_add() can be used.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
<parameter name="end_time">
<parameter_description> a #GTimeVal, determining the final time.
</parameter_description>
</parameter>
</parameters>
<return> data from the queue or %NULL, when no data is
received before @end_time.
</return>
</function>

<function name="g_key_file_set_integer">
<description>
Associates a new integer value with @key under @group_name.
If @key cannot be found then it is created.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> an integer value
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_get_codeset">
<description>
Get the codeset for the current locale.


</description>
<parameters>
</parameters>
<return> a newly allocated string containing the name
of the codeset. This string must be freed with g_free().
</return>
</function>

<function name="g_vasprintf">
<description>
An implementation of the GNU vasprintf() function which supports 
positional parameters, as specified in the Single Unix Specification.
This function is similar to g_vsprintf(), except that it allocates a 
string to hold the output, instead of putting the output in a buffer 
you allocate in advance.

Since: 2.4

</description>
<parameters>
<parameter name="string">
<parameter_description> the return location for the newly-allocated string.
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;.
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> the list of arguments to insert in the output.
</parameter_description>
</parameter>
</parameters>
<return> the number of bytes printed.

</return>
</function>

<function name="g_value_transform">
<description>
Tries to cast the contents of @src_value into a type appropriate
to store in @dest_value, e.g. to transform a %G_TYPE_INT value
into a %G_TYPE_FLOAT value. Performing transformations between
value types might incur precision lossage. Especially
transformations into strings might reveal seemingly arbitrary
results and shouldn't be relied upon for production code (such
as rcfile value or object property serialization).


</description>
<parameters>
<parameter name="src_value">
<parameter_description> Source value.
</parameter_description>
</parameter>
<parameter name="dest_value">
<parameter_description> Target value.
</parameter_description>
</parameter>
</parameters>
<return> Whether a transformation rule was found and could be applied.
Upon failing transformations, @dest_value is left untouched.
</return>
</function>

<function name="g_key_file_get_comment">
<description>
Retrieves a comment above @key from @group_name.
If @key is %NULL then @comment will be read from above 
@group_name. If both @key and @group_name are %NULL, then 
@comment will be read from above the first group in the file.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name, or %NULL
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> a comment that should be freed with g_free()

</return>
</function>

<function name="g_regex_get_match_flags">
<description>
Returns the match options that @regex was created with.

Since: 2.26

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex
</parameter_description>
</parameter>
</parameters>
<return> flags from #GRegexMatchFlags

</return>
</function>

<function name="g_utf16_to_ucs4">
<description>
Convert a string from UTF-16 to UCS-4. The result will be
nul-terminated.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-16 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length (number of &lt;type&gt;gunichar2&lt;/type&gt;) of @str to use. 
If @len &lt; 0, then the string is nul-terminated.
</parameter_description>
</parameter>
<parameter name="items_read">
<parameter_description> location to store number of words read, or %NULL.
If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be
returned in case @str contains a trailing partial
character. If an error occurs then the index of the
invalid input is stored here.
</parameter_description>
</parameter>
<parameter name="items_written">
<parameter_description> location to store number of characters written, or %NULL.
The value stored here does not include the trailing
0 character.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError other than
%G_CONVERT_ERROR_NO_CONVERSION may occur.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to a newly allocated UCS-4 string.
This value must be freed with g_free(). If an
error occurs, %NULL will be returned and
@error set.
</return>
</function>

<function name="g_hash_table_iter_steal">
<description>
Removes the key/value pair currently pointed to by the iterator
from its associated #GHashTable, without calling the key and value
destroy functions. Can only be called after
g_hash_table_iter_next() returned %TRUE, and cannot be called more
than once for the same key/value pair.

Since: 2.16

</description>
<parameters>
<parameter name="iter">
<parameter_description> an initialized #GHashTableIter.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_new">
<description>
Creates a new #GQueue. 


</description>
<parameters>
</parameters>
<return> a new #GQueue.
</return>
</function>

<function name="g_source_add_poll">
<description>
Adds a file descriptor to the set of file descriptors polled for
this source. This is usually combined with g_source_new() to add an
event source. The event source's check function will typically test
the @revents field in the #GPollFD struct and return %TRUE if events need
to be processed.

</description>
<parameters>
<parameter name="source">
<parameter_description>a #GSource 
</parameter_description>
</parameter>
<parameter name="fd">
<parameter_description> a #GPollFD structure holding information about a file
descriptor to watch.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_reload_user_special_dirs_cache">
<description>
Resets the cache used for g_get_user_special_dir(), so
that the latest on-disk version is used. Call this only
if you just changed the data on disk yourself.

Due to threadsafety issues this may cause leaking of strings
that were previously returned from g_get_user_special_dir()
that can't be freed. We ensure to only leak the data for
the directories that actually changed value though.

Since: 2.22

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_queue_pop_tail_link">
<description>
Removes the last element of the queue.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
</parameters>
<return> the #GList element at the tail of the queue, or %NULL if the queue
is empty.
</return>
</function>

<function name="g_path_skip_root">
<description>
Returns a pointer into @file_name after the root component, i.e. after
the &quot;/&quot; in UNIX or &quot;C:\&quot; under Windows. If @file_name is not an absolute
path it returns %NULL.


</description>
<parameters>
<parameter name="file_name">
<parameter_description> a file name.
</parameter_description>
</parameter>
</parameters>
<return> a pointer into @file_name after the root component.
</return>
</function>

<function name="g_cclosure_marshal_BOOL__FLAGS">
<description>
Another name for g_cclosure_marshal_BOOLEAN__FLAGS().

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_option_context_get_help_enabled">
<description>
Returns whether automatic &lt;option&gt;--help&lt;/option&gt; generation
is turned on for @context. See g_option_context_set_help_enabled().

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if automatic help generation is turned on.

</return>
</function>

<function name="g_object_set_qdata_full">
<description>
This function works like g_object_set_qdata(), but in addition,
a void (*destroy) (gpointer) function may be specified which is
called with @data as argument when the @object is finalized, or
the data is being overwritten by a call to g_object_set_qdata()
with the same @quark.

</description>
<parameters>
<parameter name="object">
<parameter_description> The GObject to set store a user data pointer
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> A #GQuark, naming the user data pointer
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> An opaque user data pointer
</parameter_description>
</parameter>
<parameter name="destroy">
<parameter_description> Function to invoke with @data as argument, when @data
needs to be freed
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_set_prgname">
<description>
Sets the name of the program. This name should &lt;emphasis&gt;not&lt;/emphasis&gt; 
be localized, contrast with g_set_application_name(). Note that for 
thread-safety reasons this function can only be called once.

</description>
<parameters>
<parameter name="prgname">
<parameter_description> the name of the program.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_newv">
<description>
Creates a new instance of a #GObject subtype and sets its properties.

Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY)
which are not explicitly specified are set to their default values.


</description>
<parameters>
<parameter name="object_type">
<parameter_description> the type id of the #GObject subtype to instantiate
</parameter_description>
</parameter>
<parameter name="n_parameters">
<parameter_description> the length of the @parameters array
</parameter_description>
</parameter>
<parameter name="parameters">
<parameter_description> an array of #GParameter
</parameter_description>
</parameter>
</parameters>
<return> a new instance of @object_type
</return>
</function>

<function name="g_spawn_async_with_pipes">
<description>
Executes a child program asynchronously (your program will not
block waiting for the child to exit). The child program is
specified by the only argument that must be provided, @argv. @argv
should be a %NULL-terminated array of strings, to be passed as the
argument vector for the child. The first string in @argv is of
course the name of the program to execute. By default, the name of
the program must be a full path; the &lt;envar&gt;PATH&lt;/envar&gt; shell variable 
will only be searched if you pass the %G_SPAWN_SEARCH_PATH flag.

On Windows, note that all the string or string vector arguments to
this function and the other g_spawn*() functions are in UTF-8, the
GLib file name encoding. Unicode characters that are not part of
the system codepage passed in these arguments will be correctly
available in the spawned program only if it uses wide character API
to retrieve its command line. For C programs built with Microsoft's
tools it is enough to make the program have a wmain() instead of
main(). wmain() has a wide character argument vector as parameter.

At least currently, mingw doesn't support wmain(), so if you use
mingw to develop the spawned program, it will have to call the
undocumented function __wgetmainargs() to get the wide character
argument vector and environment. See gspawn-win32-helper.c in the
GLib sources or init.c in the mingw runtime sources for a prototype
for that function. Alternatively, you can retrieve the Win32 system
level wide character command line passed to the spawned program
using the GetCommandLineW() function.

On Windows the low-level child process creation API
&lt;function&gt;CreateProcess()&lt;/function&gt; doesn't use argument vectors,
but a command line. The C runtime library's
&lt;function&gt;spawn*()&lt;/function&gt; family of functions (which
g_spawn_async_with_pipes() eventually calls) paste the argument
vector elements together into a command line, and the C runtime startup code
does a corresponding reconstruction of an argument vector from the
command line, to be passed to main(). Complications arise when you have
argument vector elements that contain spaces of double quotes. The
&lt;function&gt;spawn*()&lt;/function&gt; functions don't do any quoting or
escaping, but on the other hand the startup code does do unquoting
and unescaping in order to enable receiving arguments with embedded
spaces or double quotes. To work around this asymmetry,
g_spawn_async_with_pipes() will do quoting and escaping on argument
vector elements that need it before calling the C runtime
spawn() function.

The returned @child_pid on Windows is a handle to the child
process, not its identifier. Process handles and process
identifiers are different concepts on Windows.

@envp is a %NULL-terminated array of strings, where each string
has the form &lt;literal&gt;KEY=VALUE&lt;/literal&gt;. This will become
the child's environment. If @envp is %NULL, the child inherits its
parent's environment.

@flags should be the bitwise OR of any flags you want to affect the
function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that 
the child will not automatically be reaped; you must use a
#GChildWatch source to be notified about the death of the child 
process. Eventually you must call g_spawn_close_pid() on the
@child_pid, in order to free resources which may be associated
with the child process. (On Unix, using a #GChildWatch source is
equivalent to calling waitpid() or handling the %SIGCHLD signal 
manually. On Windows, calling g_spawn_close_pid() is equivalent
to calling CloseHandle() on the process handle returned in 
@child_pid).

%G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that the parent's open file
descriptors will be inherited by the child; otherwise all
descriptors except stdin/stdout/stderr will be closed before
calling exec() in the child. %G_SPAWN_SEARCH_PATH 
means that &lt;literal&gt;argv[0]&lt;/literal&gt; need not be an absolute path, it
will be looked for in the user's &lt;envar&gt;PATH&lt;/envar&gt;. 
%G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output will 
be discarded, instead of going to the same location as the parent's 
standard output. If you use this flag, @standard_output must be %NULL.
%G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error
will be discarded, instead of going to the same location as the parent's
standard error. If you use this flag, @standard_error must be %NULL.
%G_SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's
standard input (by default, the child's standard input is attached to
/dev/null). If you use this flag, @standard_input must be %NULL.
%G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of @argv is
the file to execute, while the remaining elements are the
actual argument vector to pass to the file. Normally
g_spawn_async_with_pipes() uses @argv[0] as the file to execute, and
passes all of @argv to the child.

@child_setup and @user_data are a function and user data. On POSIX
platforms, the function is called in the child after GLib has
performed all the setup it plans to perform (including creating
pipes, closing file descriptors, etc.) but before calling
exec(). That is, @child_setup is called just
before calling exec() in the child. Obviously
actions taken in this function will only affect the child, not the
parent.

On Windows, there is no separate fork() and exec()
functionality. Child processes are created and run with a single
API call, CreateProcess(). There is no sensible thing @child_setup
could be used for on Windows so it is ignored and not called.

If non-%NULL, @child_pid will on Unix be filled with the child's
process ID. You can use the process ID to send signals to the
child, or to use g_child_watch_add() (or waitpid()) if you specified the
%G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, @child_pid will be
filled with a handle to the child process only if you specified the
%G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child
process using the Win32 API, for example wait for its termination
with the &lt;function&gt;WaitFor*()&lt;/function&gt; functions, or examine its
exit code with GetExitCodeProcess(). You should close the handle 
with CloseHandle() or g_spawn_close_pid() when you no longer need it.

If non-%NULL, the @standard_input, @standard_output, @standard_error
locations will be filled with file descriptors for writing to the child's
standard input or reading from its standard output or standard error.
The caller of g_spawn_async_with_pipes() must close these file descriptors
when they are no longer in use. If these parameters are %NULL, the corresponding
pipe won't be created.

If @standard_input is NULL, the child's standard input is attached to 
/dev/null unless %G_SPAWN_CHILD_INHERITS_STDIN is set.

If @standard_error is NULL, the child's standard error goes to the same 
location as the parent's standard error unless %G_SPAWN_STDERR_TO_DEV_NULL 
is set.

If @standard_output is NULL, the child's standard output goes to the same 
location as the parent's standard output unless %G_SPAWN_STDOUT_TO_DEV_NULL 
is set.

@error can be %NULL to ignore errors, or non-%NULL to report errors.
If an error is set, the function returns %FALSE. Errors
are reported even if they occur in the child (for example if the
executable in &lt;literal&gt;argv[0]&lt;/literal&gt; is not found). Typically
the &lt;literal&gt;message&lt;/literal&gt; field of returned errors should be displayed
to users. Possible errors are those from the #G_SPAWN_ERROR domain.

If an error occurs, @child_pid, @standard_input, @standard_output,
and @standard_error will not be filled with valid values.

If @child_pid is not %NULL and an error does not occur then the returned
process reference must be closed using g_spawn_close_pid().

&lt;note&gt;&lt;para&gt;
If you are writing a GTK+ application, and the program you 
are spawning is a graphical application, too, then you may
want to use gdk_spawn_on_screen_with_pipes() instead to ensure that 
the spawned program opens its windows on the right screen.
&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="working_directory">
<parameter_description> child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding
</parameter_description>
</parameter>
<parameter name="argv">
<parameter_description> child's argument vector, in the GLib file name encoding
</parameter_description>
</parameter>
<parameter name="envp">
<parameter_description> child's environment, or %NULL to inherit parent's, in the GLib file name encoding
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags from #GSpawnFlags
</parameter_description>
</parameter>
<parameter name="child_setup">
<parameter_description> function to run in the child just before exec()
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data for @child_setup
</parameter_description>
</parameter>
<parameter name="child_pid">
<parameter_description> return location for child process ID, or %NULL
</parameter_description>
</parameter>
<parameter name="standard_input">
<parameter_description> return location for file descriptor to write to child's stdin, or %NULL
</parameter_description>
</parameter>
<parameter name="standard_output">
<parameter_description> return location for file descriptor to read child's stdout, or %NULL
</parameter_description>
</parameter>
<parameter name="standard_error">
<parameter_description> return location for file descriptor to read child's stderr, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for error
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success, %FALSE if an error was set
</return>
</function>

<function name="g_static_rec_mutex_unlock_full">
<description>
Completely unlocks @mutex. If another thread is blocked in a
g_static_rec_mutex_lock() call for @mutex, it will be woken and can
lock @mutex itself. This function returns the number of times that
@mutex has been locked by the current thread. To restore the state
before the call to g_static_rec_mutex_unlock_full() you can call
g_static_rec_mutex_lock_full() with the depth returned by this
function.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticRecMutex to completely unlock.
</parameter_description>
</parameter>
</parameters>
<return> number of times @mutex has been locked by the current
thread.
</return>
</function>

<function name="g_rand_copy">
<description>
Copies a #GRand into a new one with the same exact state as before.
This way you can take a snapshot of the random number generator for
replaying later.

Since: 2.4

</description>
<parameters>
<parameter name="rand_">
<parameter_description> a #GRand.
</parameter_description>
</parameter>
</parameters>
<return> the new #GRand.

</return>
</function>

<function name="g_object_set_qdata">
<description>
This sets an opaque, named pointer on an object.
The name is specified through a #GQuark (retrived e.g. via
g_quark_from_static_string()), and the pointer
can be gotten back from the @object with g_object_get_qdata()
until the @object is finalized.
Setting a previously set user data pointer, overrides (frees)
the old pointer set, using #NULL as pointer essentially
removes the data stored.

</description>
<parameters>
<parameter name="object">
<parameter_description> The GObject to set store a user data pointer
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> A #GQuark, naming the user data pointer
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> An opaque user data pointer
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_get_string_length">
<description>
Returns the length of the type string corresponding to the given
@type.  This function must be used to determine the valid extent of
the memory region returned by g_variant_type_peek_string().

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> the length of the corresponding type string
</return>
</function>

<function name="g_random_int_range">
<description>
Returns a random #gint32 equally distributed over the range
[@begin..@end-1].


</description>
<parameters>
<parameter name="begin">
<parameter_description> lower closed bound of the interval.
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> upper open bound of the interval.
</parameter_description>
</parameter>
</parameters>
<return> A random number.
</return>
</function>

<function name="g_datalist_get_flags">
<description>
Gets flags values packed in together with the datalist.
See g_datalist_set_flags().

Since: 2.8

</description>
<parameters>
<parameter name="datalist">
<parameter_description> pointer to the location that holds a list
</parameter_description>
</parameter>
</parameters>
<return> the flags of the datalist

</return>
</function>

<function name="g_checksum_reset">
<description>
Resets the state of the @checksum back to its initial state.

Since: 2.18

</description>
<parameters>
<parameter name="checksum">
<parameter_description> the #GChecksum to reset
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_dataset_set_data_full">
<description>
Sets the data corresponding to the given string identifier, and the
function to call when the data element is destroyed.

</description>
<parameters>
<parameter name="l">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string to identify the data element.
</parameter_description>
</parameter>
<parameter name="d">
<parameter_description> the data element.
</parameter_description>
</parameter>
<parameter name="f">
<parameter_description> the function to call when the data element is removed. This
function will be called with the data element and can be used to
free any memory allocated for it.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_remove">
<description>
Removes the item pointed to by @iter. It is an error to pass the
end iterator to this function.

If the sequnce has a data destroy function associated with it, this
function is called on the data for the removed item.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ptr_array_add">
<description>
Adds a pointer to the end of the pointer array. The array will grow
in size automatically if necessary.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the pointer to add.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_insert_sorted_with_data">
<description>
Inserts a new element into the list, using the given comparison 
function to determine its position.

Since: 2.10

</description>
<parameters>
<parameter name="list">
<parameter_description> a pointer to a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to compare elements in the list. 
It should return a number &gt; 0 if the first parameter 
comes after the second parameter in the sort order.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to comparison function.
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GList

</return>
</function>

<function name="g_hash_table_remove_all">
<description>
Removes all keys and their associated values from a #GHashTable.

If the #GHashTable was created using g_hash_table_new_full(), the keys
and values are freed using the supplied destroy functions, otherwise you
have to make sure that any dynamically allocated values are freed
yourself.

Since: 2.12

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_push_allocator">
<description>
Sets the allocator to use to allocate #GList elements. Use
g_list_pop_allocator() to restore the previous allocator.

Note that this function is not available if GLib has been compiled
with &lt;option&gt;--disable-mem-pools&lt;/option&gt;

Deprecated:2.10: It does nothing, since #GList has been converted
to the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt;

</description>
<parameters>
<parameter name="allocator">
<parameter_description> the #GAllocator to use when allocating #GList elements.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_hash_table_remove">
<description>
Removes a key and its associated value from a #GHashTable.

If the #GHashTable was created using g_hash_table_new_full(), the
key and value are freed using the supplied destroy functions, otherwise
you have to make sure that any dynamically allocated values are freed
yourself.


</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the key to remove.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the key was found and removed from the #GHashTable.
</return>
</function>

<function name="g_string_up">
<description>
Converts a #GString to uppercase.

Deprecated:2.2: This function uses the locale-specific 
toupper() function, which is almost never the right thing. 
Use g_string_ascii_up() or g_utf8_strup() instead.

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString 
</parameter_description>
</parameter>
</parameters>
<return> @string

</return>
</function>

<function name="g_ptr_array_remove_index_fast">
<description>
Removes the pointer at the given index from the pointer array. The
last element in the array is used to fill in the space, so this
function does not preserve the order of the array. But it is faster
than g_ptr_array_remove_index(). If @array has a non-%NULL
#GDestroyNotify function it is called for the removed element.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the pointer to remove.
</parameter_description>
</parameter>
</parameters>
<return> the pointer which was removed.
</return>
</function>

<function name="g_object_steal_data">
<description>
Remove a specified datum from the object's data associations,
without invoking the association's destroy handler.


</description>
<parameters>
<parameter name="object">
<parameter_description> #GObject containing the associations
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> name of the key
</parameter_description>
</parameter>
</parameters>
<return> the data if found, or %NULL if no such data exists.
</return>
</function>

<function name="g_object_ref_sink">
<description>
Increase the reference count of @object, and possibly remove the
&lt;link linkend=&quot;floating-ref&quot;&gt;floating&lt;/link&gt; reference, if @object
has a floating reference.

In other words, if the object is floating, then this call &quot;assumes
ownership&quot; of the floating reference, converting it to a normal
reference by clearing the floating flag while leaving the reference
count unchanged.  If the object is not floating, then this call
adds a new normal reference increasing the reference count by one.

Since: 2.10


</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
</parameters>
<return> @object
</return>
</function>

<function name="g_static_rec_mutex_free">
<description>
Releases all resources allocated to a #GStaticRecMutex.

You don't have to call this functions for a #GStaticRecMutex with an
unbounded lifetime, i.e. objects declared 'static', but if you have
a #GStaticRecMutex as a member of a structure and the structure is
freed, you should also free the #GStaticRecMutex.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticRecMutex to be freed.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_main_context_query">
<description>
Determines information necessary to poll this main loop.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
<parameter name="max_priority">
<parameter_description> maximum priority source to check
</parameter_description>
</parameter>
<parameter name="timeout_">
<parameter_description> location to store timeout to be used in polling
</parameter_description>
</parameter>
<parameter name="fds">
<parameter_description> location to store #GPollFD records that need to be polled.
</parameter_description>
</parameter>
<parameter name="n_fds">
<parameter_description> length of @fds.
</parameter_description>
</parameter>
</parameters>
<return> the number of records actually stored in @fds,
or, if more than @n_fds records need to be stored, the number
of records that need to be stored.
</return>
</function>

<function name="g_array_remove_range">
<description>
Removes the given number of elements starting at the given index
from a #GArray.  The following elements are moved to close the gap.

Since: 2.4

</description>
<parameters>
<parameter name="array">
<parameter_description> a @GArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the first element to remove.
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the number of elements to remove.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_quark_from_static_string">
<description>
Gets the #GQuark identifying the given (static) string. If the
string does not currently have an associated #GQuark, a new #GQuark
is created, linked to the given string.

Note that this function is identical to g_quark_from_string() except
that if a new #GQuark is created the string itself is used rather
than a copy. This saves memory, but can only be used if the string
will &lt;emphasis&gt;always&lt;/emphasis&gt; exist. It can be used with
statically allocated strings in the main program, but not with
statically allocated memory in dynamically loaded modules, if you
expect to ever unload the module again (e.g. do not use this
function in GTK+ theme engines).

</description>
<parameters>
<parameter name="string">
<parameter_description> a string.
</parameter_description>
</parameter>
</parameters>
<return> the #GQuark identifying the string, or 0 if @string is
%NULL.
</return>
</function>

<function name="g_list_prepend">
<description>
Adds a new element on to the start of the list.

&lt;note&gt;&lt;para&gt;
The return value is the new start of the list, which 
may have changed, so make sure you store the new value.
&lt;/para&gt;&lt;/note&gt;

|[ 
/ * Notice that it is initialized to the empty list. * /
GList *list = NULL;
list = g_list_prepend (list, &quot;last&quot;);
list = g_list_prepend (list, &quot;first&quot;);
]|


</description>
<parameters>
<parameter name="list">
<parameter_description> a pointer to a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GList
</return>
</function>

<function name="g_queue_free">
<description>
Frees the memory allocated for the #GQueue. Only call this function if
@queue was created with g_queue_new(). If queue elements contain
dynamically-allocated memory, they should be freed first.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_next_base">
<description>
Given a @leaf_type and a @root_type which is contained in its
anchestry, return the type that @root_type is the immediate parent
of.  In other words, this function determines the type that is
derived directly from @root_type which is also a base class of
@leaf_type.  Given a root type and a leaf type, this function can
be used to determine the types and order in which the leaf type is
descended from the root type.


</description>
<parameters>
<parameter name="leaf_type">
<parameter_description> Descendant of @root_type and the type to be returned.
</parameter_description>
</parameter>
<parameter name="root_type">
<parameter_description> Immediate parent of the returned type.
</parameter_description>
</parameter>
</parameters>
<return> Immediate child of @root_type and anchestor of @leaf_type.
</return>
</function>

<function name="g_timer_start">
<description>
Marks a start time, so that future calls to g_timer_elapsed() will
report the time since g_timer_start() was called. g_timer_new()
automatically marks the start time, so no need to call
g_timer_start() immediately after creating the timer.

</description>
<parameters>
<parameter name="timer">
<parameter_description> a #GTimer.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_markup_parse_context_end_parse">
<description>
Signals to the #GMarkupParseContext that all data has been
fed into the parse context with g_markup_parse_context_parse().
This function reports an error if the document isn't complete,
for example if elements are still open.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMarkupParseContext
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success, %FALSE if an error was set
</return>
</function>

<function name="g_mem_chunk_print">
<description>
Outputs debugging information for a #GMemChunk. It outputs the name
of the #GMemChunk (set with g_mem_chunk_new()), the number of bytes
used, and the number of blocks of memory allocated.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
<parameter name="mem_chunk">
<parameter_description> a #GMemChunk.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ascii_digit_value">
<description>
Determines the numeric value of a character as a decimal
digit. Differs from g_unichar_digit_value() because it takes
a char, so there's no worry about sign extension if characters
are signed.


</description>
<parameters>
<parameter name="c">
<parameter_description> an ASCII character.
</parameter_description>
</parameter>
</parameters>
<return> If @c is a decimal digit (according to
g_ascii_isdigit()), its numeric value. Otherwise, -1.
</return>
</function>

<function name="g_regex_get_pattern">
<description>
Gets the pattern string associated with @regex, i.e. a copy of
the string passed to g_regex_new().

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure
</parameter_description>
</parameter>
</parameters>
<return> the pattern of @regex

</return>
</function>

<function name="g_variant_type_string_is_valid">
<description>
Checks if @type_string is a valid GVariant type string.  This call is
equivalent to calling g_variant_type_string_scan() and confirming
that the following character is a nul terminator.

Since 2.24

</description>
<parameters>
<parameter name="type_string">
<parameter_description> a pointer to any string
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type_string is exactly one valid type string
</return>
</function>

<function name="g_regex_new">
<description>
Compiles the regular expression to an internal form, and does
the initial setup of the #GRegex structure.

Since: 2.14

</description>
<parameters>
<parameter name="pattern">
<parameter_description> the regular expression
</parameter_description>
</parameter>
<parameter name="compile_options">
<parameter_description> compile options for the regular expression, or 0
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> match options for the regular expression, or 0
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> a #GRegex structure. Call g_regex_unref() when you
are done with it

</return>
</function>

<function name="g_list_nth">
<description>
Gets the element at the given position in a #GList.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position of the element, counting from 0
</parameter_description>
</parameter>
</parameters>
<return> the element, or %NULL if the position is off 
the end of the #GList
</return>
</function>

<function name="g_signal_connect_object">
<description>
This is similar to g_signal_connect_data(), but uses a closure which
ensures that the @gobject stays alive during the call to @c_handler
by temporarily adding a reference count to @gobject.

Note that there is a bug in GObject that makes this function
much less useful than it might seem otherwise. Once @gobject is
disposed, the callback will no longer be called, but, the signal
handler is &lt;emphasis&gt;not&lt;/emphasis&gt; currently disconnected. If the
@instance is itself being freed at the same time than this doesn't
matter, since the signal will automatically be removed, but
if @instance persists, then the signal handler will leak. You
should not remove the signal yourself because in a future versions of
GObject, the handler &lt;emphasis&gt;will&lt;/emphasis&gt; automatically
be disconnected.

It's possible to work around this problem in a way that will
continue to work with future versions of GObject by checking
that the signal handler is still connected before disconnected it:
&lt;informalexample&gt;&lt;programlisting&gt;
if (g_signal_handler_is_connected (instance, id))
g_signal_handler_disconnect (instance, id);
&lt;/programlisting&gt;&lt;/informalexample&gt;


</description>
<parameters>
<parameter name="instance">
<parameter_description> the instance to connect to.
</parameter_description>
</parameter>
<parameter name="detailed_signal">
<parameter_description> a string of the form &quot;signal-name::detail&quot;.
</parameter_description>
</parameter>
<parameter name="c_handler">
<parameter_description> the #GCallback to connect.
</parameter_description>
</parameter>
<parameter name="gobject">
<parameter_description> the object to pass as data to @c_handler.
</parameter_description>
</parameter>
<parameter name="connect_flags">
<parameter_description> a combination of #GConnnectFlags.
</parameter_description>
</parameter>
</parameters>
<return> the handler id.
</return>
</function>

<function name="g_datalist_init">
<description>
Resets the datalist to %NULL. It does not free any memory or call
any destroy functions.

</description>
<parameters>
<parameter name="datalist">
<parameter_description> a pointer to a pointer to a datalist.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_source_is_destroyed">
<description>
Returns whether @source has been destroyed.

This is important when you operate upon your objects 
from within idle handlers, but may have freed the object 
before the dispatch of your idle handler.

|[
static gboolean 
idle_callback (gpointer data)
{
SomeWidget *self = data;

GDK_THREADS_ENTER (&lt;!-- --&gt;);
/&lt;!-- --&gt;* do stuff with self *&lt;!-- --&gt;/
self-&gt;idle_id = 0;
GDK_THREADS_LEAVE (&lt;!-- --&gt;);

return FALSE;
}

static void 
some_widget_do_stuff_later (SomeWidget *self)
{
self-&gt;idle_id = g_idle_add (idle_callback, self);
}

static void 
some_widget_finalize (GObject *object)
{
SomeWidget *self = SOME_WIDGET (object);

if (self-&gt;idle_id)
g_source_remove (self-&gt;idle_id);

G_OBJECT_CLASS (parent_class)-&gt;finalize (object);
}
]|

This will fail in a multi-threaded application if the 
widget is destroyed before the idle handler fires due 
to the use after free in the callback. A solution, to 
this particular problem, is to check to if the source
has already been destroy within the callback.

|[
static gboolean 
idle_callback (gpointer data)
{
SomeWidget *self = data;

GDK_THREADS_ENTER ();
if (!g_source_is_destroyed (g_main_current_source ()))
{
/&lt;!-- --&gt;* do stuff with self *&lt;!-- --&gt;/
}
GDK_THREADS_LEAVE ();

return FALSE;
}
]|

Since: 2.12

</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the source has been destroyed

</return>
</function>

<function name="g_test_add_data_func">
<description>
Create a new test case, similar to g_test_create_case(). However
the test is assumed to use no fixture, and test suites are automatically
created on the fly and added to the root fixture, based on the
slash-separated portions of @testpath. The @test_data argument
will be passed as first argument to @test_func.

Since: 2.16

</description>
<parameters>
<parameter name="testpath">
<parameter_description>   Slash-separated test case path name for the test.
</parameter_description>
</parameter>
<parameter name="test_data">
<parameter_description>  Test data argument for the test function.
</parameter_description>
</parameter>
<parameter name="test_func">
<parameter_description>  The test function to invoke for this test.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cclosure_marshal_VOID__UINT">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, guint arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #guint parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_builder_add">
<description>
Adds to a #GVariantBuilder.

This call is a convenience wrapper that is exactly equivalent to
calling g_variant_new() followed by g_variant_builder_add_value().

This function might be used as follows:

&lt;programlisting&gt;
GVariant *
make_pointless_dictionary (void)
{
GVariantBuilder *builder;
int i;

builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
for (i = 0; i &lt; 16; i++)
{
gchar buf[3];

sprintf (buf, &quot;%d&quot;, i);
g_variant_builder_add (builder, &quot;{is}&quot;, i, buf);
}

return g_variant_builder_end (builder);
}
&lt;/programlisting&gt;

Since: 2.24

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder
</parameter_description>
</parameter>
<parameter name="format_string">
<parameter_description> a #GVariant varargs format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments, as per @format_string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ascii_formatd">
<description>
Converts a #gdouble to a string, using the '.' as
decimal point. To format the number you pass in
a printf()-style format string. Allowed conversion
specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'. 

If you just want to want to serialize the value into a
string, use g_ascii_dtostr().


</description>
<parameters>
<parameter name="buffer">
<parameter_description> A buffer to place the resulting string in
</parameter_description>
</parameter>
<parameter name="buf_len">
<parameter_description> The length of the buffer.
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> The printf()-style format to use for the
code to use for converting. 
</parameter_description>
</parameter>
<parameter name="d">
<parameter_description> The #gdouble to convert
</parameter_description>
</parameter>
</parameters>
<return> The pointer to the buffer with the converted string.
</return>
</function>

<function name="g_bookmark_file_set_title">
<description>
Sets @title as the title of the bookmark for @uri inside the
bookmark file @bookmark.

If @uri is %NULL, the title of @bookmark is set.

If a bookmark for @uri cannot be found then it is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI or %NULL
</parameter_description>
</parameter>
<parameter name="title">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_enum_complete_type_info">
<description>
This function is meant to be called from the complete_type_info()
function of a #GTypePlugin implementation, as in the following
example:

|[
static void
my_enum_complete_type_info (GTypePlugin     *plugin,
GType            g_type,
GTypeInfo       *info,
GTypeValueTable *value_table)
{
static const GEnumValue values[] = {
{ MY_ENUM_FOO, &quot;MY_ENUM_FOO&quot;, &quot;foo&quot; },
{ MY_ENUM_BAR, &quot;MY_ENUM_BAR&quot;, &quot;bar&quot; },
{ 0, NULL, NULL }
};

g_enum_complete_type_info (type, info, values);
}
]|

</description>
<parameters>
<parameter name="g_enum_type">
<parameter_description> the type identifier of the type being completed
</parameter_description>
</parameter>
<parameter name="info">
<parameter_description> the #GTypeInfo struct to be filled in
</parameter_description>
</parameter>
<parameter name="const_values">
<parameter_description> An array of #GEnumValue structs for the possible
enumeration values. The array is terminated by a struct with all
members being 0.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_propagate_prefixed_error">
<description>
If @dest is %NULL, free @src; otherwise,
moves @src into *@dest. *@dest must be %NULL.
After the move, add a prefix as with
g_prefix_error().

Since: 2.16

</description>
<parameters>
<parameter name="dest">
<parameter_description> error return location
</parameter_description>
</parameter>
<parameter name="src">
<parameter_description> error to move into the return location
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> printf()-style format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments to @format
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_fundamental_next">
<description>
Returns the next free fundamental type id which can be used to
register a new fundamental type with g_type_register_fundamental().
The returned type ID represents the highest currently registered
fundamental type identifier.


</description>
<parameters>
</parameters>
<return> The nextmost fundamental type ID to be registered,
or 0 if the type system ran out of fundamental type IDs.
</return>
</function>

<function name="g_thread_pool_new">
<description>
This function creates a new thread pool.

Whenever you call g_thread_pool_push(), either a new thread is
created or an unused one is reused. At most @max_threads threads
are running concurrently for this thread pool. @max_threads = -1
allows unlimited threads to be created for this thread pool. The
newly created or reused thread now executes the function @func with
the two arguments. The first one is the parameter to
g_thread_pool_push() and the second one is @user_data.

The parameter @exclusive determines, whether the thread pool owns
all threads exclusive or whether the threads are shared
globally. If @exclusive is %TRUE, @max_threads threads are started
immediately and they will run exclusively for this thread pool until
it is destroyed by g_thread_pool_free(). If @exclusive is %FALSE,
threads are created, when needed and shared between all
non-exclusive thread pools. This implies that @max_threads may not
be -1 for exclusive thread pools.

@error can be %NULL to ignore errors, or non-%NULL to report
errors. An error can only occur when @exclusive is set to %TRUE and
not all @max_threads threads could be created.


</description>
<parameters>
<parameter name="func">
<parameter_description> a function to execute in the threads of the new thread pool
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data that is handed over to @func every time it 
is called
</parameter_description>
</parameter>
<parameter name="max_threads">
<parameter_description> the maximal number of threads to execute concurrently in 
the new thread pool, -1 means no limit
</parameter_description>
</parameter>
<parameter name="exclusive">
<parameter_description> should this thread pool be exclusive?
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for error
</parameter_description>
</parameter>
</parameters>
<return> the new #GThreadPool
</return>
</function>

<function name="g_io_channel_win32_new_messages">
<description>
Creates a new #GIOChannel given a window handle on Windows.

This function creates a #GIOChannel that can be used to poll for
Windows messages for the window in question.

</description>
<parameters>
<parameter name="hwnd">
<parameter_description> a window handle.
</parameter_description>
</parameter>
</parameters>
<return> a new #GIOChannel.
</return>
</function>

<function name="g_tree_remove">
<description>
Removes a key/value pair from a #GTree.

If the #GTree was created using g_tree_new_full(), the key and value 
are freed using the supplied destroy functions, otherwise you have to 
make sure that any dynamically allocated values are freed yourself.
If the key does not exist in the #GTree, the function does nothing.


</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the key to remove.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the key was found (prior to 2.8, this function returned 
nothing)
</return>
</function>

<function name="g_variant_get_type_string">
<description>
Returns the type string of @value.  Unlike the result of calling
g_variant_type_peek_string(), this string is nul-terminated.  This
string belongs to #GVariant and must not be freed.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return> the type string for the type of @value
</return>
</function>

<function name="g_type_interface_peek">
<description>
Returns the #GTypeInterface structure of an interface to which the
passed in class conforms.


</description>
<parameters>
<parameter name="instance_class">
<parameter_description> A #GTypeClass structure.
</parameter_description>
</parameter>
<parameter name="iface_type">
<parameter_description> An interface ID which this class conforms to.
</parameter_description>
</parameter>
</parameters>
<return> The GTypeInterface structure of iface_type if implemented
by @instance_class, %NULL otherwise
</return>
</function>

<function name="g_variant_iter_next_value">
<description>
Gets the next item in the container.  If no more items remain then
%NULL is returned.

Use g_variant_unref() to drop your reference on the return value when
you no longer need it.

&lt;example&gt;
&lt;title&gt;Iterating with g_variant_iter_next_value()&lt;/title&gt;
&lt;programlisting&gt;
/&lt;!-- --&gt;* recursively iterate a container *&lt;!-- --&gt;/
void
iterate_container_recursive (GVariant *container)
{
GVariantIter iter;
GVariant *child;

g_variant_iter_init (&amp;iter, dictionary);
while ((child = g_variant_iter_next_value (&amp;iter)))
{
g_print (&quot;type '%s'\n&quot;, g_variant_get_type_string (child));

if (g_variant_is_container (child))
iterate_container_recursive (child);

g_variant_unref (child);
}
}
&lt;/programlisting&gt;
&lt;/example&gt;

Since: 2.24

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GVariantIter
</parameter_description>
</parameter>
</parameters>
<return> a #GVariant, or %NULL
</return>
</function>

<function name="g_variant_new_uint64">
<description>
Creates a new uint64 #GVariant instance.

Since: 2.24

</description>
<parameters>
<parameter name="uint64">
<parameter_description> a #guint64 value
</parameter_description>
</parameter>
</parameters>
<return> a new uint64 #GVariant instance
</return>
</function>

<function name="g_list_next">
<description>
A convenience macro to get the next element in a #GList.

</description>
<parameters>
<parameter name="list">
<parameter_description> an element in a #GList.
</parameter_description>
</parameter>
</parameters>
<return> the next element, or %NULL if there are no more elements.
</return>
</function>

<function name="g_tree_steal">
<description>
Removes a key and its associated value from a #GTree without calling 
the key and value destroy functions.

If the key does not exist in the #GTree, the function does nothing.


</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the key to remove.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the key was found (prior to 2.8, this function returned 
nothing)
</return>
</function>

<function name="g_ptr_array_sort_with_data">
<description>
Like g_ptr_array_sort(), but the comparison function has an extra
user data argument.

&lt;note&gt;&lt;para&gt;The comparison function for g_ptr_array_sort_with_data()
doesn't take the pointers from the array as arguments, it takes
pointers to the pointers in the array.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> comparison function.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> data to pass to @compare_func.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_tree_new_full">
<description>
Creates a new #GTree like g_tree_new() and allows to specify functions 
to free the memory allocated for the key and value that get called when 
removing the entry from the #GTree.


</description>
<parameters>
<parameter name="key_compare_func">
<parameter_description> qsort()-style comparison function.
</parameter_description>
</parameter>
<parameter name="key_compare_data">
<parameter_description> data to pass to comparison function.
</parameter_description>
</parameter>
<parameter name="key_destroy_func">
<parameter_description> a function to free the memory allocated for the key 
used when removing the entry from the #GTree or %NULL if you don't
want to supply such a function.
</parameter_description>
</parameter>
<parameter name="value_destroy_func">
<parameter_description> a function to free the memory allocated for the 
value used when removing the entry from the #GTree or %NULL if you 
don't want to supply such a function.
</parameter_description>
</parameter>
</parameters>
<return> a new #GTree.
</return>
</function>

<function name="g_variant_get_maybe">
<description>
Given a maybe-typed #GVariant instance, extract its value.  If the
value is Nothing, then this function returns %NULL.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a maybe-typed value
</parameter_description>
</parameter>
</parameters>
<return> the contents of @value, or %NULL
</return>
</function>

<function name="g_dataset_remove_data">
<description>
Removes a data element corresponding to a string. Its destroy
function is called if it has been set.

</description>
<parameters>
<parameter name="l">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string identifying the data element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_index">
<description>
Gets the position of the element containing 
the given data (starting from 0).


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to find
</parameter_description>
</parameter>
</parameters>
<return> the index of the element containing the data, 
or -1 if the data is not found
</return>
</function>

<function name="g_param_spec_get_redirect_target">
<description>
If the paramspec redirects operations to another paramspec,
returns that paramspec. Redirect is used typically for
providing a new implementation of a property in a derived
type while preserving all the properties from the parent
type. Redirection is established by creating a property
of type #GParamSpecOverride. See g_object_class_override_property()
for an example of the use of this capability.

Since: 2.4


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a #GParamSpec
</parameter_description>
</parameter>
</parameters>
<return> paramspec to which requests on this paramspec should
be redirected, or %NULL if none.
</return>
</function>

<function name="g_sprintf">
<description>
An implementation of the standard sprintf() function which supports
positional parameters, as specified in the Single Unix Specification.

Note that it is usually better to use g_snprintf(), to avoid the
risk of buffer overflow.

See also g_strdup_printf().

Since: 2.2

</description>
<parameters>
<parameter name="string">
<parameter_description> A pointer to a memory buffer to contain the resulting string. It
is up to the caller to ensure that the allocated buffer is large
enough to hold the formatted result
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> the arguments to insert in the output.
</parameter_description>
</parameter>
</parameters>
<return> the number of bytes printed.

</return>
</function>

<function name="g_strncasecmp">
<description>
A case-insensitive string comparison, corresponding to the standard
strncasecmp() function on platforms which support it.
It is similar to g_strcasecmp() except it only compares the first @n 
characters of the strings.

Deprecated:2.2: The problem with g_strncasecmp() is that it does the 
comparison by calling toupper()/tolower(). These functions are
locale-specific and operate on single bytes. However, it is impossible
to handle things correctly from an I18N standpoint by operating on
bytes, since characters may be multibyte. Thus g_strncasecmp() is
broken if your string is guaranteed to be ASCII, since it's
locale-sensitive, and it's broken if your string is localized, since
it doesn't work on many encodings at all, including UTF-8, EUC-JP,
etc.

There are therefore two replacement functions: g_ascii_strncasecmp(),
which only works on ASCII and is not locale-sensitive, and
g_utf8_casefold(), which is good for case-insensitive sorting of UTF-8.

</description>
<parameters>
<parameter name="s1">
<parameter_description> a string.
</parameter_description>
</parameter>
<parameter name="s2">
<parameter_description> a string to compare with @s1.
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the maximum number of characters to compare.
</parameter_description>
</parameter>
</parameters>
<return> 0 if the strings match, a negative value if @s1 &lt; @s2, 
or a positive value if @s1 &gt; @s2.

</return>
</function>

<function name="g_list_nth_prev">
<description>
Gets the element @n places before @list.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position of the element, counting from 0
</parameter_description>
</parameter>
</parameters>
<return> the element, or %NULL if the position is 
off the end of the #GList
</return>
</function>

<function name="g_key_file_remove_group">
<description>
Removes the specified group, @group_name, 
from the key file. 

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the group was removed, %FALSE otherwise

</return>
</function>

<function name="g_atomic_pointer_set">
<description>
Sets the value of the pointer pointed to by @atomic.
Also acts as a memory barrier.

Since: 2.10

</description>
<parameters>
<parameter name="atomic">
<parameter_description> a pointer to a #gpointer
</parameter_description>
</parameter>
<parameter name="newval">
<parameter_description> the new value
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_mutex_unlock">
<description>
Unlocks @mutex. If another thread is blocked in a g_mutex_lock()
call for @mutex, it will be woken and can lock @mutex itself.

This function can be used even if g_thread_init() has not yet been
called, and, in that case, will do nothing.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GMutex.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_nth_data">
<description>
Gets the data of the element at the given position.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position of the element
</parameter_description>
</parameter>
</parameters>
<return> the element's data, or %NULL if the position 
is off the end of the #GSList
</return>
</function>

<function name="g_ptr_array_remove_fast">
<description>
Removes the first occurrence of the given pointer from the pointer
array. The last element in the array is used to fill in the space,
so this function does not preserve the order of the array. But it is
faster than g_ptr_array_remove(). If @array has a non-%NULL
#GDestroyNotify function it is called for the removed element.

It returns %TRUE if the pointer was removed, or %FALSE if the
pointer was not found.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the pointer to remove.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the pointer was found in the array.
</return>
</function>

<function name="g_string_prepend_c">
<description>
Adds a byte onto the start of a #GString, 
expanding it if necessary.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="c">
<parameter_description> the byte to prepend on the start of the #GString
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_static_mutex_trylock">
<description>
Works like g_mutex_trylock(), but for a #GStaticMutex.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticMutex.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE, if the #GStaticMutex could be locked.
</return>
</function>

<function name="g_completion_clear_items">
<description>
Removes all items from the #GCompletion.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="cmp">
<parameter_description> the #GCompletion.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_value_defaults">
<description>
Checks whether @value contains the default value as specified in @pspec.


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> a #GValue of correct type for @pspec
</parameter_description>
</parameter>
</parameters>
<return> whether @value contains the canonical default for this @pspec
</return>
</function>

<function name="g_list_pop_allocator">
<description>
Restores the previous #GAllocator, used when allocating #GList
elements.

Note that this function is not available if GLib has been compiled
with &lt;option&gt;--disable-mem-pools&lt;/option&gt;

Deprecated:2.10: It does nothing, since #GList has been converted
to the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt;

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_markup_escape_text">
<description>
Escapes text so that the markup parser will parse it verbatim.
Less than, greater than, ampersand, etc. are replaced with the
corresponding entities. This function would typically be used
when writing out a file to be parsed with the markup parser.

Note that this function doesn't protect whitespace and line endings
from being processed according to the XML rules for normalization
of line endings and attribute values.

Note also that this function will produce character references in
the range of &amp;#x1; ... &amp;#x1f; for all control sequences
except for tabstop, newline and carriage return.  The character
references in this range are not valid XML 1.0, but they are
valid XML 1.1 and will be accepted by the GMarkup parser.


</description>
<parameters>
<parameter name="text">
<parameter_description> some valid UTF-8 text
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> length of @text in bytes, or -1 if the text is nul-terminated
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string with the escaped text
</return>
</function>

<function name="g_variant_type_peek_string">
<description>
Returns the type string corresponding to the given @type.  The
result is not nul-terminated; in order to determine its length you
must call g_variant_type_get_string_length().

To get a nul-terminated string, see g_variant_type_dup_string().

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> the corresponding type string (not nul-terminated)
</return>
</function>

<function name="g_type_default_interface_peek">
<description>
If the interface type @g_type is currently in use, returns its
default interface vtable.

Since: 2.4


</description>
<parameters>
<parameter name="g_type">
<parameter_description> an interface type
</parameter_description>
</parameter>
</parameters>
<return> the default vtable for the interface, or %NULL
if the type is not currently in use.
</return>
</function>

<function name="g_array_insert_val">
<description>
Inserts an element into an array at the given index.

&lt;note&gt;&lt;para&gt;g_array_insert_val() is a macro which uses a reference
to the value parameter @v. This means that you cannot use it with
literal values such as &quot;27&quot;. You must use variables.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="a">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="i">
<parameter_description> the index to place the element at.
</parameter_description>
</parameter>
<parameter name="v">
<parameter_description> the value to insert into the array.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_bit_lock">
<description>
Sets the indicated @lock_bit in @address.  If the bit is already
set, this call will block until g_bit_unlock() unsets the
corresponding bit.

Attempting to lock on two different bits within the same integer is
not supported and will very probably cause deadlocks.

The value of the bit that is set is (1u &lt;&lt; @bit).  If @bit is not
between 0 and 31 then the result is undefined.

This function accesses @address atomically.  All other accesses to
@address must be atomic in order for this function to work
reliably.

Since: 2.24

</description>
<parameters>
<parameter name="address">
<parameter_description> a pointer to an integer
</parameter_description>
</parameter>
<parameter name="lock_bit">
<parameter_description> a bit value between 0 and 31
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_remove">
<description>
A wrapper for the POSIX remove() function. The remove() function
deletes a name from the filesystem.

See your C library manual for more details about how remove() works
on your system. On Unix, remove() removes also directories, as it
calls unlink() for files and rmdir() for directories. On Windows,
although remove() in the C library only works for files, this
function tries first remove() and then if that fails rmdir(), and
thus works for both files and directories. Note however, that on
Windows, it is in general not possible to remove a file that is
open to some process, or mapped into memory.

If this function fails on Windows you can't infer too much from the
errno value. rmdir() is tried regardless of what caused remove() to
fail. Any errno value set by remove() will be overwritten by that
set by rmdir().

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
</parameters>
<return> 0 if the file was successfully removed, -1 if an error 
occurred

</return>
</function>

<function name="g_list_reverse">
<description>
Reverses a #GList.
It simply switches the next and prev pointers of each element.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
</parameters>
<return> the start of the reversed #GList
</return>
</function>

<function name="g_main_context_check">
<description>
Passes the results of polling back to the main loop.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
<parameter name="max_priority">
<parameter_description> the maximum numerical priority of sources to check
</parameter_description>
</parameter>
<parameter name="fds">
<parameter_description> array of #GPollFD's that was passed to the last call to
g_main_context_query()
</parameter_description>
</parameter>
<parameter name="n_fds">
<parameter_description> return value of g_main_context_query()
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if some sources are ready to be dispatched.
</return>
</function>

<function name="g_variant_parse">
<description>
Parses a #GVariant from a text representation.

A single #GVariant is parsed from the content of @text.

The memory at @limit will never be accessed and the parser behaves as
if the character at @limit is the nul terminator.  This has the
effect of bounding @text.

If @endptr is non-%NULL then @text is permitted to contain data
following the value that this function parses and @endptr will be
updated to point to the first character past the end of the text
parsed by this function.  If @endptr is %NULL and there is extra data
then an error is returned.

If @type is non-%NULL then the value will be parsed to have that
type.  This may result in additional parse errors (in the case that
the parsed value doesn't fit the type) but may also result in fewer
errors (in the case that the type would have been ambiguous, such as
with empty arrays).

In the event that the parsing is successful, the resulting #GVariant
is returned.

In case of any error, %NULL will be returned.  If @error is non-%NULL
then it will be set to reflect the error that occured.

Officially, the language understood by the parser is &quot;any string
produced by g_variant_print()&quot;.

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType, or %NULL
</parameter_description>
</parameter>
<parameter name="text">
<parameter_description> a string containing a GVariant in text form
</parameter_description>
</parameter>
<parameter name="limit">
<parameter_description> a pointer to the end of @text, or %NULL
</parameter_description>
</parameter>
<parameter name="endptr">
<parameter_description> a location to store the end pointer, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> a pointer to a %NULL #GError pointer, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a reference to a #GVariant, or %NULL
</return>
</function>

<function name="g_sequence_sort">
<description>
Sorts @seq using @cmp_func.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
<parameter name="cmp_func">
<parameter_description> the #GCompareDataFunc used to sort @seq. This function is
passed two items of @seq and should return 0 if they are equal,
a negative value if the first comes before the second, and a
positive value if the second comes before the first.
</parameter_description>
</parameter>
<parameter name="cmp_data">
<parameter_description> user data passed to @cmp_func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_option_context_set_summary">
<description>
Adds a string to be displayed in &lt;option&gt;--help&lt;/option&gt; output
before the list of options. This is typically a summary of the
program functionality. 

Note that the summary is translated (see 
g_option_context_set_translate_func() and
g_option_context_set_translation_domain()).

Since: 2.12

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="summary">
<parameter_description> a string to be shown in &lt;option&gt;--help&lt;/option&gt; output 
before the list of options, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_double">
<description>
Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE
property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_io_channel_read_to_end">
<description>
Reads all the remaining data from the file.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="str_return">
<parameter_description> Location to store a pointer to a string holding
the remaining data in the #GIOChannel. This data should
be freed with g_free() when no longer needed. This
data is terminated by an extra nul character, but there 
may be other nuls in the intervening data.
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> location to store length of the data
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to return an error of type #GConvertError
or #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> %G_IO_STATUS_NORMAL on success. 
This function never returns %G_IO_STATUS_EOF.
</return>
</function>

<function name="g_variant_type_free">
<description>
Frees a #GVariantType that was allocated with
g_variant_type_copy(), g_variant_type_new() or one of the container
type constructor functions.

In the case that @type is %NULL, this function does nothing.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_random_double">
<description>
Returns a random #gdouble equally distributed over the range [0..1).


</description>
<parameters>
</parameters>
<return> A random number.
</return>
</function>

<function name="g_closure_add_finalize_notifier">
<description>
Registers a finalization notifier which will be called when the
reference count of @closure goes down to 0. Multiple finalization
notifiers on a single closure are invoked in unspecified order. If
a single call to g_closure_unref() results in the closure being
both invalidated and finalized, then the invalidate notifiers will
be run before the finalize notifiers.

</description>
<parameters>
<parameter name="closure">
<parameter_description> a #GClosure
</parameter_description>
</parameter>
<parameter name="notify_data">
<parameter_description> data to pass to @notify_func
</parameter_description>
</parameter>
<parameter name="notify_func">
<parameter_description> the callback function to register
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ascii_strcasecmp">
<description>
Compare two strings, ignoring the case of ASCII characters.

Unlike the BSD strcasecmp() function, this only recognizes standard
ASCII letters and ignores the locale, treating all non-ASCII
bytes as if they are not letters.

This function should be used only on strings that are known to be
in encodings where the bytes corresponding to ASCII letters always
represent themselves. This includes UTF-8 and the ISO-8859-*
charsets, but not for instance double-byte encodings like the
Windows Codepage 932, where the trailing bytes of double-byte
characters include all ASCII letters. If you compare two CP932
strings using this function, you will get false matches.


</description>
<parameters>
<parameter name="s1">
<parameter_description> string to compare with @s2.
</parameter_description>
</parameter>
<parameter name="s2">
<parameter_description> string to compare with @s1.
</parameter_description>
</parameter>
</parameters>
<return> 0 if the strings match, a negative value if @s1 &lt; @s2, 
or a positive value if @s1 &gt; @s2.
</return>
</function>

<function name="g_signal_remove_emission_hook">
<description>
Deletes an emission hook.

</description>
<parameters>
<parameter name="signal_id">
<parameter_description> the id of the signal
</parameter_description>
</parameter>
<parameter name="hook_id">
<parameter_description> the id of the emission hook, as returned by
g_signal_add_emission_hook()
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_compute_checksum_for_data">
<description>
Computes the checksum for a binary @data of @length. This is a
convenience wrapper for g_checksum_new(), g_checksum_get_string()
and g_checksum_free().

The hexadecimal string returned will be in lower case.

Since: 2.16

</description>
<parameters>
<parameter name="checksum_type">
<parameter_description> a #GChecksumType
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> binary blob to compute the digest of
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> length of @data
</parameter_description>
</parameter>
</parameters>
<return> the digest of the binary data as a string in hexadecimal.
The returned string should be freed with g_free() when done using it.

</return>
</function>

<function name="g_hash_table_insert">
<description>
Inserts a new key and value into a #GHashTable.

If the key already exists in the #GHashTable its current value is replaced
with the new value. If you supplied a @value_destroy_func when creating the
#GHashTable, the old value is freed using that function. If you supplied
a @key_destroy_func when creating the #GHashTable, the passed key is freed
using that function.

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key to insert.
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> the value to associate with the key.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_tree_foreach">
<description>
Calls the given function for each of the key/value pairs in the #GTree.
The function is passed the key and value of each pair, and the given
@data parameter. The tree is traversed in sorted order.

The tree may not be modified while iterating over it (you can't 
add/remove items). To remove all items matching a predicate, you need 
to add each item to a list in your #GTraverseFunc as you walk over 
the tree, then walk the list and remove each item.

</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each node visited. If this function
returns %TRUE, the traversal is stopped.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_closure_set_marshal">
<description>
Sets the marshaller of @closure. The &lt;literal&gt;marshal_data&lt;/literal&gt;
of @marshal provides a way for a meta marshaller to provide additional
information to the marshaller. (See g_closure_set_meta_marshal().) For
GObject's C predefined marshallers (the g_cclosure_marshal_*()
functions), what it provides is a callback function to use instead of
@closure-&gt;callback.

</description>
<parameters>
<parameter name="closure">
<parameter_description> a #GClosure
</parameter_description>
</parameter>
<parameter name="marshal">
<parameter_description> a #GClosureMarshal function
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_get_user_special_dir">
<description>
Returns the full path of a special directory using its logical id.

On Unix this is done using the XDG special user directories.
For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP
falls back to &lt;filename&gt;$HOME/Desktop&lt;/filename&gt; when XDG special
user directories have not been set up. 

Depending on the platform, the user might be able to change the path
of the special directory without requiring the session to restart; GLib
will not reflect any change once the special directories are loaded.

Since: 2.14

</description>
<parameters>
<parameter name="directory">
<parameter_description> the logical id of special directory
</parameter_description>
</parameter>
</parameters>
<return> the path to the specified special directory, or %NULL
if the logical id was not found. The returned string is owned by
GLib and should not be modified or freed.

</return>
</function>

<function name="g_variant_builder_add_parsed">
<description>
Adds to a #GVariantBuilder.

This call is a convenience wrapper that is exactly equivalent to
calling g_variant_new_parsed() followed by
g_variant_builder_add_value().

This function might be used as follows:

&lt;programlisting&gt;
GVariant *
make_pointless_dictionary (void)
{
GVariantBuilder *builder;
int i;

builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
g_variant_builder_add_parsed (builder, &quot;{'width', &lt;%i&gt;}&quot;, 600);
g_variant_builder_add_parsed (builder, &quot;{'title', &lt;%s&gt;}&quot;, &quot;foo&quot;);
g_variant_builder_add_parsed (builder, &quot;{'transparency', &lt;0.5&gt;}&quot;);
return g_variant_builder_end (builder);
}
&lt;/programlisting&gt;

Since: 2.26

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> a text format #GVariant
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments as per @format
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_strcasecmp">
<description>
A case-insensitive string comparison, corresponding to the standard
strcasecmp() function on platforms which support it.

Deprecated:2.2: See g_strncasecmp() for a discussion of why this function 
is deprecated and how to replace it.

</description>
<parameters>
<parameter name="s1">
<parameter_description> a string.
</parameter_description>
</parameter>
<parameter name="s2">
<parameter_description> a string to compare with @s1.
</parameter_description>
</parameter>
</parameters>
<return> 0 if the strings match, a negative value if @s1 &lt; @s2, 
or a positive value if @s1 &gt; @s2.

</return>
</function>

<function name="g_propagate_error">
<description>
If @dest is %NULL, free @src; otherwise, moves @src into *@dest.
The error variable @dest points to must be %NULL.

</description>
<parameters>
<parameter name="dest">
<parameter_description> error return location
</parameter_description>
</parameter>
<parameter name="src">
<parameter_description> error to move into the return location
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_new_int16">
<description>
Creates a new int16 #GVariant instance.

Since: 2.24

</description>
<parameters>
<parameter name="int16">
<parameter_description> a #gint16 value
</parameter_description>
</parameter>
</parameters>
<return> a new int16 #GVariant instance
</return>
</function>

<function name="g_variant_iter_new">
<description>
Creates a heap-allocated #GVariantIter for iterating over the items
in @value.

Use g_variant_iter_free() to free the return value when you no longer
need it.

A reference is taken to @value and will be released only when
g_variant_iter_free() is called.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a container #GVariant
</parameter_description>
</parameter>
</parameters>
<return> a new heap-allocated #GVariantIter
</return>
</function>

<function name="g_string_equal">
<description>
Compares two strings for equality, returning %TRUE if they are equal. 
For use with #GHashTable.


</description>
<parameters>
<parameter name="v">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="v2">
<parameter_description> another #GString
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if they strings are the same length and contain the 
same bytes
</return>
</function>

<function name="g_checksum_type_get_length">
<description>
Gets the length in bytes of digests of type @checksum_type

Since: 2.16

</description>
<parameters>
<parameter name="checksum_type">
<parameter_description> a #GChecksumType
</parameter_description>
</parameter>
</parameters>
<return> the checksum length, or -1 if @checksum_type is
not supported.

</return>
</function>

<function name="g_main_current_source">
<description>
Returns the currently firing source for this thread.

Since: 2.12

</description>
<parameters>
</parameters>
<return> The currently firing source or %NULL.

</return>
</function>

<function name="g_key_file_set_double_list">
<description>
Associates a list of double values with @key under
@group_name.  If @key cannot be found then it is created.

Since: 2.12

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="list">
<parameter_description> an array of double values
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> number of double values in @list
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_enum_register_static">
<description>
Registers a new static enumeration type with the name @name.

It is normally more convenient to let &lt;link
linkend=&quot;glib-mkenums&quot;&gt;glib-mkenums&lt;/link&gt; generate a
my_enum_get_type() function from a usual C enumeration definition
than to write one yourself using g_enum_register_static().


</description>
<parameters>
<parameter name="name">
<parameter_description> A nul-terminated string used as the name of the new type.
</parameter_description>
</parameter>
<parameter name="const_static_values">
<parameter_description> An array of #GEnumValue structs for the possible
enumeration values. The array is terminated by a struct with all
members being 0. GObject keeps a reference to the data, so it cannot
be stack-allocated.
</parameter_description>
</parameter>
</parameters>
<return> The new type identifier.
</return>
</function>

<function name="g_sequence_iter_get_position">
<description>
Returns the position of @iter

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return> the position of @iter

</return>
</function>

<function name="g_utf8_normalize">
<description>
Converts a string into canonical form, standardizing
such issues as whether a character with an accent
is represented as a base character and combining
accent or as a single precomposed character. The
string has to be valid UTF-8, otherwise %NULL is
returned. You should generally call g_utf8_normalize()
before comparing two Unicode strings.

The normalization mode %G_NORMALIZE_DEFAULT only
standardizes differences that do not affect the
text content, such as the above-mentioned accent
representation. %G_NORMALIZE_ALL also standardizes
the &quot;compatibility&quot; characters in Unicode, such
as SUPERSCRIPT THREE to the standard forms
(in this case DIGIT THREE). Formatting information
may be lost but for most text operations such
characters should be considered the same.

%G_NORMALIZE_DEFAULT_COMPOSE and %G_NORMALIZE_ALL_COMPOSE
are like %G_NORMALIZE_DEFAULT and %G_NORMALIZE_ALL,
but returned a result with composed forms rather
than a maximally decomposed form. This is often
useful if you intend to convert the string to
a legacy encoding or pass it to a system with
less capable Unicode handling.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> length of @str, in bytes, or -1 if @str is nul-terminated.
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> the type of normalization to perform.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string, that is the
normalized form of @str, or %NULL if @str is not
valid UTF-8.
</return>
</function>

<function name="g_private_get">
<description>
Returns the pointer keyed to @private_key for the current thread. If
g_private_set() hasn't been called for the current @private_key and
thread yet, this pointer will be %NULL.

This function can be used even if g_thread_init() has not yet been
called, and, in that case, will return the value of @private_key
casted to #gpointer. Note however, that private data set
&lt;emphasis&gt;before&lt;/emphasis&gt; g_thread_init() will
&lt;emphasis&gt;not&lt;/emphasis&gt; be retained &lt;emphasis&gt;after&lt;/emphasis&gt; the
call. Instead, %NULL will be returned in all threads directly after
g_thread_init(), regardless of any g_private_set() calls issued
before threading system intialization.

</description>
<parameters>
<parameter name="private_key">
<parameter_description> a #GPrivate.
</parameter_description>
</parameter>
</parameters>
<return> the corresponding pointer.
</return>
</function>

<function name="g_match_info_fetch">
<description>
Retrieves the text matching the @match_num&lt;!-- --&gt;'th capturing
parentheses. 0 is the full text of the match, 1 is the first paren
set, 2 the second, and so on.

If @match_num is a valid sub pattern but it didn't match anything
(e.g. sub pattern 1, matching &quot;b&quot; against &quot;(a)?b&quot;) then an empty
string is returned.

If the match was obtained using the DFA algorithm, that is using
g_regex_match_all() or g_regex_match_all_full(), the retrieved
string is not that of a set of parentheses but that of a matched
substring. Substrings are matched in reverse order of length, so
0 is the longest match.

The string is fetched from the string passed to the match function,
so you cannot call this function after freeing the string.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> #GMatchInfo structure
</parameter_description>
</parameter>
<parameter name="match_num">
<parameter_description> number of the sub expression
</parameter_description>
</parameter>
</parameters>
<return> The matched substring, or %NULL if an error
occurred. You have to free the string yourself

</return>
</function>

<function name="g_main_context_acquire">
<description>
Tries to become the owner of the specified context.
If some other thread is the owner of the context,
returns %FALSE immediately. Ownership is properly
recursive: the owner can require ownership again
and will release ownership when g_main_context_release()
is called as many times as g_main_context_acquire().

You must be the owner of a context before you
can call g_main_context_prepare(), g_main_context_query(),
g_main_context_check(), g_main_context_dispatch().


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the operation succeeded, and
this thread is now the owner of @context.
</return>
</function>

<function name="g_file_set_contents">
<description>
Writes all of @contents to a file named @filename, with good error checking.
If a file called @filename already exists it will be overwritten.

This write is atomic in the sense that it is first written to a temporary
file which is then renamed to the final name. Notes:
&lt;itemizedlist&gt;
&lt;listitem&gt;
On Unix, if @filename already exists hard links to @filename will break.
Also since the file is recreated, existing permissions, access control
lists, metadata etc. may be lost. If @filename is a symbolic link,
the link itself will be replaced, not the linked file.
&lt;/listitem&gt;
&lt;listitem&gt;
On Windows renaming a file will not remove an existing file with the
new name, so on Windows there is a race condition between the existing
file being removed and the temporary file being renamed.
&lt;/listitem&gt;
&lt;listitem&gt;
On Windows there is no way to remove a file that is open to some
process, or mapped into memory. Thus, this function will fail if
@filename already exists and is open.
&lt;/listitem&gt;
&lt;/itemizedlist&gt;

If the call was sucessful, it returns %TRUE. If the call was not successful,
it returns %FALSE and sets @error. The error domain is #G_FILE_ERROR.
Possible error codes are those in the #GFileError enumeration.

Since: 2.8

</description>
<parameters>
<parameter name="filename">
<parameter_description> name of a file to write @contents to, in the GLib file name
encoding
</parameter_description>
</parameter>
<parameter name="contents">
<parameter_description> string to write to the file
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> length of @contents, or -1 if @contents is a nul-terminated string
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success, %FALSE if an error occurred

</return>
</function>

<function name="g_type_depth">
<description>
Returns the length of the ancestry of the passed in type. This
includes the type itself, so that e.g. a fundamental type has depth 1.


</description>
<parameters>
<parameter name="type">
<parameter_description> A #GType value.
</parameter_description>
</parameter>
</parameters>
<return> The depth of @type.
</return>
</function>

<function name="g_hash_table_get_keys">
<description>
Retrieves every key inside @hash_table. The returned data is valid
until @hash_table is modified.

Since: 2.14

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable
</parameter_description>
</parameter>
</parameters>
<return> a #GList containing all the keys inside the hash
table. The content of the list is owned by the hash table and
should not be modified or freed. Use g_list_free() when done
using the list.

</return>
</function>

<function name="g_byte_array_ref">
<description>
Atomically increments the reference count of @array by one. This
function is MT-safe and may be called from any thread.

Since: 2.22

</description>
<parameters>
<parameter name="array">
<parameter_description> A #GByteArray.
</parameter_description>
</parameter>
</parameters>
<return> The passed in #GByteArray.

</return>
</function>

<function name="g_key_file_set_boolean_list">
<description>
Associates a list of boolean values with @key under @group_name.  
If @key cannot be found then it is created.
If @group_name is %NULL, the start_group is used.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="list">
<parameter_description> an array of boolean values
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> length of @list
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_set_data_full">
<description>
Like g_object_set_data() except it adds notification
for when the association is destroyed, either by setting it
to a different value or when the object is destroyed.

Note that the @destroy callback is not called if @data is %NULL.

</description>
<parameters>
<parameter name="object">
<parameter_description> #GObject containing the associations
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> name of the key
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to associate with that key
</parameter_description>
</parameter>
<parameter name="destroy">
<parameter_description> function to call when the association is destroyed
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_get_param">
<description>
Get the contents of a %G_TYPE_PARAM #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue whose type is derived from %G_TYPE_PARAM
</parameter_description>
</parameter>
</parameters>
<return> #GParamSpec content of @value
</return>
</function>

<function name="g_unichar_totitle">
<description>
Converts a character to the titlecase.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> the result of converting @c to titlecase.
If @c is not an uppercase or lowercase character,
@c is returned unchanged.
</return>
</function>

<function name="g_main_loop_unref">
<description>
Decreases the reference count on a #GMainLoop object by one. If
the result is zero, free the loop and free all associated memory.

</description>
<parameters>
<parameter name="loop">
<parameter_description> a #GMainLoop
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_init_with_debug_flags">
<description>
Similar to g_type_init(), but additionally sets debug flags.

</description>
<parameters>
<parameter name="debug_flags">
<parameter_description> Bitwise combination of #GTypeDebugFlags values for
debugging purposes.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_get_added">
<description>
Gets the time the bookmark for @uri was added to @bookmark

In the event the URI cannot be found, -1 is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a timestamp

</return>
</function>

<function name="g_option_group_set_translation_domain">
<description>
A convenience function to use gettext() for translating
user-visible strings. 

Since: 2.6

</description>
<parameters>
<parameter name="group">
<parameter_description> a #GOptionGroup
</parameter_description>
</parameter>
<parameter name="domain">
<parameter_description> the domain to use
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cache_destroy">
<description>
Frees the memory allocated for the #GCache.

Note that it does not destroy the keys and values which were
contained in the #GCache.

</description>
<parameters>
<parameter name="cache">
<parameter_description> a #GCache.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_type_is_variant">
<description>
Determines if the given @type is the variant type.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is the variant type
</return>
</function>

<function name="g_checksum_free">
<description>
Frees the memory allocated for @checksum.

Since: 2.16

</description>
<parameters>
<parameter name="checksum">
<parameter_description> a #GChecksum
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_freopen">
<description>
A wrapper for the POSIX freopen() function. The freopen() function
opens a file and associates it with an existing stream.

See your C library manual for more details about freopen().

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> a string describing the mode in which the file should be 
opened
</parameter_description>
</parameter>
<parameter name="stream">
<parameter_description> an existing stream which will be reused, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> A &lt;type&gt;FILE&lt;/type&gt; pointer if the file was successfully
opened, or %NULL if an error occurred.

</return>
</function>

<function name="g_tree_lookup">
<description>
Gets the value corresponding to the given key. Since a #GTree is 
automatically balanced as key/value pairs are added, key lookup is very 
fast.


</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the key to look up.
</parameter_description>
</parameter>
</parameters>
<return> the value corresponding to the key, or %NULL if the key was
not found.
</return>
</function>

<function name="g_hash_table_destroy">
<description>
Destroys all keys and values in the #GHashTable and decrements its
reference count by 1. If keys and/or values are dynamically allocated,
you should either free them first or create the #GHashTable with destroy
notifiers using g_hash_table_new_full(). In the latter case the destroy
functions you supplied will be called on all keys and values during the
destruction phase.

</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_datalist_id_set_data_full">
<description>
Sets the data corresponding to the given #GQuark id, and the
function to be called when the element is removed from the datalist.
Any previous data with the same key is removed, and its destroy
function is called.

</description>
<parameters>
<parameter name="datalist">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="key_id">
<parameter_description> the #GQuark to identify the data element.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data element or %NULL to remove any previous element
corresponding to @key_id.
</parameter_description>
</parameter>
<parameter name="destroy_func">
<parameter_description> the function to call when the data element is
removed. This function will be called with the data
element and can be used to free any memory allocated
for it. If @data is %NULL, then @destroy_func must
also be %NULL.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_test_timer_last">
<description>
Report the last result of g_test_timer_elapsed().

Since: 2.16

</description>
<parameters>
</parameters>
<return> the last result of g_test_timer_elapsed(), as a double

</return>
</function>

<function name="g_unichar_iswide">
<description>
Determines if a character is typically rendered in a double-width
cell.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the character is wide
</return>
</function>

<function name="g_slist_remove_link">
<description>
Removes an element from a #GSList, without 
freeing the element. The removed element's next 
link is set to %NULL, so that it becomes a
self-contained list with one element.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="link_">
<parameter_description> an element in the #GSList
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GSList, without the element
</return>
</function>

<function name="g_regex_get_capture_count">
<description>
Returns the number of capturing subpatterns in the pattern.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex
</parameter_description>
</parameter>
</parameters>
<return> the number of capturing subpatterns

</return>
</function>

<function name="g_bookmark_file_get_modified">
<description>
Gets the time when the bookmark for @uri was last modified.

In the event the URI cannot be found, -1 is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a timestamp

</return>
</function>

<function name="g_type_module_set_name">
<description>
Sets the name for a #GTypeModule 

</description>
<parameters>
<parameter name="module">
<parameter_description> a #GTypeModule.
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> a human-readable name to use in error messages.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_write_unichar">
<description>
Writes a Unicode character to @channel.
This function cannot be called on a channel with %NULL encoding.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="thechar">
<parameter_description> a character
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to return an error of type #GConvertError
or #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> a #GIOStatus
</return>
</function>

<function name="g_random_double_range">
<description>
Returns a random #gdouble equally distributed over the range [@begin..@end).


</description>
<parameters>
<parameter name="begin">
<parameter_description> lower closed bound of the interval.
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> upper open bound of the interval.
</parameter_description>
</parameter>
</parameters>
<return> A random number.
</return>
</function>

<function name="g_time_val_add">
<description>
Adds the given number of microseconds to @time_. @microseconds can
also be negative to decrease the value of @time_.

</description>
<parameters>
<parameter name="time_">
<parameter_description> a #GTimeVal
</parameter_description>
</parameter>
<parameter name="microseconds">
<parameter_description> number of microseconds to add to @time
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_push_allocator">
<description>
Sets the allocator to use to allocate #GSList elements. Use
g_slist_pop_allocator() to restore the previous allocator.

Note that this function is not available if GLib has been compiled
with &lt;option&gt;--disable-mem-pools&lt;/option&gt;

Deprecated: 2.10: It does nothing, since #GSList has been converted
to the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt;

</description>
<parameters>
<parameter name="dummy">
<parameter_description> the #GAllocator to use when allocating #GSList elements.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_blow_chunks">
<description>
Calls g_mem_chunk_clean() on all #GMemChunk objects.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_child_watch_add">
<description>
Sets a function to be called when the child indicated by @pid 
exits, at a default priority, #G_PRIORITY_DEFAULT.

If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes() 
you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to 
the spawn function for the child watching to work.

Note that on platforms where #GPid must be explicitly closed
(see g_spawn_close_pid()) @pid must not be closed while the
source is still active. Typically, you will want to call
g_spawn_close_pid() in the callback function for the source.

GLib supports only a single callback per process id.

This internally creates a main loop source using 
g_child_watch_source_new() and attaches it to the main loop context 
using g_source_attach(). You can do these steps manually if you 
need greater control.

Since: 2.4

</description>
<parameters>
<parameter name="pid">
<parameter_description>      process id to watch. On POSIX the pid of a child process. On
Windows a handle for a process (which doesn't have to be a child).
</parameter_description>
</parameter>
<parameter name="function">
<parameter_description> function to call
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description>     data to pass to @function
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) of the event source.

</return>
</function>

<function name="g_type_module_use">
<description>
Increases the use count of a #GTypeModule by one. If the
use count was zero before, the plugin will be loaded.
If loading the plugin fails, the use count is reset to 
its prior value. 


</description>
<parameters>
<parameter name="module">
<parameter_description> a #GTypeModule
</parameter_description>
</parameter>
</parameters>
<return> %FALSE if the plugin needed to be loaded and
loading the plugin failed.
</return>
</function>

<function name="g_object_class_install_property">
<description>
Installs a new property. This is usually done in the class initializer.

Note that it is possible to redefine a property in a derived class,
by installing a property with the same name. This can be useful at times,
e.g. to change the range of allowed values or the default value.

</description>
<parameters>
<parameter name="oclass">
<parameter_description> a #GObjectClass
</parameter_description>
</parameter>
<parameter name="property_id">
<parameter_description> the id for the new property
</parameter_description>
</parameter>
<parameter name="pspec">
<parameter_description> the #GParamSpec for the new property
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_set_buffer_size">
<description>
Sets the buffer size.

</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="size">
<parameter_description> the size of the buffer, or 0 to let GLib pick a good size
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_name">
<description>
Given the signal's identifier, finds its name.

Two different signals may have the same name, if they have differing types.


</description>
<parameters>
<parameter name="signal_id">
<parameter_description> the signal's identifying number.
</parameter_description>
</parameter>
</parameters>
<return> the signal name, or %NULL if the signal number was invalid.
</return>
</function>

<function name="g_value_take_boxed">
<description>
Sets the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed
and takes over the ownership of the callers reference to @v_boxed;
the caller doesn't have to unref it any more.

Since: 2.4

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_BOXED derived type
</parameter_description>
</parameter>
<parameter name="v_boxed">
<parameter_description> duplicated unowned boxed value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_int64_hash">
<description>
Converts a pointer to a #gint64 to a hash value.
It can be passed to g_hash_table_new() as the @hash_func parameter, 
when using pointers to 64-bit integers values as keys in a #GHashTable.

Since: 2.22

</description>
<parameters>
<parameter name="v">
<parameter_description> a pointer to a #gint64 key
</parameter_description>
</parameter>
</parameters>
<return> a hash value corresponding to the key.

</return>
</function>

<function name="g_error_free">
<description>
Frees a #GError and associated resources.

</description>
<parameters>
<parameter name="error">
<parameter_description> a #GError
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_insert_before">
<description>
Inserts a #GNode beneath the parent before the given sibling.


</description>
<parameters>
<parameter name="parent">
<parameter_description> the #GNode to place @node under
</parameter_description>
</parameter>
<parameter name="sibling">
<parameter_description> the sibling #GNode to place @node before. 
If sibling is %NULL, the node is inserted as the last child of @parent.
</parameter_description>
</parameter>
<parameter name="node">
<parameter_description> the #GNode to insert
</parameter_description>
</parameter>
</parameters>
<return> the inserted #GNode
</return>
</function>

<function name="g_variant_new_from_data">
<description>
Creates a new #GVariant instance from serialised data.

@type is the type of #GVariant instance that will be constructed.
The interpretation of @data depends on knowing the type.

@data is not modified by this function and must remain valid with an
unchanging value until such a time as @notify is called with
@user_data.  If the contents of @data change before that time then
the result is undefined.

If @data is trusted to be serialised data in normal form then
@trusted should be %TRUE.  This applies to serialised data created
within this process or read from a trusted location on the disk (such
as a file installed in /usr/lib alongside your application).  You
should set trusted to %FALSE if @data is read from the network, a
file in the user's home directory, etc.

@notify will be called with @user_data when @data is no longer
needed.  The exact time of this call is unspecified and might even be
before this function returns.

Since: 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a definite #GVariantType
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the serialised data
</parameter_description>
</parameter>
<parameter name="size">
<parameter_description> the size of @data
</parameter_description>
</parameter>
<parameter name="trusted">
<parameter_description> %TRUE if @data is definitely in normal form
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description> function to call when @data is no longer needed
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> data for @notify
</parameter_description>
</parameter>
</parameters>
<return> a new floating #GVariant of type @type
</return>
</function>

<function name="g_timeout_add_seconds">
<description>
Sets a function to be called at regular intervals with the default
priority, #G_PRIORITY_DEFAULT. The function is called repeatedly until
it returns %FALSE, at which point the timeout is automatically destroyed
and the function will not be called again.

This internally creates a main loop source using 
g_timeout_source_new_seconds() and attaches it to the main loop context 
using g_source_attach(). You can do these steps manually if you need 
greater control. Also see g_timout_add_seconds_full().

Since: 2.14

</description>
<parameters>
<parameter name="interval">
<parameter_description> the time between calls to the function, in seconds
</parameter_description>
</parameter>
<parameter name="function">
<parameter_description> function to call
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to pass to @function
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) of the event source.

</return>
</function>

<function name="g_value_init">
<description>
Initializes @value with the default value of @type.


</description>
<parameters>
<parameter name="value">
<parameter_description> A zero-filled (uninitialized) #GValue structure.
</parameter_description>
</parameter>
<parameter name="g_type">
<parameter_description> Type the #GValue should hold values of.
</parameter_description>
</parameter>
</parameters>
<return> the #GValue structure that has been passed in
</return>
</function>

<function name="g_type_get_qdata">
<description>
Obtains data which has previously been attached to @type
with g_type_set_qdata().


</description>
<parameters>
<parameter name="type">
<parameter_description> a #GType
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> a #GQuark id to identify the data
</parameter_description>
</parameter>
</parameters>
<return> the data, or %NULL if no data was found
</return>
</function>

<function name="g_thread_join">
<description>
Waits until @thread finishes, i.e. the function @func, as given to
g_thread_create(), returns or g_thread_exit() is called by @thread.
All resources of @thread including the #GThread struct are released.
@thread must have been created with @joinable=%TRUE in
g_thread_create(). The value returned by @func or given to
g_thread_exit() by @thread is returned by this function.

</description>
<parameters>
<parameter name="thread">
<parameter_description> a #GThread to be waited for.
</parameter_description>
</parameter>
</parameters>
<return> the return value of the thread.
</return>
</function>

<function name="g_unichar_break_type">
<description>
Determines the break type of @c. @c should be a Unicode character
(to derive a character from UTF-8 encoded text, use
g_utf8_get_char()). The break type is used to find word and line
breaks (&quot;text boundaries&quot;), Pango implements the Unicode boundary
resolution algorithms and normally you would use a function such
as pango_break() instead of caring about break types yourself.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> the break type of @c
</return>
</function>

<function name="g_hash_table_steal">
<description>
Removes a key and its associated value from a #GHashTable without
calling the key and value destroy functions.


</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the key to remove.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the key was found and removed from the #GHashTable.
</return>
</function>

<function name="g_byte_array_set_size">
<description>
Sets the size of the #GByteArray, expanding it if necessary.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GByteArray.
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the new size of the #GByteArray.
</parameter_description>
</parameter>
</parameters>
<return> the #GByteArray.
</return>
</function>

<function name="g_string_new_len">
<description>
Creates a new #GString with @len bytes of the @init buffer.  
Because a length is provided, @init need not be nul-terminated,
and can contain embedded nul bytes.

Since this function does not stop at nul bytes, it is the caller's
responsibility to ensure that @init has at least @len addressable 
bytes.


</description>
<parameters>
<parameter name="init">
<parameter_description> initial contents of the string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> length of @init to use
</parameter_description>
</parameter>
</parameters>
<return> a new #GString
</return>
</function>

<function name="g_ptr_array_foreach">
<description>
Calls a function for each element of a #GPtrArray.

Since: 2.4

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each array element
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_push_tail">
<description>
Adds a new element at the tail of the queue.

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_binding_get_flags">
<description>
Retrieves the flags passed when constructing the #GBinding

Since: 2.26

</description>
<parameters>
<parameter name="binding">
<parameter_description> a #GBinding
</parameter_description>
</parameter>
</parameters>
<return> the #GBindingFlags used by the #GBinding

</return>
</function>

<function name="g_access">
<description>
A wrapper for the POSIX access() function. This function is used to
test a pathname for one or several of read, write or execute
permissions, or just existence.

On Windows, the file protection mechanism is not at all POSIX-like,
and the underlying function in the C library only checks the
FAT-style READONLY attribute, and does not look at the ACL of a
file at all. This function is this in practise almost useless on
Windows. Software that needs to handle file permissions on Windows
more exactly should use the Win32 API.

See your C library manual for more details about access().

Since: 2.8

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> as in access()
</parameter_description>
</parameter>
</parameters>
<return> zero if the pathname refers to an existing file system
object that has all the tested permissions, or -1 otherwise or on
error.

</return>
</function>

<function name="g_variant_new_parsed_va">
<description>
Parses @format and returns the result.

This is the version of g_variant_new_parsed() intended to be used
from libraries.

The return value will be floating if it was a newly created GVariant
instance.  In the case that @format simply specified the collection
of a #GVariant pointer (eg: @format was &quot;%*&quot;) then the collected
#GVariant pointer will be returned unmodified, without adding any
additional references.

In order to behave correctly in all cases it is necessary for the
calling function to g_variant_ref_sink() the return result before
returning control to the user that originally provided the pointer.
At this point, the caller will have their own full reference to the
result.  This can also be done by adding the result to a container,
or by passing it to another g_variant_new() call.

</description>
<parameters>
<parameter name="format">
<parameter_description> a text format #GVariant
</parameter_description>
</parameter>
<parameter name="app">
<parameter_description> a pointer to a #va_list
</parameter_description>
</parameter>
</parameters>
<return> a new, usually floating, #GVariant
</return>
</function>

<function name="g_signal_new_class_handler">
<description>
Creates a new signal. (This is usually done in the class initializer.)

This is a variant of g_signal_new() that takes a C callback instead
off a class offset for the signal's class handler. This function
doesn't need a function pointer exposed in the class structure of
an object definition, instead the function pointer is passed
directly and can be overriden by derived classes with
g_signal_override_class_closure() or
g_signal_override_class_handler()and chained to with
g_signal_chain_from_overridden() or
g_signal_chain_from_overridden_handler().

See g_signal_new() for information about signal names.

Since: 2.18

</description>
<parameters>
<parameter name="signal_name">
<parameter_description> the name for the signal
</parameter_description>
</parameter>
<parameter name="itype">
<parameter_description> the type this signal pertains to. It will also pertain to
types which are derived from this type.
</parameter_description>
</parameter>
<parameter name="signal_flags">
<parameter_description> a combination of #GSignalFlags specifying detail of when
the default handler is to be invoked. You should at least specify
%G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST.
</parameter_description>
</parameter>
<parameter name="class_handler">
<parameter_description> a #GCallback which acts as class implementation of
this signal. Used to invoke a class method generically. Pass %NULL to
not associate a class method with this signal.
</parameter_description>
</parameter>
<parameter name="accumulator">
<parameter_description> the accumulator for this signal; may be %NULL.
</parameter_description>
</parameter>
<parameter name="accu_data">
<parameter_description> user data for the @accumulator.
</parameter_description>
</parameter>
<parameter name="c_marshaller">
<parameter_description> the function to translate arrays of parameter values to
signal emissions into C language callback invocations.
</parameter_description>
</parameter>
<parameter name="return_type">
<parameter_description> the type of return value, or #G_TYPE_NONE for a signal
without a return value.
</parameter_description>
</parameter>
<parameter name="n_params">
<parameter_description> the number of parameter types to follow.
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> a list of types, one for each parameter.
</parameter_description>
</parameter>
</parameters>
<return> the signal id

</return>
</function>

<function name="g_option_group_set_parse_hooks">
<description>
Associates two functions with @group which will be called 
from g_option_context_parse() before the first option is parsed
and after the last option has been parsed, respectively.

Note that the user data to be passed to @pre_parse_func and
@post_parse_func can be specified when constructing the group
with g_option_group_new().

Since: 2.6

</description>
<parameters>
<parameter name="group">
<parameter_description> a #GOptionGroup
</parameter_description>
</parameter>
<parameter name="pre_parse_func">
<parameter_description> a function to call before parsing, or %NULL
</parameter_description>
</parameter>
<parameter name="post_parse_func">
<parameter_description> a function to call after parsing, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_add_application">
<description>
Adds the application with @name and @exec to the list of
applications that have registered a bookmark for @uri into
@bookmark.

Every bookmark inside a #GBookmarkFile must have at least an
application registered.  Each application must provide a name, a
command line useful for launching the bookmark, the number of times
the bookmark has been registered by the application and the last
time the application registered this bookmark.

If @name is %NULL, the name of the application will be the
same returned by g_get_application_name(); if @exec is %NULL, the
command line will be a composition of the program name as
returned by g_get_prgname() and the &quot;%u&quot; modifier, which will be
expanded to the bookmark's URI.

This function will automatically take care of updating the
registrations count and timestamping in case an application
with the same @name had already registered a bookmark for
@uri inside @bookmark.

If no bookmark for @uri is found, one is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> the name of the application registering the bookmark
or %NULL
</parameter_description>
</parameter>
<parameter name="exec">
<parameter_description> command line to be used to launch the bookmark or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_reverse">
<description>
Reverses a #GSList.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
</parameters>
<return> the start of the reversed #GSList
</return>
</function>

<function name="g_type_class_peek_parent">
<description>
This is a convenience function often needed in class initializers.
It returns the class structure of the immediate parent type of the
class passed in.  Since derived classes hold a reference count on
their parent classes as long as they are instantiated, the returned
class will always exist. This function is essentially equivalent
to:

&lt;programlisting&gt;
g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)));
&lt;/programlisting&gt;


</description>
<parameters>
<parameter name="g_class">
<parameter_description> The #GTypeClass structure to retrieve the parent class for.
</parameter_description>
</parameter>
</parameters>
<return> The parent class of @g_class.
</return>
</function>

<function name="g_option_context_get_help">
<description>
Returns a formatted, translated help text for the given context.
To obtain the text produced by &lt;option&gt;--help&lt;/option&gt;, call
&lt;literal&gt;g_option_context_get_help (context, TRUE, NULL)&lt;/literal&gt;.
To obtain the text produced by &lt;option&gt;--help-all&lt;/option&gt;, call
&lt;literal&gt;g_option_context_get_help (context, FALSE, NULL)&lt;/literal&gt;.
To obtain the help text for an option group, call
&lt;literal&gt;g_option_context_get_help (context, FALSE, group)&lt;/literal&gt;.

Since: 2.14

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="main_help">
<parameter_description> if %TRUE, only include the main group 
</parameter_description>
</parameter>
<parameter name="group">
<parameter_description> the #GOptionGroup to create help for, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> A newly allocated string containing the help text

</return>
</function>

<function name="g_main_context_new">
<description>
Creates a new #GMainContext structure.


</description>
<parameters>
</parameters>
<return> the new #GMainContext
</return>
</function>

<function name="g_vsnprintf">
<description>
A safer form of the standard vsprintf() function. The output is guaranteed
to not exceed @n characters (including the terminating nul character), so 
it is easy to ensure that a buffer overflow cannot occur.

See also g_strdup_vprintf().

In versions of GLib prior to 1.2.3, this function may return -1 if the 
output was truncated, and the truncated string may not be nul-terminated.
In versions prior to 1.3.12, this function returns the length of the output 
string.

The return value of g_vsnprintf() conforms to the vsnprintf() function 
as standardized in ISO C99. Note that this is different from traditional 
vsnprintf(), which returns the length of the output string.

The format string may contain positional parameters, as specified in 
the Single Unix Specification.


</description>
<parameters>
<parameter name="string">
<parameter_description> the buffer to hold the output.
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the maximum number of bytes to produce (including the 
terminating nul character).
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> a standard printf() format string, but notice 
&lt;link linkend=&quot;string-precision&quot;&gt;string precision pitfalls&lt;/link&gt;.
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> the list of arguments to insert in the output.
</parameter_description>
</parameter>
</parameters>
<return> the number of bytes which would be produced if the buffer 
was large enough.
</return>
</function>

<function name="g_object_set_valist">
<description>
Sets properties on an object.

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="first_property_name">
<parameter_description> name of the first property to set
</parameter_description>
</parameter>
<parameter name="var_args">
<parameter_description> value for the first property, followed optionally by more
name/value pairs, followed by %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_datalist_id_remove_data">
<description>
Removes an element, using its #GQuark identifier.

</description>
<parameters>
<parameter name="dl">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="q">
<parameter_description> the #GQuark identifying the data element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_set_error_literal">
<description>
Does nothing if @err is %NULL; if @err is non-%NULL, then *@err
must be %NULL. A new #GError is created and assigned to *@err.
Unlike g_set_error(), @message is not a printf()-style format string.
Use this function if @message contains text you don't have control over,
that could include printf() escape sequences.

Since: 2.18

</description>
<parameters>
<parameter name="err">
<parameter_description> a return location for a #GError, or %NULL
</parameter_description>
</parameter>
<parameter name="domain">
<parameter_description> error domain
</parameter_description>
</parameter>
<parameter name="code">
<parameter_description> error code
</parameter_description>
</parameter>
<parameter name="message">
<parameter_description> error message
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_array_insert_vals">
<description>
Inserts @len elements into a #GArray at the given index.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index to place the elements at.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> a pointer to the elements to insert.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the number of elements to insert.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_type_register_fundamental">
<description>
Registers @type_id as the predefined identifier and @type_name as the
name of a fundamental type.  The type system uses the information
contained in the #GTypeInfo structure pointed to by @info and the
#GTypeFundamentalInfo structure pointed to by @finfo to manage the
type and its instances.  The value of @flags determines additional
characteristics of the fundamental type.


</description>
<parameters>
<parameter name="type_id">
<parameter_description> A predefined type identifier.
</parameter_description>
</parameter>
<parameter name="type_name">
<parameter_description> 0-terminated string used as the name of the new type.
</parameter_description>
</parameter>
<parameter name="info">
<parameter_description> The #GTypeInfo structure for this type.
</parameter_description>
</parameter>
<parameter name="finfo">
<parameter_description> The #GTypeFundamentalInfo structure for this type.
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> Bitwise combination of #GTypeFlags values.
</parameter_description>
</parameter>
</parameters>
<return> The predefined type identifier.
</return>
</function>

<function name="g_param_spec_ref_sink">
<description>
Convenience function to ref and sink a #GParamSpec.

Since: 2.10

</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
</parameters>
<return> the #GParamSpec that was passed into this function
</return>
</function>

<function name="g_string_prepend">
<description>
Adds a string on to the start of a #GString, 
expanding it if necessary.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> the string to prepend on the start of @string
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_string_append_unichar">
<description>
Converts a Unicode character into UTF-8, and appends it
to the string.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="wc">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_binding_get_target_property">
<description>
Retrieves the name of the property of #GBinding:target used as the target
of the binding

Since: 2.26

</description>
<parameters>
<parameter name="binding">
<parameter_description> a #GBinding
</parameter_description>
</parameter>
</parameters>
<return> the name of the target property

</return>
</function>

<function name="g_param_spec_uint64">
<description>
Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64
property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_option_context_get_ignore_unknown_options">
<description>
Returns whether unknown options are ignored or not. See
g_option_context_set_ignore_unknown_options().

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if unknown options are ignored.

</return>
</function>

<function name="g_object_remove_weak_pointer">
<description>
Removes a weak reference from @object that was previously added
using g_object_add_weak_pointer(). The @weak_pointer_location has
to match the one used with g_object_add_weak_pointer().

</description>
<parameters>
<parameter name="object">
<parameter_description> The object that is weak referenced.
</parameter_description>
</parameter>
<parameter name="weak_pointer_location">
<parameter_description> The memory address of a pointer.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_utf8_offset_to_pointer">
<description>
Converts from an integer character offset to a pointer to a position
within the string.

Since 2.10, this function allows to pass a negative @offset to
step backwards. It is usually worth stepping backwards from the end
instead of forwards if @offset is in the last fourth of the string,
since moving forward is about 3 times faster than moving backward.

&lt;note&gt;&lt;para&gt;
This function doesn't abort when reaching the end of @str. Therefore
you should be sure that @offset is within string boundaries before
calling that function. Call g_utf8_strlen() when unsure.

This limitation exists as this function is called frequently during
text rendering and therefore has to be as fast as possible.
&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="offset">
<parameter_description> a character offset within @str
</parameter_description>
</parameter>
</parameters>
<return> the resulting pointer
</return>
</function>

<function name="g_io_channel_get_encoding">
<description>
Gets the encoding for the input/output of the channel. 
The internal encoding is always UTF-8. The encoding %NULL 
makes the channel safe for binary data.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
</parameters>
<return> A string containing the encoding, this string is
owned by GLib and must not be freed.
</return>
</function>

<function name="g_win32_get_package_installation_directory_of_module">
<description>
This function tries to determine the installation directory of a
software package based on the location of a DLL of the software
package.

@hmodule should be the handle of a loaded DLL or %NULL. The
function looks up the directory that DLL was loaded from. If
@hmodule is NULL, the directory the main executable of the current
process is looked up. If that directory's last component is &quot;bin&quot;
or &quot;lib&quot;, its parent directory is returned, otherwise the directory
itself.

It thus makes sense to pass only the handle to a &quot;public&quot; DLL of a
software package to this function, as such DLLs typically are known
to be installed in a &quot;bin&quot; or occasionally &quot;lib&quot; subfolder of the
installation folder. DLLs that are of the dynamically loaded module
or plugin variety are often located in more private locations
deeper down in the tree, from which it is impossible for GLib to
deduce the root of the package installation.

The typical use case for this function is to have a DllMain() that
saves the handle for the DLL. Then when code in the DLL needs to
construct names of files in the installation tree it calls this
function passing the DLL handle.

Since: 2.16

</description>
<parameters>
<parameter name="hmodule">
<parameter_description> The Win32 handle for a DLL loaded into the current process, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a string containing the guessed installation directory for
the software package @hmodule is from. The string is in the GLib
file name encoding, i.e. UTF-8. The return value should be freed
with g_free() when not needed any longer. If the function fails
%NULL is returned.

</return>
</function>

<function name="g_sequence_insert_before">
<description>
Inserts a new item just before the item pointed to by @iter.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new item
</parameter_description>
</parameter>
</parameters>
<return> an iterator pointing to the new item

</return>
</function>

<function name="g_bookmark_file_load_from_file">
<description>
Loads a desktop bookmark file into an empty #GBookmarkFile structure.
If the file could not be loaded then @error is set to either a #GFileError
or #GBookmarkFileError.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> an empty #GBookmarkFile struct
</parameter_description>
</parameter>
<parameter name="filename">
<parameter_description> the path of a filename to load, in the GLib file name encoding
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a desktop bookmark file could be loaded

</return>
</function>

<function name="g_key_file_set_boolean">
<description>
Associates a new boolean value with @key under @group_name.
If @key cannot be found then it is created. 

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> %TRUE or %FALSE
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_ucs4_to_utf8">
<description>
Convert a string from a 32-bit fixed width representation as UCS-4.
to UTF-8. The result will be terminated with a 0 byte.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UCS-4 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length (number of characters) of @str to use. 
If @len &lt; 0, then the string is nul-terminated.
</parameter_description>
</parameter>
<parameter name="items_read">
<parameter_description> location to store number of characters read, or %NULL.
</parameter_description>
</parameter>
<parameter name="items_written">
<parameter_description> location to store number of bytes written or %NULL.
The value here stored does not include the trailing 0
byte. 
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError other than
%G_CONVERT_ERROR_NO_CONVERSION may occur.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to a newly allocated UTF-8 string.
This value must be freed with g_free(). If an
error occurs, %NULL will be returned and
@error set. In that case, @items_read will be
set to the position of the first invalid input 
character.
</return>
</function>

<function name="g_slist_free">
<description>
Frees all of the memory used by a #GSList.
The freed elements are returned to the slice allocator.

</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_remove">
<description>
Removes an element from a #GSList.
If two elements contain the same data, only the first is removed.
If none of the elements contain the data, the #GSList is unchanged.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data of the element to remove
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GSList
</return>
</function>

<function name="g_queue_peek_tail">
<description>
Returns the last element of the queue.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
</parameters>
<return> the data of the last element in the queue, or %NULL if the queue
is empty.
</return>
</function>

<function name="g_relation_print">
<description>
Outputs information about all records in a #GRelation, as well as
the indexes. It is for debugging.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="relation">
<parameter_description> a #GRelation.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_index">
<description>
Gets the position of the element containing 
the given data (starting from 0).


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to find
</parameter_description>
</parameter>
</parameters>
<return> the index of the element containing the data, 
or -1 if the data is not found
</return>
</function>

<function name="g_key_file_get_double_list">
<description>
Returns the values associated with @key under @group_name as
doubles. 

If @key cannot be found then %NULL is returned and @error is set to
#G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
with @key cannot be interpreted as doubles then %NULL is returned
and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.

Since: 2.12

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the number of doubles returned
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> the values associated with the key as a list of
doubles, or %NULL if the key was not found or could not be parsed.

</return>
</function>

<function name="g_variant_get_double">
<description>
Returns the double precision floating point value of @value.

It is an error to call this function with a @value of any type
other than %G_VARIANT_TYPE_DOUBLE.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a double #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> a #gdouble
</return>
</function>

<function name="g_utf8_casefold">
<description>
Converts a string into a form that is independent of case. The
result will not correspond to any particular case, but can be
compared for equality or ordered with the results of calling
g_utf8_casefold() on other strings.

Note that calling g_utf8_casefold() followed by g_utf8_collate() is
only an approximation to the correct linguistic case insensitive
ordering, though it is a fairly good one. Getting this exactly
right would require a more sophisticated collation function that
takes case sensitivity into account. GLib does not currently
provide such a function.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> length of @str, in bytes, or -1 if @str is nul-terminated.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string, that is a
case independent form of @str.
</return>
</function>

<function name="g_utf8_validate">
<description>
Validates UTF-8 encoded text. @str is the text to validate;
if @str is nul-terminated, then @max_len can be -1, otherwise
@max_len should be the number of bytes to validate.
If @end is non-%NULL, then the end of the valid range
will be stored there (i.e. the start of the first invalid 
character if some bytes were invalid, or the end of the text 
being validated otherwise).

Note that g_utf8_validate() returns %FALSE if @max_len is 
positive and NUL is met before @max_len bytes have been read.


</description>
<parameters>
<parameter name="str">
<parameter_description> a pointer to character data
</parameter_description>
</parameter>
<parameter name="max_len">
<parameter_description> max bytes to validate, or -1 to go until NUL
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> return location for end of valid data
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the text was valid UTF-8
</return>
</function>

<function name="g_value_take_variant">
<description>
Set the contents of a variant #GValue to @variant, and takes over
the ownership of the caller's reference to @variant;
the caller doesn't have to unref it any more (i.e. the reference
count of the variant is not increased).

It is a programmer error to pass a floating variant to this function.
In particular this means that callbacks in closures, and signal handlers
for signals of return type %G_TYPE_VARIANT, must never return floating
variants.

If you want the #GValue to hold its own reference to @variant, use
g_value_set_variant() instead.

This is an internal function introduced mainly for C marshallers.

Since: 2.26

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_VARIANT
</parameter_description>
</parameter>
<parameter name="variant">
<parameter_description> a #GVariant, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_utf8_collate_key">
<description>
Converts a string into a collation key that can be compared
with other collation keys produced by the same function using 
strcmp(). 

The results of comparing the collation keys of two strings 
with strcmp() will always be the same as comparing the two 
original keys with g_utf8_collate().

Note that this function depends on the 
&lt;link linkend=&quot;setlocale&quot;&gt;current locale&lt;/link&gt;.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-8 encoded string.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> length of @str, in bytes, or -1 if @str is nul-terminated.
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string. This string should
be freed with g_free() when you are done with it.
</return>
</function>

<function name="g_key_file_get_integer">
<description>
Returns the value associated with @key under @group_name as an
integer. 

If @key cannot be found then 0 is returned and @error is set to
#G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
with @key cannot be interpreted as an integer then 0 is returned
and @error is set to #G_KEY_FILE_ERROR_INVALID_VALUE.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> the value associated with the key as an integer, or
0 if the key was not found or could not be parsed.

</return>
</function>

<function name="g_unichar_get_mirror_char">
<description>
In Unicode, some characters are &lt;firstterm&gt;mirrored&lt;/firstterm&gt;. This
means that their images are mirrored horizontally in text that is laid
out from right to left. For instance, &quot;(&quot; would become its mirror image,
&quot;)&quot;, in right-to-left text.

If @ch has the Unicode mirrored property and there is another unicode
character that typically has a glyph that is the mirror image of @ch's
glyph and @mirrored_ch is set, it puts that character in the address
pointed to by @mirrored_ch.  Otherwise the original character is put.

Since: 2.4

</description>
<parameters>
<parameter name="ch">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
<parameter name="mirrored_ch">
<parameter_description> location to store the mirrored character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @ch has a mirrored character, %FALSE otherwise

</return>
</function>

<function name="g_convert_with_iconv">
<description>
Converts a string from one character set to another. 

Note that you should use g_iconv() for streaming 
conversions&lt;footnote id=&quot;streaming-state&quot;&gt;
&lt;para&gt;
Despite the fact that @byes_read can return information about partial 
characters, the &lt;literal&gt;g_convert_...&lt;/literal&gt; functions
are not generally suitable for streaming. If the underlying converter 
being used maintains internal state, then this won't be preserved 
across successive calls to g_convert(), g_convert_with_iconv() or 
g_convert_with_fallback(). (An example of this is the GNU C converter 
for CP1255 which does not emit a base character until it knows that 
the next character is not a mark that could combine with the base 
character.)
&lt;/para&gt;
&lt;/footnote&gt;. 


</description>
<parameters>
<parameter name="str">
<parameter_description>           the string to convert
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description>           the length of the string, or -1 if the string is 
nul-terminated&lt;footnoteref linkend=&quot;nul-unsafe&quot;/&gt;. 
</parameter_description>
</parameter>
<parameter name="converter">
<parameter_description>     conversion descriptor from g_iconv_open()
</parameter_description>
</parameter>
<parameter name="bytes_read">
<parameter_description>    location to store the number of bytes in the
input string that were successfully converted, or %NULL.
Even if the conversion was successful, this may be 
less than @len if there were partial characters
at the end of the input. If the error
#G_CONVERT_ERROR_ILLEGAL_SEQUENCE occurs, the value
stored will the byte offset after the last valid
input sequence.
</parameter_description>
</parameter>
<parameter name="bytes_written">
<parameter_description> the number of bytes stored in the output buffer (not 
including the terminating nul).
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description>         location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError may occur.
</parameter_description>
</parameter>
</parameters>
<return> If the conversion was successful, a newly allocated
nul-terminated string, which must be freed with
g_free(). Otherwise %NULL and @error will be set.
</return>
</function>

<function name="g_utf8_collate">
<description>
Compares two strings for ordering using the linguistically
correct rules for the &lt;link linkend=&quot;setlocale&quot;&gt;current locale&lt;/link&gt;. 
When sorting a large number of strings, it will be significantly 
faster to obtain collation keys with g_utf8_collate_key() and 
compare the keys with strcmp() when sorting instead of sorting 
the original strings.


</description>
<parameters>
<parameter name="str1">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
<parameter name="str2">
<parameter_description> a UTF-8 encoded string
</parameter_description>
</parameter>
</parameters>
<return> &lt; 0 if @str1 compares before @str2, 
0 if they compare equal, &gt; 0 if @str1 compares after @str2.
</return>
</function>

<function name="g_variant_type_is_dict_entry">
<description>
Determines if the given @type is a dictionary entry type.  This is
true if the type string for @type starts with a '{'.

This function returns %TRUE for any indefinite type for which every
definite subtype is a dictionary entry type --
%G_VARIANT_TYPE_DICT_ENTRY, for example.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is a dictionary entry type
</return>
</function>

<function name="g_type_module_register_type">
<description>
Looks up or registers a type that is implemented with a particular
type plugin. If a type with name @type_name was previously registered,
the #GType identifier for the type is returned, otherwise the type
is newly registered, and the resulting #GType identifier returned.

When reregistering a type (typically because a module is unloaded
then reloaded, and reinitialized), @module and @parent_type must
be the same as they were previously.

As long as any instances of the type exist, the type plugin will
not be unloaded.


</description>
<parameters>
<parameter name="module">
<parameter_description> a #GTypeModule
</parameter_description>
</parameter>
<parameter name="parent_type">
<parameter_description> the type for the parent class
</parameter_description>
</parameter>
<parameter name="type_name">
<parameter_description> name for the type
</parameter_description>
</parameter>
<parameter name="type_info">
<parameter_description> type information structure
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags field providing details about the type
</parameter_description>
</parameter>
</parameters>
<return> the new or existing type ID
</return>
</function>

<function name="g_variant_hash">
<description>
Generates a hash value for a #GVariant instance.

The output of this function is guaranteed to be the same for a given
value only per-process.  It may change between different processor
architectures or even different versions of GLib.  Do not use this
function as a basis for building protocols or file formats.

The type of @value is #gconstpointer only to allow use of this
function with #GHashTable.  @value must be a #GVariant.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a basic #GVariant value as a #gconstpointer
</parameter_description>
</parameter>
</parameters>
<return> a hash value corresponding to @value
</return>
</function>

<function name="g_variant_is_object_path">
<description>
Determines if a given string is a valid DBus object path.  You
should ensure that a string is a valid DBus object path before
passing it to g_variant_new_object_path().

A valid object path starts with '/' followed by zero or more
sequences of characters separated by '/' characters.  Each sequence
must contain only the characters &quot;[A-Z][a-z][0-9]_&quot;.  No sequence
(including the one following the final '/' character) may be empty.

Since: 2.24

</description>
<parameters>
<parameter name="string">
<parameter_description> a normal C nul-terminated string
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @string is a DBus object path
</return>
</function>

<function name="g_value_get_pointer">
<description>
Get the contents of a pointer #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_POINTER
</parameter_description>
</parameter>
</parameters>
<return> pointer contents of @value
</return>
</function>

<function name="g_win32_locale_filename_from_utf8">
<description>
Converts a filename from UTF-8 to the system codepage.

On NT-based Windows, on NTFS file systems, file names are in
Unicode. It is quite possible that Unicode file names contain
characters not representable in the system codepage. (For instance,
Greek or Cyrillic characters on Western European or US Windows
installations, or various less common CJK characters on CJK Windows
installations.)

In such a case, and if the filename refers to an existing file, and
the file system stores alternate short (8.3) names for directory
entries, the short form of the filename is returned. Note that the
&quot;short&quot; name might in fact be longer than the Unicode name if the
Unicode name has very short pathname components containing
non-ASCII characters. If no system codepage name for the file is
possible, %NULL is returned.

The return value is dynamically allocated and should be freed with
g_free() when no longer needed.

Since: 2.8

</description>
<parameters>
<parameter name="utf8filename">
<parameter_description> a UTF-8 encoded filename.
</parameter_description>
</parameter>
</parameters>
<return> The converted filename, or %NULL on conversion
failure and lack of short names.

</return>
</function>

<function name="g_closure_new_simple">
<description>
Allocates a struct of the given size and initializes the initial
part as a #GClosure. This function is mainly useful when
implementing new types of closures.

|[
typedef struct _MyClosure MyClosure;
struct _MyClosure
{
GClosure closure;
// extra data goes here
};

static void
my_closure_finalize (gpointer  notify_data,
GClosure *closure)
{
MyClosure *my_closure = (MyClosure *)closure;

// free extra data here
}

MyClosure *my_closure_new (gpointer data)
{
GClosure *closure;
MyClosure *my_closure;

closure = g_closure_new_simple (sizeof (MyClosure), data);
my_closure = (MyClosure *) closure;

// initialize extra data here

g_closure_add_finalize_notifier (closure, notify_data,
my_closure_finalize);
return my_closure;
}
]|


</description>
<parameters>
<parameter name="sizeof_closure">
<parameter_description> the size of the structure to allocate, must be at least
&lt;literal&gt;sizeof (GClosure)&lt;/literal&gt;
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to store in the @data field of the newly allocated #GClosure
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated #GClosure
</return>
</function>

<function name="g_ptr_array_new_with_free_func">
<description>
Creates a new #GPtrArray with a reference count of 1 and use @element_free_func
for freeing each element when the array is destroyed either via
g_ptr_array_unref(), when g_ptr_array_free() is called with @free_segment
set to %TRUE or when removing elements.

Since: 2.22

</description>
<parameters>
<parameter name="element_free_func">
<parameter_description> A function to free elements with destroy @array or %NULL.
</parameter_description>
</parameter>
</parameters>
<return> A new #GPtrArray.

</return>
</function>

<function name="g_variant_iter_copy">
<description>
Creates a new heap-allocated #GVariantIter to iterate over the
container that was being iterated over by @iter.  Iteration begins on
the new iterator from the current position of the old iterator but
the two copies are independent past that point.

Use g_variant_iter_free() to free the return value when you no longer
need it.

A reference is taken to the container that @iter is iterating over
and will be releated only when g_variant_iter_free() is called.

Since: 2.24

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GVariantIter
</parameter_description>
</parameter>
</parameters>
<return> a new heap-allocated #GVariantIter
</return>
</function>

<function name="g_type_interfaces">
<description>
Return a newly allocated and 0-terminated array of type IDs, listing the
interface types that @type conforms to. The return value has to be
g_free()ed after use.


</description>
<parameters>
<parameter name="type">
<parameter_description> The type to list interface types for.
</parameter_description>
</parameter>
<parameter name="n_interfaces">
<parameter_description> Optional #guint pointer to contain the number of
interface types.
</parameter_description>
</parameter>
</parameters>
<return> Newly allocated and 0-terminated array of interface types.
</return>
</function>

<function name="g_variant_type_new_array">
<description>
Constructs the type corresponding to an array of elements of the
type @type.

It is appropriate to call g_variant_type_free() on the return value.

Since 2.24

</description>
<parameters>
<parameter name="element">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> a new array #GVariantType
</return>
</function>

<function name="g_io_channel_error_from_errno">
<description>
Converts an &lt;literal&gt;errno&lt;/literal&gt; error number to a #GIOChannelError.


</description>
<parameters>
<parameter name="en">
<parameter_description> an &lt;literal&gt;errno&lt;/literal&gt; error number, e.g. %EINVAL
</parameter_description>
</parameter>
</parameters>
<return> a #GIOChannelError error number, e.g. 
%G_IO_CHANNEL_ERROR_INVAL.
</return>
</function>

<function name="g_cond_signal">
<description>
If threads are waiting for @cond, exactly one of them is woken up.
It is good practice to hold the same lock as the waiting thread
while calling this function, though not required.

This function can be used even if g_thread_init() has not yet been
called, and, in that case, will do nothing.

</description>
<parameters>
<parameter name="cond">
<parameter_description> a #GCond.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_sort_changed_iter">
<description>
Like g_sequence_sort_changed(), but uses
a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
the compare function.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="iter_cmp">
<parameter_description> the #GSequenceItercompare used to compare iterators in the
sequence. It is called with two iterators pointing into @seq. It should
return 0 if the iterators are equal, a negative value if the first
iterator comes before the second, and a positive value if the second
iterator comes before the first.
</parameter_description>
</parameter>
<parameter name="cmp_data">
<parameter_description> user data passed to @cmp_func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_unichar_isdefined">
<description>
Determines if a given character is assigned in the Unicode
standard.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the character has an assigned value
</return>
</function>

<function name="g_signal_handler_block">
<description>
Blocks a handler of an instance so it will not be called during any
signal emissions unless it is unblocked again. Thus &quot;blocking&quot; a
signal handler means to temporarily deactive it, a signal handler
has to be unblocked exactly the same amount of times it has been
blocked before to become active again.

The @handler_id has to be a valid signal handler id, connected to a
signal of @instance.

</description>
<parameters>
<parameter name="instance">
<parameter_description> The instance to block the signal handler of.
</parameter_description>
</parameter>
<parameter name="handler_id">
<parameter_description> Handler id of the handler to be blocked.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_set_float">
<description>
Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_FLOAT
</parameter_description>
</parameter>
<parameter name="v_float">
<parameter_description> float value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_markup_parse_context_get_element_stack">
<description>
Retrieves the element stack from the internal state of the parser.
The returned #GSList is a list of strings where the first item is
the currently open tag (as would be returned by
g_markup_parse_context_get_element()) and the next item is its
immediate parent.

This function is intended to be used in the start_element and
end_element handlers where g_markup_parse_context_get_element()
would merely return the name of the element that is being
processed.

Since: 2.16

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMarkupParseContext
</parameter_description>
</parameter>
</parameters>
<return> the element stack, which must not be modified

</return>
</function>

<function name="g_win32_get_package_installation_directory">
<description>
Try to determine the installation directory for a software package.

This function is deprecated. Use
g_win32_get_package_installation_directory_of_module() instead.

The use of @package is deprecated. You should always pass %NULL. A
warning is printed if non-NULL is passed as @package.

The original intended use of @package was for a short identifier of
the package, typically the same identifier as used for
&lt;literal&gt;GETTEXT_PACKAGE&lt;/literal&gt; in software configured using GNU
autotools. The function first looks in the Windows Registry for the
value &lt;literal&gt;&#35;InstallationDirectory&lt;/literal&gt; in the key
&lt;literal&gt;&#35;HKLM\Software\@package&lt;/literal&gt;, and if that value
exists and is a string, returns that.

It is strongly recommended that packagers of GLib-using libraries
for Windows do not store installation paths in the Registry to be
used by this function as that interfers with having several
parallel installations of the library. Enabling multiple
installations of different versions of some GLib-using library, or
GLib itself, is desirable for various reasons.

For this reason it is recommeded to always pass %NULL as
@package to this function, to avoid the temptation to use the
Registry. In version 2.20 of GLib the @package parameter
will be ignored and this function won't look in the Registry at all.

If @package is %NULL, or the above value isn't found in the
Registry, but @dll_name is non-%NULL, it should name a DLL loaded
into the current process. Typically that would be the name of the
DLL calling this function, looking for its installation
directory. The function then asks Windows what directory that DLL
was loaded from. If that directory's last component is &quot;bin&quot; or
&quot;lib&quot;, the parent directory is returned, otherwise the directory
itself. If that DLL isn't loaded, the function proceeds as if
@dll_name was %NULL.

If both @package and @dll_name are %NULL, the directory from where
the main executable of the process was loaded is used instead in
the same way as above.

Deprecated: 2.18: Pass the HMODULE of a DLL or EXE to
g_win32_get_package_installation_directory_of_module() instead.

</description>
<parameters>
<parameter name="package">
<parameter_description> You should pass %NULL for this.
</parameter_description>
</parameter>
<parameter name="dll_name">
<parameter_description> The name of a DLL that a package provides in UTF-8, or %NULL.
</parameter_description>
</parameter>
</parameters>
<return> a string containing the installation directory for
@package. The string is in the GLib file name encoding,
i.e. UTF-8. The return value should be freed with g_free() when not
needed any longer. If the function fails %NULL is returned.

</return>
</function>

<function name="g_dataset_id_set_data">
<description>
Sets the data element associated with the given #GQuark id. Any
previous data with the same key is removed, and its destroy function
is called.

</description>
<parameters>
<parameter name="l">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the #GQuark id to identify the data element.
</parameter_description>
</parameter>
<parameter name="d">
<parameter_description> the data element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_take_string">
<description>
Sets the contents of a %G_TYPE_STRING #GValue to @v_string.

Since: 2.4

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of type %G_TYPE_STRING
</parameter_description>
</parameter>
<parameter name="v_string">
<parameter_description> string to take ownership of
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_thread_self">
<description>
This functions returns the #GThread corresponding to the calling
thread.

</description>
<parameters>
</parameters>
<return> the current thread.
</return>
</function>

<function name="g_signal_newv">
<description>
Creates a new signal. (This is usually done in the class initializer.)

See g_signal_new() for details on allowed signal names.


</description>
<parameters>
<parameter name="signal_name">
<parameter_description> the name for the signal
</parameter_description>
</parameter>
<parameter name="itype">
<parameter_description> the type this signal pertains to. It will also pertain to
types which are derived from this type
</parameter_description>
</parameter>
<parameter name="signal_flags">
<parameter_description> a combination of #GSignalFlags specifying detail of when
the default handler is to be invoked. You should at least specify
%G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST
</parameter_description>
</parameter>
<parameter name="class_closure">
<parameter_description> The closure to invoke on signal emission; may be %NULL
</parameter_description>
</parameter>
<parameter name="accumulator">
<parameter_description> the accumulator for this signal; may be %NULL
</parameter_description>
</parameter>
<parameter name="accu_data">
<parameter_description> user data for the @accumulator
</parameter_description>
</parameter>
<parameter name="c_marshaller">
<parameter_description> the function to translate arrays of parameter values to
signal emissions into C language callback invocations
</parameter_description>
</parameter>
<parameter name="return_type">
<parameter_description> the type of return value, or #G_TYPE_NONE for a signal
without a return value
</parameter_description>
</parameter>
<parameter name="n_params">
<parameter_description> the length of @param_types
</parameter_description>
</parameter>
<parameter name="param_types">
<parameter_description> an array of types, one for each parameter
</parameter_description>
</parameter>
</parameters>
<return> the signal id
</return>
</function>

<function name="g_value_set_flags">
<description>
Set the contents of a %G_TYPE_FLAGS #GValue to @v_flags.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue whose type is derived from %G_TYPE_FLAGS
</parameter_description>
</parameter>
<parameter name="v_flags">
<parameter_description> flags value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_set_close_on_unref">
<description>
Setting this flag to %TRUE for a channel you have already closed
can cause problems.

</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="do_close">
<parameter_description> Whether to close the channel on the final unref of
the GIOChannel data structure. The default value of
this is %TRUE for channels created by g_io_channel_new_file (),
and %FALSE for all other channels.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_option_context_get_description">
<description>
Returns the description. See g_option_context_set_description().

Since: 2.12

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
</parameters>
<return> the description

</return>
</function>

<function name="g_io_channel_shutdown">
<description>
Close an IO channel. Any pending data to be written will be
flushed if @flush is %TRUE. The channel will not be freed until the
last reference is dropped using g_io_channel_unref().


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="flush">
<parameter_description> if %TRUE, flush pending
</parameter_description>
</parameter>
<parameter name="err">
<parameter_description> location to store a #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> the status of the operation.
</return>
</function>

<function name="g_type_module_register_flags">
<description>
Looks up or registers a flags type that is implemented with a particular
type plugin. If a type with name @type_name was previously registered,
the #GType identifier for the type is returned, otherwise the type
is newly registered, and the resulting #GType identifier returned.

As long as any instances of the type exist, the type plugin will
not be unloaded.

Since: 2.6


</description>
<parameters>
<parameter name="module">
<parameter_description> a #GTypeModule
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> name for the type
</parameter_description>
</parameter>
<parameter name="const_static_values">
<parameter_description> an array of #GFlagsValue structs for the
possible flags values. The array is
terminated by a struct with all members being
0.
</parameter_description>
</parameter>
</parameters>
<return> the new or existing type ID
</return>
</function>

<function name="g_ucs4_to_utf16">
<description>
Convert a string from UCS-4 to UTF-16. A 0 character will be
added to the result after the converted text.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UCS-4 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length (number of characters) of @str to use. 
If @len &lt; 0, then the string is nul-terminated.
</parameter_description>
</parameter>
<parameter name="items_read">
<parameter_description> location to store number of bytes read, or %NULL.
If an error occurs then the index of the invalid input
is stored here.
</parameter_description>
</parameter>
<parameter name="items_written">
<parameter_description> location to store number of &lt;type&gt;gunichar2&lt;/type&gt; 
written, or %NULL. The value stored here does not 
include the trailing 0.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError other than
%G_CONVERT_ERROR_NO_CONVERSION may occur.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to a newly allocated UTF-16 string.
This value must be freed with g_free(). If an
error occurs, %NULL will be returned and
@error set.
</return>
</function>

<function name="g_static_rw_lock_reader_trylock">
<description>
Tries to lock @lock for reading. If @lock is already locked for
writing by another thread or if another thread is already waiting to
lock @lock for writing, immediately returns %FALSE. Otherwise locks
@lock for reading and returns %TRUE. This lock has to be unlocked by
g_static_rw_lock_reader_unlock().

</description>
<parameters>
<parameter name="lock">
<parameter_description> a #GStaticRWLock to lock for reading.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE, if @lock could be locked for reading.
</return>
</function>

<function name="g_node_insert_after">
<description>
Inserts a #GNode beneath the parent after the given sibling.


</description>
<parameters>
<parameter name="parent">
<parameter_description> the #GNode to place @node under
</parameter_description>
</parameter>
<parameter name="sibling">
<parameter_description> the sibling #GNode to place @node after. 
If sibling is %NULL, the node is inserted as the first child of @parent.
</parameter_description>
</parameter>
<parameter name="node">
<parameter_description> the #GNode to insert
</parameter_description>
</parameter>
</parameters>
<return> the inserted #GNode
</return>
</function>

<function name="g_queue_insert_sorted">
<description>
Inserts @data into @queue using @func to determine the new position.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to insert
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the #GCompareDataFunc used to compare elements in the queue. It is
called with two elements of the @queue and @user_data. It should
return 0 if the elements are equal, a negative value if the first
element comes before the second, and a positive value if the second
element comes before the first.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data passed to @func.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_test_rand_int">
<description>
Get a reproducible random integer number.

The random numbers generated by the g_test_rand_*() family of functions
change with every new test program start, unless the --seed option is
given when starting test programs.

For individual test cases however, the random number generator is
reseeded, to avoid dependencies between tests and to make --seed
effective for all test cases.

Since: 2.16

</description>
<parameters>
</parameters>
<return> a random number from the seeded random number generator.

</return>
</function>

<function name="g_type_is_a">
<description>
If @is_a_type is a derivable type, check whether @type is a
descendant of @is_a_type.  If @is_a_type is an interface, check
whether @type conforms to it.


</description>
<parameters>
<parameter name="type">
<parameter_description> Type to check anchestry for.
</parameter_description>
</parameter>
<parameter name="is_a_type">
<parameter_description> Possible anchestor of @type or interface @type could conform to.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type is_a @is_a_type holds true.
</return>
</function>

<function name="g_object_get_qdata">
<description>
This function gets back user data pointers stored via
g_object_set_qdata().


</description>
<parameters>
<parameter name="object">
<parameter_description> The GObject to get a stored user data pointer from
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> A #GQuark, naming the user data pointer
</parameter_description>
</parameter>
</parameters>
<return> The user data pointer set, or %NULL
</return>
</function>

<function name="g_test_suite_add">
<description>
Adds @test_case to @suite.

Since: 2.16

</description>
<parameters>
<parameter name="suite">
<parameter_description> a #GTestSuite
</parameter_description>
</parameter>
<parameter name="test_case">
<parameter_description> a #GTestCase
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_disconnect">
<description>
A convenience function to disconnect multiple signals at once.

The signal specs expected by this function have the form
&quot;any_signal&quot;, which means to disconnect any signal with matching
callback and data, or &quot;any_signal::signal_name&quot;, which only
disconnects the signal named &quot;signal_name&quot;.

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="signal_spec">
<parameter_description> the spec for the first signal
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> #GCallback for the first signal, followed by data for the first signal,
followed optionally by more signal spec/callback/data triples,
followed by %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_iconv_open">
<description>
Same as the standard UNIX routine iconv_open(), but
may be implemented via libiconv on UNIX flavors that lack
a native implementation.

GLib provides g_convert() and g_locale_to_utf8() which are likely
more convenient than the raw iconv wrappers.


</description>
<parameters>
<parameter name="to_codeset">
<parameter_description> destination codeset
</parameter_description>
</parameter>
<parameter name="from_codeset">
<parameter_description> source codeset
</parameter_description>
</parameter>
</parameters>
<return> a &quot;conversion descriptor&quot;, or (GIConv)-1 if
opening the converter failed.
</return>
</function>

<function name="g_object_weak_ref">
<description>
Adds a weak reference callback to an object. Weak references are
used for notification when an object is finalized. They are called
&quot;weak references&quot; because they allow you to safely hold a pointer
to an object without calling g_object_ref() (g_object_ref() adds a
strong reference, that is, forces the object to stay alive).

</description>
<parameters>
<parameter name="object">
<parameter_description> #GObject to reference weakly
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description> callback to invoke before the object is freed
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> extra data to pass to notify
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_compute_checksum_for_string">
<description>
Computes the checksum of a string.

The hexadecimal string returned will be in lower case.

Since: 2.16

</description>
<parameters>
<parameter name="checksum_type">
<parameter_description> a #GChecksumType
</parameter_description>
</parameter>
<parameter name="str">
<parameter_description> the string to compute the checksum of
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the length of the string, or -1 if the string is null-terminated.
</parameter_description>
</parameter>
</parameters>
<return> the checksum as a hexadecimal string. The returned string
should be freed with g_free() when done using it.

</return>
</function>

<function name="g_rand_free">
<description>
Frees the memory allocated for the #GRand.

</description>
<parameters>
<parameter name="rand_">
<parameter_description> a #GRand.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_key_file_get_uint64">
<description>
Returns the value associated with @key under @group_name as an unsigned
64-bit integer. This is similar to g_key_file_get_integer() but can return
large positive results without truncation.

Since: 2.26

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a non-%NULL #GKeyFile
</parameter_description>
</parameter>
<parameter name="group_name">
<parameter_description> a non-%NULL group name
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a non-%NULL key
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> the value associated with the key as an unsigned 64-bit integer,
or 0 if the key was not found or could not be parsed.

</return>
</function>

<function name="g_key_file_get_groups">
<description>
Returns all groups in the key file loaded with @key_file.  
The array of returned groups will be %NULL-terminated, so 
@length may optionally be %NULL.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> a #GKeyFile
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> return location for the number of returned groups, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated %NULL-terminated array of strings. 
Use g_strfreev() to free it.
</return>
</function>

<function name="g_dataset_destroy">
<description>
Destroys the dataset, freeing all memory allocated, and calling any
destroy functions set for data elements.

</description>
<parameters>
<parameter name="dataset_location">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_foreach_range">
<description>
Calls @func for each item in the range (@begin, @end) passing
@user_data to the function.

Since: 2.14

</description>
<parameters>
<parameter name="begin">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> a #GFunc
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data passed to @func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_class_peek_static">
<description>
A more efficient version of g_type_class_peek() which works only for
static types.

Since: 2.4

</description>
<parameters>
<parameter name="type">
<parameter_description> Type ID of a classed type.
</parameter_description>
</parameter>
</parameters>
<return> The #GTypeClass structure for the given type ID or %NULL
if the class does not currently exist or is dynamically loaded.
</return>
</function>

<function name="g_param_spec_boolean">
<description>
Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN
property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_datalist_remove_no_notify">
<description>
Removes an element, without calling its destroy notifier.

</description>
<parameters>
<parameter name="dl">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string identifying the data element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_rand_new_with_seed_array">
<description>
Creates a new random number generator initialized with @seed.

Since: 2.4

</description>
<parameters>
<parameter name="seed">
<parameter_description> an array of seeds to initialize the random number generator.
</parameter_description>
</parameter>
<parameter name="seed_length">
<parameter_description> an array of seeds to initialize the random number generator.
</parameter_description>
</parameter>
</parameters>
<return> the new #GRand.

</return>
</function>

<function name="g_param_value_set_default">
<description>
Sets @value to its default value as specified in @pspec.

</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> a #GValue of correct type for @pspec
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_string_prepend_unichar">
<description>
Converts a Unicode character into UTF-8, and prepends it
to the string.


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="wc">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_rand_set_seed_array">
<description>
Initializes the random number generator by an array of
longs.  Array can be of arbitrary size, though only the
first 624 values are taken.  This function is useful
if you have many low entropy seeds, or if you require more then
32bits of actual entropy for your application.

Since: 2.4

</description>
<parameters>
<parameter name="rand_">
<parameter_description> a #GRand.
</parameter_description>
</parameter>
<parameter name="seed">
<parameter_description> array to initialize with
</parameter_description>
</parameter>
<parameter name="seed_length">
<parameter_description> length of array
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_regex_match_simple">
<description>
Scans for a match in @string for @pattern.

This function is equivalent to g_regex_match() but it does not
require to compile the pattern with g_regex_new(), avoiding some
lines of code when you need just to do a match without extracting
substrings, capture counts, and so on.

If this function is to be called on the same @pattern more than
once, it's more efficient to compile the pattern once with
g_regex_new() and then use g_regex_match().

Since: 2.14

</description>
<parameters>
<parameter name="pattern">
<parameter_description> the regular expression
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to scan for matches
</parameter_description>
</parameter>
<parameter name="compile_options">
<parameter_description> compile options for the regular expression, or 0
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> match options, or 0
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the string matched, %FALSE otherwise

</return>
</function>

<function name="g_strfreev">
<description>
Frees a %NULL-terminated array of strings, and the array itself.
If called on a %NULL value, g_strfreev() simply returns. 

</description>
<parameters>
<parameter name="str_array">
<parameter_description> a %NULL-terminated array of strings to free.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_weak_unref">
<description>
Removes a weak reference callback to an object.

</description>
<parameters>
<parameter name="object">
<parameter_description> #GObject to remove a weak reference from
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description> callback to search for
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to search for
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_type_name">
<description>
Get the unique name that is assigned to a type ID.  Note that this
function (like all other GType API) cannot cope with invalid type
IDs. %G_TYPE_INVALID may be passed to this function, as may be any
other validly registered type ID, but randomized type IDs should
not be passed in and will most likely lead to a crash.


</description>
<parameters>
<parameter name="type">
<parameter_description> Type to return name for.
</parameter_description>
</parameter>
</parameters>
<return> Static type name or %NULL.
</return>
</function>

<function name="g_iconv">
<description>
Same as the standard UNIX routine iconv(), but
may be implemented via libiconv on UNIX flavors that lack
a native implementation.

GLib provides g_convert() and g_locale_to_utf8() which are likely
more convenient than the raw iconv wrappers.


</description>
<parameters>
<parameter name="converter">
<parameter_description> conversion descriptor from g_iconv_open()
</parameter_description>
</parameter>
<parameter name="inbuf">
<parameter_description> bytes to convert
</parameter_description>
</parameter>
<parameter name="inbytes_left">
<parameter_description> inout parameter, bytes remaining to convert in @inbuf
</parameter_description>
</parameter>
<parameter name="outbuf">
<parameter_description> converted output bytes
</parameter_description>
</parameter>
<parameter name="outbytes_left">
<parameter_description> inout parameter, bytes available to fill in @outbuf
</parameter_description>
</parameter>
</parameters>
<return> count of non-reversible conversions, or -1 on error
</return>
</function>

<function name="g_main_context_dispatch">
<description>
Dispatches all pending sources.

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_swap">
<description>
Swaps the items pointed to by @a and @b. It is allowed for @a and @b
to point into difference sequences.

Since: 2.14

</description>
<parameters>
<parameter name="a">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="b">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_child_position">
<description>
Gets the position of a #GNode with respect to its siblings.
@child must be a child of @node. The first child is numbered 0, 
the second 1, and so on.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
<parameter name="child">
<parameter_description> a child of @node
</parameter_description>
</parameter>
</parameters>
<return> the position of @child with respect to its siblings
</return>
</function>

<function name="g_option_context_set_help_enabled">
<description>
Enables or disables automatic generation of &lt;option&gt;--help&lt;/option&gt; 
output. By default, g_option_context_parse() recognizes
&lt;option&gt;--help&lt;/option&gt;, &lt;option&gt;-h&lt;/option&gt;,
&lt;option&gt;-?&lt;/option&gt;, &lt;option&gt;--help-all&lt;/option&gt;
and &lt;option&gt;--help-&lt;/option&gt;&lt;replaceable&gt;groupname&lt;/replaceable&gt; and creates
suitable output to stdout. 

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="help_enabled">
<parameter_description> %TRUE to enable &lt;option&gt;--help&lt;/option&gt;, %FALSE to disable it
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_list_append">
<description>
Adds a new element on to the end of the list.

&lt;note&gt;&lt;para&gt;
The return value is the new start of the list, which 
may have changed, so make sure you store the new value.
&lt;/para&gt;&lt;/note&gt;

&lt;note&gt;&lt;para&gt;
Note that g_list_append() has to traverse the entire list 
to find the end, which is inefficient when adding multiple 
elements. A common idiom to avoid the inefficiency is to prepend 
the elements and reverse the list when all elements have been added.
&lt;/para&gt;&lt;/note&gt;

|[
/ * Notice that these are initialized to the empty list. * /
GList *list = NULL, *number_list = NULL;

/ * This is a list of strings. * /
list = g_list_append (list, &quot;first&quot;);
list = g_list_append (list, &quot;second&quot;);

/ * This is a list of integers. * /
number_list = g_list_append (number_list, GINT_TO_POINTER (27));
number_list = g_list_append (number_list, GINT_TO_POINTER (14));
]|


</description>
<parameters>
<parameter name="list">
<parameter_description> a pointer to a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data for the new element
</parameter_description>
</parameter>
</parameters>
<return> the new start of the #GList
</return>
</function>

<function name="g_enum_get_value">
<description>
Returns the #GEnumValue for a value.


</description>
<parameters>
<parameter name="enum_class">
<parameter_description> a #GEnumClass
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> the value to look up
</parameter_description>
</parameter>
</parameters>
<return> the #GEnumValue for @value, or %NULL if @value is not a
member of the enumeration
</return>
</function>

<function name="g_variant_get_variant">
<description>
Unboxes @value.  The result is the #GVariant instance that was
contained in @value.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a variant #GVariance instance
</parameter_description>
</parameter>
</parameters>
<return> the item contained in the variant
</return>
</function>

<function name="g_node_max_height">
<description>
Gets the maximum height of all branches beneath a #GNode.
This is the maximum distance from the #GNode to all leaf nodes.

If @root is %NULL, 0 is returned. If @root has no children, 
1 is returned. If @root has children, 2 is returned. And so on.


</description>
<parameters>
<parameter name="root">
<parameter_description> a #GNode
</parameter_description>
</parameter>
</parameters>
<return> the maximum height of the tree beneath @root
</return>
</function>

<function name="g_dataset_remove_no_notify">
<description>
Removes an element, without calling its destroy notifier.

</description>
<parameters>
<parameter name="l">
<parameter_description> the location identifying the dataset.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string identifying the data element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_init">
<description>
Initializes a #GIOChannel struct. 

This is called by each of the above functions when creating a 
#GIOChannel, and so is not often needed by the application 
programmer (unless you are creating a new type of #GIOChannel).

</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_static_rec_mutex_lock">
<description>
Locks @mutex. If @mutex is already locked by another thread, the
current thread will block until @mutex is unlocked by the other
thread. If @mutex is already locked by the calling thread, this
functions increases the depth of @mutex and returns immediately.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticRecMutex to lock.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_get_description">
<description>
Retrieves the description of the bookmark for @uri.

In the event the URI cannot be found, %NULL is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string or %NULL if the specified
URI cannot be found.

</return>
</function>

<function name="g_list_nth_data">
<description>
Gets the data of the element at the given position.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position of the element
</parameter_description>
</parameter>
</parameters>
<return> the element's data, or %NULL if the position 
is off the end of the #GList
</return>
</function>

<function name="g_value_get_enum">
<description>
Get the contents of a %G_TYPE_ENUM #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue whose type is derived from %G_TYPE_ENUM
</parameter_description>
</parameter>
</parameters>
<return> enum contents of @value
</return>
</function>

<function name="g_variant_new">
<description>
Creates a new #GVariant instance.

Think of this function as an analogue to g_strdup_printf().

The type of the created instance and the arguments that are
expected by this function are determined by @format_string.  See the
section on &lt;link linkend='gvariant-format-strings'&gt;GVariant Format
Strings&lt;/link&gt;.  Please note that the syntax of the format string is
very likely to be extended in the future.

The first character of the format string must not be '*' '?' '@' or
'r'; in essence, a new #GVariant must always be constructed by this
function (and not merely passed through it unmodified).

Since: 2.24

</description>
<parameters>
<parameter name="format_string">
<parameter_description> a #GVariant format string
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> arguments, as per @format_string
</parameter_description>
</parameter>
</parameters>
<return> a new floating #GVariant instance
</return>
</function>

<function name="g_datalist_foreach">
<description>
Calls the given function for each data element of the datalist. The
function is called with each data element's #GQuark id and data,
together with the given @user_data parameter. Note that this
function is NOT thread-safe. So unless @datalist can be protected
from any modifications during invocation of this function, it should
not be called.

</description>
<parameters>
<parameter name="datalist">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call for each data element.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_set_object">
<description>
Set the contents of a %G_TYPE_OBJECT derived #GValue to @v_object.

g_value_set_object() increases the reference count of @v_object
(the #GValue holds a reference to @v_object).  If you do not wish
to increase the reference count of the object (i.e. you wish to
pass your current reference to the #GValue because you no longer
need it), use g_value_take_object() instead.

It is important that your #GValue holds a reference to @v_object (either its
own, or one it has taken) to ensure that the object won't be destroyed while
the #GValue still exists).

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_OBJECT derived type
</parameter_description>
</parameter>
<parameter name="v_object">
<parameter_description> object value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_timer_reset">
<description>
This function is useless; it's fine to call g_timer_start() on an
already-started timer to reset the start time, so g_timer_reset()
serves no purpose.

</description>
<parameters>
<parameter name="timer">
<parameter_description> a #GTimer.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_file_open_tmp">
<description>
Opens a file for writing in the preferred directory for temporary
files (as returned by g_get_tmp_dir()). 

@tmpl should be a string in the GLib file name encoding containing 
a sequence of six 'X' characters, as the parameter to g_mkstemp().
However, unlike these functions, the template should only be a
basename, no directory components are allowed. If template is
%NULL, a default template is used.

Note that in contrast to g_mkstemp() (and mkstemp()) 
@tmpl is not modified, and might thus be a read-only literal string.

The actual name used is returned in @name_used if non-%NULL. This
string should be freed with g_free() when not needed any longer.
The returned name is in the GLib file name encoding.


</description>
<parameters>
<parameter name="tmpl">
<parameter_description> Template for file name, as in g_mkstemp(), basename only,
or %NULL, to a default template
</parameter_description>
</parameter>
<parameter name="name_used">
<parameter_description> location to store actual name used, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError
</parameter_description>
</parameter>
</parameters>
<return> A file handle (as from open()) to 
the file opened for reading and writing. The file is opened in binary 
mode on platforms where there is a difference. The file handle should be
closed with close(). In case of errors, -1 is returned 
and @error will be set.
</return>
</function>

<function name="g_markup_parse_context_free">
<description>
Frees a #GMarkupParseContext. Can't be called from inside
one of the #GMarkupParser functions. Can't be called while
a subparser is pushed.

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMarkupParseContext
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_direct_equal">
<description>
Compares two #gpointer arguments and returns %TRUE if they are equal.
It can be passed to g_hash_table_new() as the @key_equal_func
parameter, when using pointers as keys in a #GHashTable.


</description>
<parameters>
<parameter name="v1">
<parameter_description> a key.
</parameter_description>
</parameter>
<parameter name="v2">
<parameter_description> a key to compare with @v1.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the two keys match.
</return>
</function>

<function name="g_cache_insert">
<description>
Gets the value corresponding to the given key, creating it if
necessary. It first checks if the value already exists in the
#GCache, by using the @key_equal_func function passed to
g_cache_new(). If it does already exist it is returned, and its
reference count is increased by one. If the value does not currently
exist, if is created by calling the @value_new_func. The key is
duplicated by calling @key_dup_func and the duplicated key and value
are inserted into the #GCache.

</description>
<parameters>
<parameter name="cache">
<parameter_description> a #GCache.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> a key describing a #GCache object.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to a #GCache value.
</return>
</function>

<function name="g_mem_chunk_new">
<description>
Creates a new #GMemChunk.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
<parameter name="name">
<parameter_description> a string to identify the #GMemChunk. It is not copied so it
should be valid for the lifetime of the #GMemChunk. It is
only used in g_mem_chunk_print(), which is used for debugging.
</parameter_description>
</parameter>
<parameter name="atom_size">
<parameter_description> the size, in bytes, of each element in the #GMemChunk.
</parameter_description>
</parameter>
<parameter name="area_size">
<parameter_description> the size, in bytes, of each block of memory allocated to
contain the atoms.
</parameter_description>
</parameter>
<parameter name="type">
<parameter_description> the type of the #GMemChunk.  #G_ALLOC_AND_FREE is used if the
atoms will be freed individually.  #G_ALLOC_ONLY should be
used if atoms will never be freed individually.
#G_ALLOC_ONLY is quicker, since it does not need to track
free atoms, but it obviously wastes memory if you no longer
need many of the atoms.
</parameter_description>
</parameter>
</parameters>
<return> the new #GMemChunk.
</return>
</function>

<function name="g_tree_lookup_extended">
<description>
Looks up a key in the #GTree, returning the original key and the
associated value and a #gboolean which is %TRUE if the key was found. This 
is useful if you need to free the memory allocated for the original key, 
for example before calling g_tree_remove().


</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
<parameter name="lookup_key">
<parameter_description> the key to look up.
</parameter_description>
</parameter>
<parameter name="orig_key">
<parameter_description> returns the original key.
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> returns the value associated with the key.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the key was found in the #GTree.
</return>
</function>

<function name="g_slist_free_1">
<description>
Frees one #GSList element.
It is usually used after g_slist_remove_link().

</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList element
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_private_new">
<description>
Creates a new #GPrivate. If @destructor is non-%NULL, it is a
pointer to a destructor function. Whenever a thread ends and the
corresponding pointer keyed to this instance of #GPrivate is
non-%NULL, the destructor is called with this pointer as the
argument.

&lt;note&gt;&lt;para&gt;@destructor is used quite differently from @notify in
g_static_private_set().&lt;/para&gt;&lt;/note&gt;

&lt;note&gt;&lt;para&gt;A #GPrivate can not be freed. Reuse it instead, if you
can, to avoid shortage, or use #GStaticPrivate.&lt;/para&gt;&lt;/note&gt;

&lt;note&gt;&lt;para&gt;This function will abort if g_thread_init() has not been
called yet.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
<parameter name="destructor">
<parameter_description> a function to destroy the data keyed to #GPrivate when
a thread ends.
</parameter_description>
</parameter>
</parameters>
<return> a new #GPrivate.
</return>
</function>

<function name="g_array_prepend_vals">
<description>
Adds @len elements onto the start of the array.

This operation is slower than g_array_append_vals() since the
existing elements in the array have to be moved to make space for
the new elements.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> a pointer to the elements to prepend to the start of the
array.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the number of elements to prepend.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_string_assign">
<description>
Copies the bytes from a string into a #GString, 
destroying any previous contents. It is rather like 
the standard strcpy() function, except that you do not 
have to worry about having enough space to copy the string.


</description>
<parameters>
<parameter name="string">
<parameter_description> the destination #GString. Its current contents 
are destroyed.
</parameter_description>
</parameter>
<parameter name="rval">
<parameter_description> the string to copy into @string
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_node_insert">
<description>
Inserts a #GNode beneath the parent at the given position.


</description>
<parameters>
<parameter name="parent">
<parameter_description> the #GNode to place @node under
</parameter_description>
</parameter>
<parameter name="position">
<parameter_description> the position to place @node at, with respect to its siblings
If position is -1, @node is inserted as the last child of @parent
</parameter_description>
</parameter>
<parameter name="node">
<parameter_description> the #GNode to insert
</parameter_description>
</parameter>
</parameters>
<return> the inserted #GNode
</return>
</function>

<function name="g_variant_iter_free">
<description>
Frees a heap-allocated #GVariantIter.  Only call this function on
iterators that were returned by g_variant_iter_new() or
g_variant_iter_copy().

Since: 2.24

</description>
<parameters>
<parameter name="iter">
<parameter_description> a heap-allocated #GVariantIter
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_fopen">
<description>
A wrapper for the stdio fopen() function. The fopen() function
opens a file and associates a new stream with it.

Because file descriptors are specific to the C library on Windows,
and a file descriptor is partof the &lt;type&gt;FILE&lt;/type&gt; struct, the
&lt;type&gt;FILE&lt;/type&gt; pointer returned by this function makes sense
only to functions in the same C library. Thus if the GLib-using
code uses a different C library than GLib does, the
&lt;type&gt;FILE&lt;/type&gt; pointer returned by this function cannot be
passed to C library functions like fprintf() or fread().

See your C library manual for more details about fopen().

Since: 2.6

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> a string describing the mode in which the file should be 
opened
</parameter_description>
</parameter>
</parameters>
<return> A &lt;type&gt;FILE&lt;/type&gt; pointer if the file was successfully
opened, or %NULL if an error occurred

</return>
</function>

<function name="g_static_mutex_get_mutex">
<description>
For some operations (like g_cond_wait()) you must have a #GMutex
instead of a #GStaticMutex. This function will return the
corresponding #GMutex for @mutex.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticMutex.
</parameter_description>
</parameter>
</parameters>
<return> the #GMutex corresponding to @mutex.
</return>
</function>

<function name="g_match_info_fetch_named_pos">
<description>
Retrieves the position in bytes of the capturing parentheses named @name.

If @name is a valid sub pattern name but it didn't match anything
(e.g. sub pattern &quot;X&quot;, matching &quot;b&quot; against &quot;(?P&lt;X&gt;a)?b&quot;)
then @start_pos and @end_pos are set to -1 and %TRUE is returned.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> #GMatchInfo structure
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> name of the subexpression
</parameter_description>
</parameter>
<parameter name="start_pos">
<parameter_description> pointer to location where to store
the start position, or %NULL
</parameter_description>
</parameter>
<parameter name="end_pos">
<parameter_description> pointer to location where to store
the end position, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the position was fetched, %FALSE otherwise.
If the position cannot be fetched, @start_pos and @end_pos
are left unchanged.

</return>
</function>

<function name="g_variant_get_bytestring">
<description>
Returns the string value of a #GVariant instance with an
array-of-bytes type.  The string has no particular encoding.

If the array does not end with a nul terminator character, the empty
string is returned.  For this reason, you can always trust that a
non-%NULL nul-terminated string will be returned by this function.

If the array contains a nul terminator character somewhere other than
the last byte then the returned string is the string, up to the first
such nul character.

It is an error to call this function with a @value that is not an
array of bytes.

The return value remains valid as long as @value exists.

Since: 2.26

</description>
<parameters>
<parameter name="value">
<parameter_description> an array-of-bytes #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> the constant string
</return>
</function>

<function name="g_regex_split">
<description>
Breaks the string on the pattern, and returns an array of the tokens.
If the pattern contains capturing parentheses, then the text for each
of the substrings will also be returned. If the pattern does not match
anywhere in the string, then the whole string is returned as the first
token.

As a special case, the result of splitting the empty string &quot;&quot; is an
empty vector, not a vector containing a single string. The reason for
this special case is that being able to represent a empty vector is
typically more useful than consistent handling of empty elements. If
you do need to represent empty elements, you'll need to check for the
empty string before calling this function.

A pattern that can match empty strings splits @string into separate
characters wherever it matches the empty string between characters.
For example splitting &quot;ab c&quot; using as a separator &quot;\s*&quot;, you will get
&quot;a&quot;, &quot;b&quot; and &quot;c&quot;.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to split with the pattern
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> match time option flags
</parameter_description>
</parameter>
</parameters>
<return> a %NULL-terminated gchar ** array. Free it using g_strfreev()

</return>
</function>

<function name="g_variant_get_fixed_array">
<description>
Provides access to the serialised data for an array of fixed-sized
items.

@value must be an array with fixed-sized elements.  Numeric types are
fixed-size as are tuples containing only other fixed-sized types.

@element_size must be the size of a single element in the array.  For
example, if calling this function for an array of 32 bit integers,
you might say &lt;code&gt;sizeof (gint32)&lt;/code&gt;.  This value isn't used
except for the purpose of a double-check that the form of the
seralised data matches the caller's expectation.

@n_elements, which must be non-%NULL is set equal to the number of
items in the array.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a #GVariant array with fixed-sized elements
</parameter_description>
</parameter>
<parameter name="n_elements">
<parameter_description> a pointer to the location to store the number of items
</parameter_description>
</parameter>
<parameter name="element_size">
<parameter_description> the size of each element
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the fixed array
</return>
</function>

<function name="g_type_plugin_complete_type_info">
<description>
Calls the @complete_type_info function from the #GTypePluginClass of @plugin.
There should be no need to use this function outside of the GObject 
type system itself.

</description>
<parameters>
<parameter name="plugin">
<parameter_description> a #GTypePlugin
</parameter_description>
</parameter>
<parameter name="g_type">
<parameter_description> the #GType whose info is completed
</parameter_description>
</parameter>
<parameter name="info">
<parameter_description> the #GTypeInfo struct to fill in
</parameter_description>
</parameter>
<parameter name="value_table">
<parameter_description> the #GTypeValueTable to fill in
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_find">
<description>
Finds the first link in @queue which contains @data.

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to find
</parameter_description>
</parameter>
</parameters>
<return> The first link in @queue which contains @data.

</return>
</function>

<function name="g_param_spec_uint">
<description>
Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="minimum">
<parameter_description> minimum value for the property specified
</parameter_description>
</parameter>
<parameter name="maximum">
<parameter_description> maximum value for the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_bookmark_file_to_data">
<description>
This function outputs @bookmark as a string.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> return location for the length of the returned string, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string holding
the contents of the #GBookmarkFile

</return>
</function>

<function name="g_main_loop_get_context">
<description>
Returns the #GMainContext of @loop.


</description>
<parameters>
<parameter name="loop">
<parameter_description> a #GMainLoop.
</parameter_description>
</parameter>
</parameters>
<return> the #GMainContext of @loop
</return>
</function>

<function name="g_io_channel_seek_position">
<description>
Replacement for g_io_channel_seek() with the new API.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="offset">
<parameter_description> The offset in bytes from the position specified by @type
</parameter_description>
</parameter>
<parameter name="type">
<parameter_description> a #GSeekType. The type %G_SEEK_CUR is only allowed in those
cases where a call to g_io_channel_set_encoding ()
is allowed. See the documentation for
g_io_channel_set_encoding () for details.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> A location to return an error of type #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> the status of the operation.
</return>
</function>

<function name="g_node_last_sibling">
<description>
Gets the last sibling of a #GNode.
This could possibly be the node itself.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
</parameters>
<return> the last sibling of @node
</return>
</function>

<function name="g_variant_new_int32">
<description>
Creates a new int32 #GVariant instance.

Since: 2.24

</description>
<parameters>
<parameter name="int32">
<parameter_description> a #gint32 value
</parameter_description>
</parameter>
</parameters>
<return> a new int32 #GVariant instance
</return>
</function>

<function name="g_regex_replace_eval">
<description>
Replaces occurrences of the pattern in regex with the output of
@eval for that occurrence.

Setting @start_position differs from just passing over a shortened
string and setting #G_REGEX_MATCH_NOTBOL in the case of a pattern
that begins with any kind of lookbehind assertion, such as &quot;\b&quot;.

The following example uses g_regex_replace_eval() to replace multiple
strings at once:
|[
static gboolean
eval_cb (const GMatchInfo *info,
GString          *res,
gpointer          data)
{
gchar *match;
gchar *r;

match = g_match_info_fetch (info, 0);
r = g_hash_table_lookup ((GHashTable *)data, match);
g_string_append (res, r);
g_free (match);

return FALSE;
}

/ * ... * /

GRegex *reg;
GHashTable *h;
gchar *res;

h = g_hash_table_new (g_str_hash, g_str_equal);

g_hash_table_insert (h, &quot;1&quot;, &quot;ONE&quot;);
g_hash_table_insert (h, &quot;2&quot;, &quot;TWO&quot;);
g_hash_table_insert (h, &quot;3&quot;, &quot;THREE&quot;);
g_hash_table_insert (h, &quot;4&quot;, &quot;FOUR&quot;);

reg = g_regex_new (&quot;1|2|3|4&quot;, 0, 0, NULL);
res = g_regex_replace_eval (reg, text, -1, 0, 0, eval_cb, h, NULL);
g_hash_table_destroy (h);

/ * ... * /
]|

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure from g_regex_new()
@string (array length=string_len): string to perform matches against
</parameter_description>
</parameter>
<parameter name="string_len">
<parameter_description> the length of @string, or -1 if @string is nul-terminated
</parameter_description>
</parameter>
<parameter name="start_position">
<parameter_description> starting index of the string to match
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> options for the match
</parameter_description>
</parameter>
<parameter name="eval">
<parameter_description> a function to call for each match
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore errors
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string containing the replacements

</return>
</function>

<function name="g_hash_table_lookup_extended">
<description>
Looks up a key in the #GHashTable, returning the original key and the
associated value and a #gboolean which is %TRUE if the key was found. This
is useful if you need to free the memory allocated for the original key,
for example before calling g_hash_table_remove().

You can actually pass %NULL for @lookup_key to test
whether the %NULL key exists.


</description>
<parameters>
<parameter name="hash_table">
<parameter_description> a #GHashTable
</parameter_description>
</parameter>
<parameter name="lookup_key">
<parameter_description> the key to look up
</parameter_description>
</parameter>
<parameter name="orig_key">
<parameter_description> return location for the original key, or %NULL
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> return location for the value associated with the key, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the key was found in the #GHashTable.
</return>
</function>

<function name="g_bookmark_file_get_mime_type">
<description>
Retrieves the MIME type of the resource pointed by @uri.

In the event the URI cannot be found, %NULL is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
event that the MIME type cannot be found, %NULL is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string or %NULL if the specified
URI cannot be found.

</return>
</function>

<function name="g_strrstr_len">
<description>
Searches the string @haystack for the last occurrence
of the string @needle, limiting the length of the search
to @haystack_len. 


</description>
<parameters>
<parameter name="haystack">
<parameter_description> a nul-terminated string.
</parameter_description>
</parameter>
<parameter name="haystack_len">
<parameter_description> the maximum length of @haystack.
</parameter_description>
</parameter>
<parameter name="needle">
<parameter_description> the nul-terminated string to search for.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to the found occurrence, or
%NULL if not found.
</return>
</function>

<function name="g_variant_type_element">
<description>
Determines the element type of an array or maybe type.

This function may only be used with array or maybe types.

Since 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> an array or maybe #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> the element type of @type
</return>
</function>

<function name="g_queue_peek_nth">
<description>
Returns the @n'th element of @queue. 

Since: 2.4

</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue
</parameter_description>
</parameter>
<parameter name="n">
<parameter_description> the position of the element.
</parameter_description>
</parameter>
</parameters>
<return> The data for the @n'th element of @queue, or %NULL if @n is
off the end of @queue.

</return>
</function>

<function name="g_io_channel_flush">
<description>
Flushes the write buffer for the GIOChannel.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store an error of type #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> the status of the operation: One of
#G_IO_STATUS_NORMAL, #G_IO_STATUS_AGAIN, or
#G_IO_STATUS_ERROR.
</return>
</function>

<function name="g_variant_new_string">
<description>
Creates a string #GVariant with the contents of @string.

@string must be valid utf8.

Since: 2.24

</description>
<parameters>
<parameter name="string">
<parameter_description> a normal utf8 nul-terminated string
</parameter_description>
</parameter>
</parameters>
<return> a new string #GVariant instance
</return>
</function>

<function name="g_ptr_array_index">
<description>
Returns the pointer at the given index of the pointer array.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the pointer to return.
</parameter_description>
</parameter>
</parameters>
<return> the pointer at the given index.
</return>
</function>

<function name="g_main_loop_ref">
<description>
Increases the reference count on a #GMainLoop object by one.


</description>
<parameters>
<parameter name="loop">
<parameter_description> a #GMainLoop
</parameter_description>
</parameter>
</parameters>
<return> @loop
</return>
</function>

<function name="g_bookmark_file_move_item">
<description>
Changes the URI of a bookmark item from @old_uri to @new_uri.  Any
existing bookmark for @new_uri will be overwritten.  If @new_uri is
%NULL, then the bookmark is removed.

In the event the URI cannot be found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="old_uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="new_uri">
<parameter_description> a valid URI, or %NULL
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the URI was successfully changed

</return>
</function>

<function name="g_byte_array_sort">
<description>
Sorts a byte array, using @compare_func which should be a
qsort()-style comparison function (returns less than zero for first
arg is less than second arg, zero for equal, greater than zero if
first arg is greater than second arg).

If two array elements compare equal, their order in the sorted array
is undefined.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GByteArray.
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> comparison function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_match_info_fetch_pos">
<description>
Retrieves the position in bytes of the @match_num&lt;!-- --&gt;'th capturing
parentheses. 0 is the full text of the match, 1 is the first
paren set, 2 the second, and so on.

If @match_num is a valid sub pattern but it didn't match anything
(e.g. sub pattern 1, matching &quot;b&quot; against &quot;(a)?b&quot;) then @start_pos
and @end_pos are set to -1 and %TRUE is returned.

If the match was obtained using the DFA algorithm, that is using
g_regex_match_all() or g_regex_match_all_full(), the retrieved
position is not that of a set of parentheses but that of a matched
substring. Substrings are matched in reverse order of length, so
0 is the longest match.

Since: 2.14

</description>
<parameters>
<parameter name="match_info">
<parameter_description> #GMatchInfo structure
</parameter_description>
</parameter>
<parameter name="match_num">
<parameter_description> number of the sub expression
</parameter_description>
</parameter>
<parameter name="start_pos">
<parameter_description> pointer to location where to store
the start position, or %NULL
</parameter_description>
</parameter>
<parameter name="end_pos">
<parameter_description> pointer to location where to store
the end position, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the position was fetched, %FALSE otherwise. If
the position cannot be fetched, @start_pos and @end_pos are left
unchanged

</return>
</function>

<function name="g_type_from_name">
<description>
Lookup the type ID from a given type name, returning 0 if no type
has been registered under this name (this is the preferred method
to find out by name whether a specific type has been registered
yet).


</description>
<parameters>
<parameter name="name">
<parameter_description> Type name to lookup.
</parameter_description>
</parameter>
</parameters>
<return> Corresponding type ID or 0.
</return>
</function>

<function name="g_queue_pop_head_link">
<description>
Removes the first element of the queue.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
</parameters>
<return> the #GList element at the head of the queue, or %NULL if the queue
is empty.
</return>
</function>

<function name="g_list_remove_all">
<description>
Removes all list nodes with data equal to @data. 
Returns the new head of the list. Contrast with 
g_list_remove() which removes only the first node 
matching the given data.


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> data to remove
</parameter_description>
</parameter>
</parameters>
<return> new head of @list
</return>
</function>

<function name="g_value_unset">
<description>
Clears the current value in @value and &quot;unsets&quot; the type,
this releases all resources associated with this GValue.
An unset value is the same as an uninitialized (zero-filled)
#GValue structure.

</description>
<parameters>
<parameter name="value">
<parameter_description> An initialized #GValue structure.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_static_mutex_unlock">
<description>
Works like g_mutex_unlock(), but for a #GStaticMutex.

</description>
<parameters>
<parameter name="mutex">
<parameter_description> a #GStaticMutex.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_bookmark_file_set_icon">
<description>
Sets the icon for the bookmark for @uri. If @href is %NULL, unsets
the currently set icon. @href can either be a full URL for the icon
file or the icon name following the Icon Naming specification.

If no bookmark for @uri is found one is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="href">
<parameter_description> the URI of the icon for the bookmark, or %NULL
</parameter_description>
</parameter>
<parameter name="mime_type">
<parameter_description> the MIME type of the icon for the bookmark
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_mutex_new">
<description>
Creates a new #GMutex.

&lt;note&gt;&lt;para&gt;This function will abort if g_thread_init() has not been
called yet.&lt;/para&gt;&lt;/note&gt;

</description>
<parameters>
</parameters>
<return> a new #GMutex.
</return>
</function>

<function name="g_type_class_unref_uncached">
<description>
A variant of g_type_class_unref() for use in #GTypeClassCacheFunc
implementations. It unreferences a class without consulting the chain
of #GTypeClassCacheFunc&lt;!-- --&gt;s, avoiding the recursion which would occur
otherwise.

</description>
<parameters>
<parameter name="g_class">
<parameter_description> The #GTypeClass structure to unreference.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_get">
<description>
Returns the data that @iter points to.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return> the data that @iter points to

</return>
</function>

<function name="g_array_remove_index_fast">
<description>
Removes the element at the given index from a #GArray. The last
element in the array is used to fill in the space, so this function
does not preserve the order of the #GArray. But it is faster than
g_array_remove_index().

</description>
<parameters>
<parameter name="array">
<parameter_description> a @GArray.
</parameter_description>
</parameter>
<parameter name="index_">
<parameter_description> the index of the element to remove.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_object_notify_by_pspec">
<description>
Emits a &quot;notify&quot; signal for the property specified by @pspec on @object.

This function omits the property name lookup, hence it is faster than
g_object_notify().

One way to avoid using g_object_notify() from within the
class that registered the properties, and using g_object_notify_by_pspec()
instead, is to store the GParamSpec used with
g_object_class_install_property() inside a static array, e.g.:

|[
enum
{
PROP_0,
PROP_FOO,
PROP_LAST
};

static GParamSpec *properties[PROP_LAST];

static void
my_object_class_init (MyObjectClass *klass)
{
properties[PROP_FOO] = g_param_spec_int (&quot;foo&quot;, &quot;Foo&quot;, &quot;The foo&quot;,
0, 100,
50,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_FOO,
properties[PROP_FOO]);
}
]|

and then notify a change on the &quot;foo&quot; property with:

|[
g_object_notify_by_pspec (self, properties[PROP_FOO]);
]|

Since: 2.26

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="pspec">
<parameter_description> the #GParamSpec of a property installed on the class of @object.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_test_rand_int_range">
<description>
Get a reproducible random integer number out of a specified range,
see g_test_rand_int() for details on test case random numbers.

Since: 2.16

</description>
<parameters>
<parameter name="begin">
<parameter_description> the minimum value returned by this function
</parameter_description>
</parameter>
<parameter name="end">
<parameter_description>   the smallest value not to be returned by this function
</parameter_description>
</parameter>
</parameters>
<return> a number with @begin &lt;= number &lt; @end.

</return>
</function>

<function name="g_datalist_remove_data">
<description>
Removes an element using its string identifier. The data element's
destroy function is called if it has been set.

</description>
<parameters>
<parameter name="dl">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="k">
<parameter_description> the string identifying the data element.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_main_loop_new">
<description>
Creates a new #GMainLoop structure.


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext  (if %NULL, the default context will be used).
</parameter_description>
</parameter>
<parameter name="is_running">
<parameter_description> set to %TRUE to indicate that the loop is running. This
is not very important since calling g_main_loop_run() will set this to
%TRUE anyway.
</parameter_description>
</parameter>
</parameters>
<return> a new #GMainLoop.
</return>
</function>

<function name="g_key_file_load_from_file">
<description>
Loads a key file into an empty #GKeyFile structure.
If the file could not be loaded then %error is set to 
either a #GFileError or #GKeyFileError.

Since: 2.6

</description>
<parameters>
<parameter name="key_file">
<parameter_description> an empty #GKeyFile struct
</parameter_description>
</parameter>
<parameter name="file">
<parameter_description> the path of a filename to load, in the GLib filename encoding
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags from #GKeyFileFlags
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a key file could be loaded, %FALSE otherwise

</return>
</function>

<function name="g_test_log_buffer_pop">
<description>
Internal function for gtester to retrieve test log messages, no ABI guarantees provided.

</description>
<parameters>
</parameters>
<return></return>
</function>

<function name="g_tree_height">
<description>
Gets the height of a #GTree.

If the #GTree contains no nodes, the height is 0.
If the #GTree contains only one root node the height is 1.
If the root node has children the height is 2, etc.


</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
</parameters>
<return> the height of the #GTree.
</return>
</function>

<function name="g_object_get_property">
<description>
Gets a property of an object.

In general, a copy is made of the property contents and the caller is
responsible for freeing the memory by calling g_value_unset().

Note that g_object_get_property() is really intended for language
bindings, g_object_get() is much more convenient for C programming.

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
<parameter name="property_name">
<parameter_description> the name of the property to get
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> return location for the property value
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_main_loop_quit">
<description>
Stops a #GMainLoop from running. Any calls to g_main_loop_run()
for the loop will return. 

Note that sources that have already been dispatched when 
g_main_loop_quit() is called will still be executed.

</description>
<parameters>
<parameter name="loop">
<parameter_description> a #GMainLoop
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_unichar_to_utf8">
<description>
Converts a single character to UTF-8.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character code
</parameter_description>
</parameter>
<parameter name="outbuf">
<parameter_description> output buffer, must have at least 6 bytes of space.
If %NULL, the length will be computed and returned
and nothing will be written to @outbuf.
</parameter_description>
</parameter>
</parameters>
<return> number of bytes written
</return>
</function>

<function name="g_signal_parse_name">
<description>
Internal function to parse a signal name into its @signal_id
and @detail quark.


</description>
<parameters>
<parameter name="detailed_signal">
<parameter_description> a string of the form &quot;signal-name::detail&quot;.
</parameter_description>
</parameter>
<parameter name="itype">
<parameter_description> The interface/instance type that introduced &quot;signal-name&quot;.
</parameter_description>
</parameter>
<parameter name="signal_id_p">
<parameter_description> Location to store the signal id.
</parameter_description>
</parameter>
<parameter name="detail_p">
<parameter_description> Location to store the detail quark.
</parameter_description>
</parameter>
<parameter name="force_detail_quark">
<parameter_description> %TRUE forces creation of a #GQuark for the detail.
</parameter_description>
</parameter>
</parameters>
<return> Whether the signal name could successfully be parsed and @signal_id_p and @detail_p contain valid return values.
</return>
</function>

<function name="g_variant_iter_n_children">
<description>
Queries the number of child items in the container that we are
iterating over.  This is the total number of items -- not the number
of items remaining.

This function might be useful for preallocation of arrays.

Since: 2.24

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GVariantIter
</parameter_description>
</parameter>
</parameters>
<return> the number of children in the container
</return>
</function>

<function name="g_main_context_default">
<description>
Returns the global default main context. This is the main context
used for main loop functions when a main loop is not explicitly
specified, and corresponds to the &quot;main&quot; main loop. See also
g_main_context_get_thread_default().


</description>
<parameters>
</parameters>
<return> the global default main context.
</return>
</function>

<function name="g_string_chunk_free">
<description>
Frees all memory allocated by the #GStringChunk.
After calling g_string_chunk_free() it is not safe to
access any of the strings which were contained within it.

</description>
<parameters>
<parameter name="chunk">
<parameter_description> a #GStringChunk 
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_get_current_dir">
<description>
Gets the current directory.
The returned string should be freed when no longer needed. The encoding 
of the returned string is system defined. On Windows, it is always UTF-8.


</description>
<parameters>
</parameters>
<return> the current directory.
</return>
</function>

<function name="g_datalist_id_get_data">
<description>
Retrieves the data element corresponding to @key_id.

</description>
<parameters>
<parameter name="datalist">
<parameter_description> a datalist.
</parameter_description>
</parameter>
<parameter name="key_id">
<parameter_description> the #GQuark identifying a data element.
</parameter_description>
</parameter>
</parameters>
<return> the data element, or %NULL if it is not found.
</return>
</function>

<function name="g_string_set_size">
<description>
Sets the length of a #GString. If the length is less than
the current length, the string will be truncated. If the
length is greater than the current length, the contents
of the newly added area are undefined. (However, as
always, string-&gt;str[string-&gt;len] will be a nul byte.) 


</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the new length
</parameter_description>
</parameter>
</parameters>
<return> @string
</return>
</function>

<function name="g_bookmark_file_remove_group">
<description>
Removes @group from the list of groups to which the bookmark
for @uri belongs to.

In the event the URI cannot be found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
In the event no group was defined, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_INVALID_VALUE.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="group">
<parameter_description> the group name to be removed
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @group was successfully removed.

</return>
</function>

<function name="g_bookmark_file_set_app_info">
<description>
Sets the meta-data of application @name inside the list of
applications that have registered a bookmark for @uri inside
@bookmark.

You should rarely use this function; use g_bookmark_file_add_application()
and g_bookmark_file_remove_application() instead.

@name can be any UTF-8 encoded string used to identify an
application.
@exec can have one of these two modifiers: &quot;%f&quot;, which will
be expanded as the local file name retrieved from the bookmark's
URI; &quot;%u&quot;, which will be expanded as the bookmark's URI.
The expansion is done automatically when retrieving the stored
command line using the g_bookmark_file_get_app_info() function.
@count is the number of times the application has registered the
bookmark; if is &lt; 0, the current registration count will be increased
by one, if is 0, the application with @name will be removed from
the list of registered applications.
@stamp is the Unix time of the last registration; if it is -1, the
current time will be used.

If you try to remove an application by setting its registration count to
zero, and no bookmark for @uri is found, %FALSE is returned and
@error is set to #G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly,
in the event that no application @name has registered a bookmark
for @uri,  %FALSE is returned and error is set to
#G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.  Otherwise, if no bookmark
for @uri is found, one is created.

Since: 2.12

</description>
<parameters>
<parameter name="bookmark">
<parameter_description> a #GBookmarkFile
</parameter_description>
</parameter>
<parameter name="uri">
<parameter_description> a valid URI
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> an application's name
</parameter_description>
</parameter>
<parameter name="exec">
<parameter_description> an application's command line
</parameter_description>
</parameter>
<parameter name="count">
<parameter_description> the number of registrations done for this application
</parameter_description>
</parameter>
<parameter name="stamp">
<parameter_description> the time of the last registration for this application
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the application's meta-data was successfully
changed.

</return>
</function>

<function name="g_strsplit_set">
<description>
Splits @string into a number of tokens not containing any of the characters
in @delimiter. A token is the (possibly empty) longest string that does not
contain any of the characters in @delimiters. If @max_tokens is reached, the
remainder is appended to the last token.

For example the result of g_strsplit_set (&quot;abc:def/ghi&quot;, &quot;:/&quot;, -1) is a
%NULL-terminated vector containing the three strings &quot;abc&quot;, &quot;def&quot;, 
and &quot;ghi&quot;.

The result if g_strsplit_set (&quot;:def/ghi:&quot;, &quot;:/&quot;, -1) is a %NULL-terminated
vector containing the four strings &quot;&quot;, &quot;def&quot;, &quot;ghi&quot;, and &quot;&quot;.

As a special case, the result of splitting the empty string &quot;&quot; is an empty
vector, not a vector containing a single string. The reason for this
special case is that being able to represent a empty vector is typically
more useful than consistent handling of empty elements. If you do need
to represent empty elements, you'll need to check for the empty string
before calling g_strsplit_set().

Note that this function works on bytes not characters, so it can't be used 
to delimit UTF-8 strings for anything but ASCII characters.

Since: 2.4

</description>
<parameters>
<parameter name="string">
<parameter_description> The string to be tokenized
</parameter_description>
</parameter>
<parameter name="delimiters">
<parameter_description> A nul-terminated string containing bytes that are used
to split the string.
</parameter_description>
</parameter>
<parameter name="max_tokens">
<parameter_description> The maximum number of tokens to split @string into. 
If this is less than 1, the string is split completely
</parameter_description>
</parameter>
</parameters>
<return> a newly-allocated %NULL-terminated array of strings. Use 
g_strfreev() to free it.

</return>
</function>

<function name="g_cclosure_new_swap">
<description>
Creates a new closure which invokes @callback_func with @user_data as
the first parameter.


</description>
<parameters>
<parameter name="callback_func">
<parameter_description> the function to invoke
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to @callback_func
</parameter_description>
</parameter>
<parameter name="destroy_data">
<parameter_description> destroy notify to be called when @user_data is no longer used
</parameter_description>
</parameter>
</parameters>
<return> a new #GCClosure
</return>
</function>

<function name="g_key_file_load_from_dirs">
<description>
This function looks for a key file named @file in the paths
specified in @search_dirs, loads the file into @key_file and
returns the file's full path in @full_path.  If the file could not
be loaded then an %error is set to either a #GFileError or
#GKeyFileError.

Since: 2.14

</description>
<parameters>
<parameter name="key_file">
<parameter_description> an empty #GKeyFile struct
</parameter_description>
</parameter>
<parameter name="file">
<parameter_description> a relative path to a filename to open and parse
</parameter_description>
</parameter>
<parameter name="search_dirs">
<parameter_description> %NULL-terminated array of directories to search
</parameter_description>
</parameter>
<parameter name="full_path">
<parameter_description> return location for a string containing the full path
of the file, or %NULL
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags from #GKeyFileFlags
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for a #GError, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if a key file could be loaded, %FALSE otherwise

</return>
</function>

<function name="g_variant_get_handle">
<description>
Returns the 32-bit signed integer value of @value.

It is an error to call this function with a @value of any type other
than %G_VARIANT_TYPE_HANDLE.

By convention, handles are indexes into an array of file descriptors
that are sent alongside a DBus message.  If you're not interacting
with DBus, you probably don't need them.

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a handle #GVariant instance
</parameter_description>
</parameter>
</parameters>
<return> a #gint32
</return>
</function>

<function name="g_timer_new">
<description>
Creates a new timer, and starts timing (i.e. g_timer_start() is
implicitly called for you).

</description>
<parameters>
</parameters>
<return> a new #GTimer.
</return>
</function>

<function name="g_creat">
<description>
A wrapper for the POSIX creat() function. The creat() function is
used to convert a pathname into a file descriptor, creating a file
if necessary.

On POSIX systems file descriptors are implemented by the operating
system. On Windows, it's the C library that implements creat() and
file descriptors. The actual Windows API for opening files is
different, see MSDN documentation for CreateFile(). The Win32 API
uses file handles, which are more randomish integers, not small
integers like file descriptors.

Because file descriptors are specific to the C library on Windows,
the file descriptor returned by this function makes sense only to
functions in the same C library. Thus if the GLib-using code uses a
different C library than GLib does, the file descriptor returned by
this function cannot be passed to C library functions like write()
or read().

See your C library manual for more details about creat().

Since: 2.8

</description>
<parameters>
<parameter name="filename">
<parameter_description> a pathname in the GLib file name encoding (UTF-8 on Windows)
</parameter_description>
</parameter>
<parameter name="mode">
<parameter_description> as in creat()
</parameter_description>
</parameter>
</parameters>
<return> a new file descriptor, or -1 if an error occurred. The
return value can be used exactly like the return value from creat().

</return>
</function>

<function name="g_test_trap_has_passed">
<description>
Check the result of the last g_test_trap_fork() call.

Since: 2.16

</description>
<parameters>
</parameters>
<return> %TRUE if the last forked child terminated successfully.

</return>
</function>

<function name="g_utf8_get_char_validated">
<description>
Convert a sequence of bytes encoded as UTF-8 to a Unicode character.
This function checks for incomplete characters, for invalid characters
such as characters that are out of the range of Unicode, and for
overlong encodings of valid characters.


</description>
<parameters>
<parameter name="p">
<parameter_description> a pointer to Unicode character encoded as UTF-8
</parameter_description>
</parameter>
<parameter name="max_len">
<parameter_description> the maximum number of bytes to read, or -1, for no maximum or
if @p is nul-terminated
</parameter_description>
</parameter>
</parameters>
<return> the resulting character. If @p points to a partial
sequence at the end of a string that could begin a valid 
character (or if @max_len is zero), returns (gunichar)-2; 
otherwise, if @p does not point to a valid UTF-8 encoded 
Unicode character, returns (gunichar)-1.
</return>
</function>

<function name="g_value_get_object">
<description>
Get the contents of a %G_TYPE_OBJECT derived #GValue.


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_OBJECT derived type
</parameter_description>
</parameter>
</parameters>
<return> object contents of @value
</return>
</function>

<function name="g_sequence_iter_is_end">
<description>
Returns whether @iter is the end iterator

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
</parameters>
<return> Whether @iter is the end iterator.

</return>
</function>

<function name="g_uri_unescape_string">
<description>
Unescapes a whole escaped string.

If any of the characters in @illegal_characters or the character zero appears
as an escaped character in @escaped_string then that is an error and %NULL
will be returned. This is useful it you want to avoid for instance having a
slash being expanded in an escaped path element, which might confuse pathname
handling.

Since: 2.16

</description>
<parameters>
<parameter name="escaped_string">
<parameter_description> an escaped string to be unescaped.
</parameter_description>
</parameter>
<parameter name="illegal_characters">
<parameter_description> an optional string of illegal characters not to be allowed.
</parameter_description>
</parameter>
</parameters>
<return> an unescaped version of @escaped_string. The returned string 
should be freed when no longer needed.

</return>
</function>

<function name="g_string_append_vprintf">
<description>
Appends a formatted string onto the end of a #GString.
This function is similar to g_string_append_printf()
except that the arguments to the format string are passed
as a va_list.

Since: 2.14

</description>
<parameters>
<parameter name="string">
<parameter_description> a #GString
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> the string format. See the printf() documentation
</parameter_description>
</parameter>
<parameter name="args">
<parameter_description> the list of arguments to insert in the output
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_spawn_command_line_sync">
<description>
A simple version of g_spawn_sync() with little-used parameters
removed, taking a command line instead of an argument vector.  See
g_spawn_sync() for full details. @command_line will be parsed by
g_shell_parse_argv(). Unlike g_spawn_sync(), the %G_SPAWN_SEARCH_PATH flag
is enabled. Note that %G_SPAWN_SEARCH_PATH can have security
implications, so consider using g_spawn_sync() directly if
appropriate. Possible errors are those from g_spawn_sync() and those
from g_shell_parse_argv().

If @exit_status is non-%NULL, the exit status of the child is stored there as
it would be returned by waitpid(); standard UNIX macros such as WIFEXITED()
and WEXITSTATUS() must be used to evaluate the exit status.

On Windows, please note the implications of g_shell_parse_argv()
parsing @command_line. Parsing is done according to Unix shell rules, not 
Windows command interpreter rules.
Space is a separator, and backslashes are
special. Thus you cannot simply pass a @command_line containing
canonical Windows paths, like &quot;c:\\program files\\app\\app.exe&quot;, as
the backslashes will be eaten, and the space will act as a
separator. You need to enclose such paths with single quotes, like
&quot;'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'&quot;.


</description>
<parameters>
<parameter name="command_line">
<parameter_description> a command line 
</parameter_description>
</parameter>
<parameter name="standard_output">
<parameter_description> return location for child output
</parameter_description>
</parameter>
<parameter name="standard_error">
<parameter_description> return location for child errors
</parameter_description>
</parameter>
<parameter name="exit_status">
<parameter_description> return location for child exit status, as returned by waitpid()
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> return location for errors
</parameter_description>
</parameter>
</parameters>
<return> %TRUE on success, %FALSE if an error was set
</return>
</function>

<function name="g_test_suite_add_suite">
<description>
Adds @nestedsuite to @suite.

Since: 2.16

</description>
<parameters>
<parameter name="suite">
<parameter_description>       a #GTestSuite
</parameter_description>
</parameter>
<parameter name="nestedsuite">
<parameter_description> another #GTestSuite
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_async_queue_timed_pop">
<description>
Pops data from the @queue. If no data is received before @end_time,
%NULL is returned.

To easily calculate @end_time a combination of g_get_current_time()
and g_time_val_add() can be used.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
<parameter name="end_time">
<parameter_description> a #GTimeVal, determining the final time.
</parameter_description>
</parameter>
</parameters>
<return> data from the queue or %NULL, when no data is
received before @end_time.
</return>
</function>

<function name="g_type_interface_get_plugin">
<description>
Returns the #GTypePlugin structure for the dynamic interface
@interface_type which has been added to @instance_type, or %NULL if
@interface_type has not been added to @instance_type or does not
have a #GTypePlugin structure. See g_type_add_interface_dynamic().


</description>
<parameters>
<parameter name="instance_type">
<parameter_description> the #GType value of an instantiatable type.
</parameter_description>
</parameter>
<parameter name="interface_type">
<parameter_description> the #GType value of an interface type.
</parameter_description>
</parameter>
</parameters>
<return> the #GTypePlugin for the dynamic interface @interface_type
of @instance_type.
</return>
</function>

<function name="g_sequence_get_iter_at_pos">
<description>
Returns the iterator at position @pos. If @pos is negative or larger
than the number of items in @seq, the end iterator is returned.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
<parameter name="pos">
<parameter_description> a position in @seq, or -1 for the end.
</parameter_description>
</parameter>
</parameters>
<return> The #GSequenceIter at position @pos

</return>
</function>

<function name="g_mem_chunk_create">
<description>
A convenience macro for creating a new #GMemChunk. It calls
g_mem_chunk_new(), using the given type to create the #GMemChunk
name. The atom size is determined using
&lt;function&gt;sizeof()&lt;/function&gt;, and the area size is calculated by
multiplying the @pre_alloc parameter with the atom size.

Deprecated:2.10: Use the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
allocator&lt;/link&gt; instead

</description>
<parameters>
<parameter name="type">
<parameter_description> the type of the atoms, typically a structure name.
</parameter_description>
</parameter>
<parameter name="pre_alloc">
<parameter_description> the number of atoms to store in each block of memory.
</parameter_description>
</parameter>
<parameter name="alloc_type">
<parameter_description> the type of the #GMemChunk.  #G_ALLOC_AND_FREE is used
if the atoms will be freed individually.  #G_ALLOC_ONLY
should be used if atoms will never be freed
individually.  #G_ALLOC_ONLY is quicker, since it does
not need to track free atoms, but it obviously wastes
memory if you no longer need many of the atoms.
</parameter_description>
</parameter>
</parameters>
<return> the new #GMemChunk.
</return>
</function>

<function name="g_variant_builder_add_value">
<description>
Adds @value to @builder.

It is an error to call this function in any way that would create an
inconsistent value to be constructed.  Some examples of this are
putting different types of items into an array, putting the wrong
types or number of items in a tuple, putting more than one value into
a variant, etc.

Since: 2.24

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> a #GVariant
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_steal_qdata">
<description>
This function gets back user data pointers stored via
g_object_set_qdata() and removes the @data from object
without invoking its destroy() function (if any was
set).
Usually, calling this function is only required to update
user data pointers with a destroy notifier, for example:
|[
void
object_add_to_user_list (GObject     *object,
const gchar *new_string)
{
// the quark, naming the object data
GQuark quark_string_list = g_quark_from_static_string (&quot;my-string-list&quot;);
// retrive the old string list
GList *list = g_object_steal_qdata (object, quark_string_list);

// prepend new string
list = g_list_prepend (list, g_strdup (new_string));
// this changed 'list', so we need to set it again
g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
}
static void
free_string_list (gpointer data)
{
GList *node, *list = data;

for (node = list; node; node = node-&gt;next)
g_free (node-&gt;data);
g_list_free (list);
}
]|
Using g_object_get_qdata() in the above example, instead of
g_object_steal_qdata() would have left the destroy function set,
and thus the partial string list would have been freed upon
g_object_set_qdata_full().


</description>
<parameters>
<parameter name="object">
<parameter_description> The GObject to get a stored user data pointer from
</parameter_description>
</parameter>
<parameter name="quark">
<parameter_description> A #GQuark, naming the user data pointer
</parameter_description>
</parameter>
</parameters>
<return> The user data pointer set, or %NULL
</return>
</function>

<function name="g_atomic_int_exchange_and_add">
<description>
Atomically adds @val to the integer pointed to by @atomic.
It returns the value of *@atomic just before the addition
took place. Also acts as a memory barrier.

Since: 2.4

</description>
<parameters>
<parameter name="atomic">
<parameter_description> a pointer to an integer
</parameter_description>
</parameter>
<parameter name="val">
<parameter_description> the value to add to *@atomic
</parameter_description>
</parameter>
</parameters>
<return> the value of *@atomic before the addition.

</return>
</function>

<function name="g_object_new_valist">
<description>
Creates a new instance of a #GObject subtype and sets its properties.

Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY)
which are not explicitly specified are set to their default values.


</description>
<parameters>
<parameter name="object_type">
<parameter_description> the type id of the #GObject subtype to instantiate
</parameter_description>
</parameter>
<parameter name="first_property_name">
<parameter_description> the name of the first property
</parameter_description>
</parameter>
<parameter name="var_args">
<parameter_description> the value of the first property, followed optionally by more
name/value pairs, followed by %NULL
</parameter_description>
</parameter>
</parameters>
<return> a new instance of @object_type
</return>
</function>

<function name="g_utf16_to_utf8">
<description>
Convert a string from UTF-16 to UTF-8. The result will be
terminated with a 0 byte.

Note that the input is expected to be already in native endianness,
an initial byte-order-mark character is not handled specially.
g_convert() can be used to convert a byte buffer of UTF-16 data of
ambiguous endianess.

Further note that this function does not validate the result
string; it may e.g. include embedded NUL characters. The only
validation done by this function is to ensure that the input can
be correctly interpreted as UTF-16, i.e. it doesn't contain
things unpaired surrogates.


</description>
<parameters>
<parameter name="str">
<parameter_description> a UTF-16 encoded string
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the maximum length (number of &lt;type&gt;gunichar2&lt;/type&gt;) of @str to use. 
If @len &lt; 0, then the string is nul-terminated.
</parameter_description>
</parameter>
<parameter name="items_read">
<parameter_description> location to store number of words read, or %NULL.
If %NULL, then %G_CONVERT_ERROR_PARTIAL_INPUT will be
returned in case @str contains a trailing partial
character. If an error occurs then the index of the
invalid input is stored here.
</parameter_description>
</parameter>
<parameter name="items_written">
<parameter_description> location to store number of bytes written, or %NULL.
The value stored here does not include the trailing
0 byte.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> location to store the error occuring, or %NULL to ignore
errors. Any of the errors in #GConvertError other than
%G_CONVERT_ERROR_NO_CONVERSION may occur.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to a newly allocated UTF-8 string.
This value must be freed with g_free(). If an
error occurs, %NULL will be returned and
@error set.
</return>
</function>

<function name="g_option_context_set_ignore_unknown_options">
<description>
Sets whether to ignore unknown options or not. If an argument is 
ignored, it is left in the @argv array after parsing. By default, 
g_option_context_parse() treats unknown options as error.

This setting does not affect non-option arguments (i.e. arguments 
which don't start with a dash). But note that GOption cannot reliably
determine whether a non-option belongs to a preceding unknown option.

Since: 2.6

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="ignore_unknown">
<parameter_description> %TRUE to ignore unknown options, %FALSE to produce
an error when unknown options are met
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_value_register_transform_func">
<description>
Registers a value transformation function for use in g_value_transform().
A previously registered transformation function for @src_type and @dest_type
will be replaced.

</description>
<parameters>
<parameter name="src_type">
<parameter_description> Source type.
</parameter_description>
</parameter>
<parameter name="dest_type">
<parameter_description> Target type.
</parameter_description>
</parameter>
<parameter name="transform_func">
<parameter_description> a function which transforms values of type @src_type
into value of type @dest_type
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_ref">
<description>
Increases the reference count of @object.


</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
</parameters>
<return> the same @object
</return>
</function>

<function name="g_checksum_copy">
<description>
Copies a #GChecksum. If @checksum has been closed, by calling
g_checksum_get_string() or g_checksum_get_digest(), the copied
checksum will be closed as well.

Since: 2.16

</description>
<parameters>
<parameter name="checksum">
<parameter_description> the #GChecksum to copy
</parameter_description>
</parameter>
</parameters>
<return> the copy of the passed #GChecksum. Use g_checksum_free()
when finished using it.

</return>
</function>

<function name="g_test_log_set_fatal_handler">
<description>
Installs a non-error fatal log handler which can be
used to decide whether log messages which are counted
as fatal abort the program.

The use case here is that you are running a test case
that depends on particular libraries or circumstances
and cannot prevent certain known critical or warning
messages. So you install a handler that compares the
domain and message to precisely not abort in such a case.

Note that the handler is reset at the beginning of
any test case, so you have to set it inside each test
function which needs the special behavior.

This handler has no effect on g_error messages.

Since: 2.22

</description>
<parameters>
<parameter name="log_func">
<parameter_description> the log handler function.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> data passed to the log handler.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_markup_collect_attributes">
<description>
Collects the attributes of the element from the
data passed to the #GMarkupParser start_element
function, dealing with common error conditions
and supporting boolean values.

This utility function is not required to write
a parser but can save a lot of typing.

The @element_name, @attribute_names,
@attribute_values and @error parameters passed
to the start_element callback should be passed
unmodified to this function.

Following these arguments is a list of
&quot;supported&quot; attributes to collect.  It is an
error to specify multiple attributes with the
same name.  If any attribute not in the list
appears in the @attribute_names array then an
unknown attribute error will result.

The #GMarkupCollectType field allows specifying
the type of collection to perform and if a
given attribute must appear or is optional.

The attribute name is simply the name of the
attribute to collect.

The pointer should be of the appropriate type
(see the descriptions under
#GMarkupCollectType) and may be %NULL in case a
particular attribute is to be allowed but
ignored.

This function deals with issuing errors for missing attributes 
(of type %G_MARKUP_ERROR_MISSING_ATTRIBUTE), unknown attributes 
(of type %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE) and duplicate 
attributes (of type %G_MARKUP_ERROR_INVALID_CONTENT) as well 
as parse errors for boolean-valued attributes (again of type
%G_MARKUP_ERROR_INVALID_CONTENT). In all of these cases %FALSE 
will be returned and @error will be set as appropriate.

Since: 2.16

</description>
<parameters>
<parameter name="element_name">
<parameter_description> the current tag name
</parameter_description>
</parameter>
<parameter name="attribute_names">
<parameter_description> the attribute names
</parameter_description>
</parameter>
<parameter name="attribute_values">
<parameter_description> the attribute values
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> a pointer to a #GError or %NULL
</parameter_description>
</parameter>
<parameter name="first_type">
<parameter_description> the #GMarkupCollectType of the
first attribute
</parameter_description>
</parameter>
<parameter name="first_attr">
<parameter_description> the name of the first attribute
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> a pointer to the storage location of the
first attribute (or %NULL), followed by
more types names and pointers, ending
with %G_MARKUP_COLLECT_INVALID.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if successful

</return>
</function>

<function name="g_io_channel_get_line_term">
<description>
This returns the string that #GIOChannel uses to determine
where in the file a line break occurs. A value of %NULL
indicates autodetection.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> a location to return the length of the line terminator
</parameter_description>
</parameter>
</parameters>
<return> The line termination string. This value
is owned by GLib and must not be freed.
</return>
</function>

<function name="g_cclosure_marshal_VOID__BOOLEAN">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gboolean arg1, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 2
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding the instance and the #gboolean parameter
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_param_spec_get_name">
<description>
Get the name of a #GParamSpec.


</description>
<parameters>
<parameter name="pspec">
<parameter_description> a valid #GParamSpec
</parameter_description>
</parameter>
</parameters>
<return> the name of @pspec.
</return>
</function>

<function name="g_cclosure_marshal_VOID__VOID">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;void (*callback) (gpointer instance, gpointer user_data)&lt;/literal&gt;.

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> ignored
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 1
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding only the instance
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_basename">
<description>
Gets the name of the file without any leading directory components.  
It returns a pointer into the given file name string.

Deprecated:2.2: Use g_path_get_basename() instead, but notice that
g_path_get_basename() allocates new memory for the returned string, unlike
this function which returns a pointer into the argument.

</description>
<parameters>
<parameter name="file_name">
<parameter_description> the name of the file.
</parameter_description>
</parameter>
</parameters>
<return> the name of the file without any leading directory components.

</return>
</function>

<function name="g_value_set_static_boxed">
<description>
Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed.
The boxed value is assumed to be static, and is thus not duplicated
when setting the #GValue.

</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_BOXED derived type
</parameter_description>
</parameter>
<parameter name="v_boxed">
<parameter_description> static boxed value to be set
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_async_queue_try_pop_unlocked">
<description>
Tries to pop data from the @queue. If no data is available, %NULL is
returned. This function must be called while holding the @queue's
lock.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GAsyncQueue.
</parameter_description>
</parameter>
</parameters>
<return> data from the queue or %NULL, when no data is
available immediately.
</return>
</function>

<function name="g_value_dup_boxed">
<description>
Get the contents of a %G_TYPE_BOXED derived #GValue.  Upon getting,
the boxed value is duplicated and needs to be later freed with
g_boxed_free(), e.g. like: g_boxed_free (G_VALUE_TYPE (@value),
return_value);


</description>
<parameters>
<parameter name="value">
<parameter_description> a valid #GValue of %G_TYPE_BOXED derived type
</parameter_description>
</parameter>
</parameters>
<return> boxed contents of @value
</return>
</function>

<function name="g_node_reverse_children">
<description>
Reverses the order of the children of a #GNode.
(It doesn't change the order of the grandchildren.)

</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_error_new">
<description>
Creates a new #GError with the given @domain and @code,
and a message formatted with @format.


</description>
<parameters>
<parameter name="domain">
<parameter_description> error domain
</parameter_description>
</parameter>
<parameter name="code">
<parameter_description> error code
</parameter_description>
</parameter>
<parameter name="format">
<parameter_description> printf()-style format for error message
</parameter_description>
</parameter>
<parameter name="Varargs">
<parameter_description> parameters for message format
</parameter_description>
</parameter>
</parameters>
<return> a new #GError
</return>
</function>

<function name="g_poll">
<description>
Polls @fds, as with the poll() system call, but portably. (On
systems that don't have poll(), it is emulated using select().)
This is used internally by #GMainContext, but it can be called
directly if you need to block until a file descriptor is ready, but
don't want to run the full main loop.

Each element of @fds is a #GPollFD describing a single file
descriptor to poll. The %fd field indicates the file descriptor,
and the %events field indicates the events to poll for. On return,
the %revents fields will be filled with the events that actually
occurred.

On POSIX systems, the file descriptors in @fds can be any sort of
file descriptor, but the situation is much more complicated on
Windows. If you need to use g_poll() in code that has to run on
Windows, the easiest solution is to construct all of your
#GPollFD&lt;!-- --&gt;s with g_io_channel_win32_make_pollfd().

Since: 2.20

</description>
<parameters>
<parameter name="fds">
<parameter_description> file descriptors to poll
</parameter_description>
</parameter>
<parameter name="nfds">
<parameter_description> the number of file descriptors in @fds
</parameter_description>
</parameter>
<parameter name="timeout">
<parameter_description> amount of time to wait, in milliseconds, or -1 to wait forever
</parameter_description>
</parameter>
</parameters>
<return> the number of entries in @fds whose %revents fields
were filled in, or 0 if the operation timed out, or -1 on error or
if the call was interrupted.

</return>
</function>

<function name="g_relation_new">
<description>
Creates a new #GRelation with the given number of fields. Note that
currently the number of fields must be 2.

Deprecated: 2.26: Rarely used API

</description>
<parameters>
<parameter name="fields">
<parameter_description> the number of fields.
</parameter_description>
</parameter>
</parameters>
<return> a new #GRelation.
</return>
</function>

<function name="g_regex_ref">
<description>
Increases reference count of @regex by 1.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex
</parameter_description>
</parameter>
</parameters>
<return> @regex

</return>
</function>

<function name="g_sequence_sort_changed">
<description>
Moves the data pointed to a new position as indicated by @cmp_func. This
function should be called for items in a sequence already sorted according
to @cmp_func whenever some aspect of an item changes so that @cmp_func
may return different values for that item.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> A #GSequenceIter
</parameter_description>
</parameter>
<parameter name="cmp_func">
<parameter_description> the #GCompareDataFunc used to compare items in the sequence. It
is called with two items of the @seq and @user_data. It should
return 0 if the items are equal, a negative value if the first
item comes before the second, and a positive value if the second
item comes before the first.
</parameter_description>
</parameter>
<parameter name="cmp_data">
<parameter_description> user data passed to @cmp_func.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_string_ascii_up">
<description>
Converts all lower case ASCII letters to upper case ASCII letters.


</description>
<parameters>
<parameter name="string">
<parameter_description> a GString
</parameter_description>
</parameter>
</parameters>
<return> passed-in @string pointer, with all the lower case
characters converted to upper case in place, with
semantics that exactly match g_ascii_toupper().
</return>
</function>

<function name="g_slist_last">
<description>
Gets the last element in a #GSList.

&lt;note&gt;&lt;para&gt;
This function iterates over the whole list.
&lt;/para&gt;&lt;/note&gt;


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GSList 
</parameter_description>
</parameter>
</parameters>
<return> the last element in the #GSList, 
or %NULL if the #GSList has no elements
</return>
</function>

<function name="g_thread_pool_get_max_threads">
<description>
Returns the maximal number of threads for @pool.


</description>
<parameters>
<parameter name="pool">
<parameter_description> a #GThreadPool
</parameter_description>
</parameter>
</parameters>
<return> the maximal number of threads
</return>
</function>

<function name="g_variant_builder_new">
<description>
Allocates and initialises a new #GVariantBuilder.

You should call g_variant_builder_unref() on the return value when it
is no longer needed.  The memory will not be automatically freed by
any other call.

In most cases it is easier to place a #GVariantBuilder directly on
the stack of the calling function and initialise it with
g_variant_builder_init().

Since: 2.24

</description>
<parameters>
<parameter name="type">
<parameter_description> a container type
</parameter_description>
</parameter>
</parameters>
<return> a #GVariantBuilder
</return>
</function>

<function name="g_test_trap_reached_timeout">
<description>
Check the result of the last g_test_trap_fork() call.

Since: 2.16

</description>
<parameters>
</parameters>
<return> %TRUE if the last forked child got killed due to a fork timeout.

</return>
</function>

<function name="g_cache_value_foreach">
<description>
Calls the given function for each of the values in the #GCache.

Deprecated:2.10: The reason is that it passes pointers to internal
data structures to @func; use g_cache_key_foreach()
instead

</description>
<parameters>
<parameter name="cache">
<parameter_description> a #GCache.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the function to call with each #GCache value.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> user data to pass to the function.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_object_interface_list_properties">
<description>
Lists the properties of an interface.Generally, the interface
vtable passed in as @g_iface will be the default vtable from
g_type_default_interface_ref(), or, if you know the interface has
already been loaded, g_type_default_interface_peek().

Since: 2.4


</description>
<parameters>
<parameter name="g_iface">
<parameter_description> any interface vtable for the interface, or the default
vtable for the interface
</parameter_description>
</parameter>
<parameter name="n_properties_p">
<parameter_description> location to store number of properties returned.
</parameter_description>
</parameter>
</parameters>
<return> a pointer to an array of pointers to #GParamSpec
structures. The paramspecs are owned by GLib, but the
array should be freed with g_free() when you are done with
it.
</return>
</function>

<function name="g_timeout_add_full">
<description>
Sets a function to be called at regular intervals, with the given
priority.  The function is called repeatedly until it returns
%FALSE, at which point the timeout is automatically destroyed and
the function will not be called again.  The @notify function is
called when the timeout is destroyed.  The first call to the
function will be at the end of the first @interval.

Note that timeout functions may be delayed, due to the processing of other
event sources. Thus they should not be relied on for precise timing.
After each call to the timeout function, the time of the next
timeout is recalculated based on the current time and the given interval
(it does not try to 'catch up' time lost in delays).

This internally creates a main loop source using g_timeout_source_new()
and attaches it to the main loop context using g_source_attach(). You can
do these steps manually if you need greater control.


</description>
<parameters>
<parameter name="priority">
<parameter_description> the priority of the timeout source. Typically this will be in
the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
</parameter_description>
</parameter>
<parameter name="interval">
<parameter_description> the time between calls to the function, in milliseconds
(1/1000ths of a second)
</parameter_description>
</parameter>
<parameter name="function">
<parameter_description> function to call
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description>     data to pass to @function
</parameter_description>
</parameter>
<parameter name="notify">
<parameter_description>   function to call when the timeout is removed, or %NULL
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) of the event source.
</return>
</function>

<function name="g_bit_trylock">
<description>
Sets the indicated @lock_bit in @address, returning %TRUE if
successful.  If the bit is already set, returns %FALSE immediately.

Attempting to lock on two different bits within the same integer is
not supported.

The value of the bit that is set is (1u &lt;&lt; @bit).  If @bit is not
between 0 and 31 then the result is undefined.

This function accesses @address atomically.  All other accesses to
@address must be atomic in order for this function to work
reliably.

Since: 2.24

</description>
<parameters>
<parameter name="address">
<parameter_description> a pointer to an integer
</parameter_description>
</parameter>
<parameter name="lock_bit">
<parameter_description> a bit value between 0 and 31
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the lock was acquired
</return>
</function>

<function name="g_unichar_iszerowidth">
<description>
Determines if a given character typically takes zero width when rendered.
The return value is %TRUE for all non-spacing and enclosing marks
(e.g., combining accents), format characters, zero-width
space, but not U+00AD SOFT HYPHEN.

A typical use of this function is with one of g_unichar_iswide() or
g_unichar_iswide_cjk() to determine the number of cells a string occupies
when displayed on a grid display (terminals).  However, note that not all
terminals support zero-width rendering of zero-width marks.

Since: 2.14

</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the character has zero width

</return>
</function>

<function name="g_test_run">
<description>
Runs all tests under the toplevel suite which can be retrieved
with g_test_get_root(). Similar to g_test_run_suite(), the test
cases to be run are filtered according to
test path arguments (-p &lt;replaceable&gt;testpath&lt;/replaceable&gt;) as 
parsed by g_test_init().
g_test_run_suite() or g_test_run() may only be called once
in a program.

Since: 2.16

</description>
<parameters>
</parameters>
<return> 0 on success

</return>
</function>

<function name="g_list_position">
<description>
Gets the position of the given element 
in the #GList (starting from 0).


</description>
<parameters>
<parameter name="list">
<parameter_description> a #GList
</parameter_description>
</parameter>
<parameter name="llink">
<parameter_description> an element in the #GList
</parameter_description>
</parameter>
</parameters>
<return> the position of the element in the #GList, 
or -1 if the element is not found
</return>
</function>

<function name="g_ptr_array_new">
<description>
Creates a new #GPtrArray with a reference count of 1.

</description>
<parameters>
</parameters>
<return> the new #GPtrArray.
</return>
</function>

<function name="g_strreverse">
<description>
Reverses all of the bytes in a string. For example, 
&lt;literal&gt;g_strreverse (&quot;abcdef&quot;)&lt;/literal&gt; will result 
in &quot;fedcba&quot;.

Note that g_strreverse() doesn't work on UTF-8 strings 
containing multibyte characters. For that purpose, use 
g_utf8_strreverse().


</description>
<parameters>
<parameter name="string">
<parameter_description> the string to reverse 
</parameter_description>
</parameter>
</parameters>
<return> the same pointer passed in as @string
</return>
</function>

<function name="g_tree_replace">
<description>
Inserts a new key and value into a #GTree similar to g_tree_insert(). 
The difference is that if the key already exists in the #GTree, it gets 
replaced by the new key. If you supplied a @value_destroy_func when 
creating the #GTree, the old value is freed using that function. If you 
supplied a @key_destroy_func when creating the #GTree, the old key is 
freed using that function. 

The tree is automatically 'balanced' as new key/value pairs are added,
so that the distance from the root to every leaf is as small as possible.

</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
<parameter name="key">
<parameter_description> the key to insert.
</parameter_description>
</parameter>
<parameter name="value">
<parameter_description> the value corresponding to the key.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_node_find_child">
<description>
Finds the first child of a #GNode with the given data.


</description>
<parameters>
<parameter name="node">
<parameter_description> a #GNode
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> which types of children are to be searched, one of 
%G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the data to find
</parameter_description>
</parameter>
</parameters>
<return> the found child #GNode, or %NULL if the data is not found
</return>
</function>

<function name="g_closure_remove_invalidate_notifier">
<description>
Removes an invalidation notifier.

Notice that notifiers are automatically removed after they are run.

</description>
<parameters>
<parameter name="closure">
<parameter_description> a #GClosure
</parameter_description>
</parameter>
<parameter name="notify_data">
<parameter_description> data which was passed to g_closure_add_invalidate_notifier()
when registering @notify_func
</parameter_description>
</parameter>
<parameter name="notify_func">
<parameter_description> the callback function to remove
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_cclosure_marshal_BOOLEAN__OBJECT_BOXED_BOXED">
<description>
A marshaller for a #GCClosure with a callback of type
&lt;literal&gt;gboolean (*callback) (gpointer instance, GBoxed *arg1, GBoxed *arg2, gpointer user_data)&lt;/literal&gt;.

Since: 2.26

</description>
<parameters>
<parameter name="closure">
<parameter_description> the #GClosure to which the marshaller belongs
</parameter_description>
</parameter>
<parameter name="return_value">
<parameter_description> a #GValue, which can store the returned string
</parameter_description>
</parameter>
<parameter name="n_param_values">
<parameter_description> 3
</parameter_description>
</parameter>
<parameter name="param_values">
<parameter_description> a #GValue array holding instance, arg1 and arg2
</parameter_description>
</parameter>
<parameter name="invocation_hint">
<parameter_description> the invocation hint given as the last argument
to g_closure_invoke()
</parameter_description>
</parameter>
<parameter name="marshal_data">
<parameter_description> additional data specified when registering the marshaller
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_signal_override_class_closure">
<description>
Overrides the class closure (i.e. the default handler) for the given signal
for emissions on instances of @instance_type. @instance_type must be derived
from the type to which the signal belongs.

See g_signal_chain_from_overridden() and
g_signal_chain_from_overridden_handler() for how to chain up to the
parent class closure from inside the overridden one.

</description>
<parameters>
<parameter name="signal_id">
<parameter_description> the signal id
</parameter_description>
</parameter>
<parameter name="instance_type">
<parameter_description> the instance type on which to override the class closure
for the signal.
</parameter_description>
</parameter>
<parameter name="class_closure">
<parameter_description> the closure.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_slist_concat">
<description>
Adds the second #GSList onto the end of the first #GSList.
Note that the elements of the second #GSList are not copied.
They are used directly.


</description>
<parameters>
<parameter name="list1">
<parameter_description> a #GSList
</parameter_description>
</parameter>
<parameter name="list2">
<parameter_description> the #GSList to add to the end of the first #GSList
</parameter_description>
</parameter>
</parameters>
<return> the start of the new #GSList
</return>
</function>

<function name="g_ascii_strtoull">
<description>
Converts a string to a #guint64 value.
This function behaves like the standard strtoull() function
does in the C locale. It does this without actually
changing the current locale, since that would not be
thread-safe.

This function is typically used when reading configuration
files or other non-user input that should be locale independent.
To handle input from the user you should normally use the
locale-sensitive system strtoull() function.

If the correct value would cause overflow, %G_MAXUINT64
is returned, and %ERANGE is stored in %errno.  If the base is
outside the valid range, zero is returned, and %EINVAL is stored
in %errno.  If the string conversion fails, zero is returned, and
@endptr returns @nptr (if @endptr is non-%NULL).

Since: 2.2

</description>
<parameters>
<parameter name="nptr">
<parameter_description>    the string to convert to a numeric value.
</parameter_description>
</parameter>
<parameter name="endptr">
<parameter_description>  if non-%NULL, it returns the character after
the last character used in the conversion.
</parameter_description>
</parameter>
<parameter name="base">
<parameter_description>    to be used for the conversion, 2..36 or 0
</parameter_description>
</parameter>
</parameters>
<return> the #guint64 value or zero on error.

</return>
</function>

<function name="g_type_add_interface_dynamic">
<description>
Adds the dynamic @interface_type to @instantiable_type. The information
contained in the #GTypePlugin structure pointed to by @plugin
is used to manage the relationship.

</description>
<parameters>
<parameter name="instance_type">
<parameter_description> the #GType value of an instantiable type.
</parameter_description>
</parameter>
<parameter name="interface_type">
<parameter_description> the #GType value of an interface type.
</parameter_description>
</parameter>
<parameter name="plugin">
<parameter_description> the #GTypePlugin structure to retrieve the #GInterfaceInfo from.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_tree_ref">
<description>
Increments the reference count of @tree by one.  It is safe to call
this function from any thread.

Since: 2.22

</description>
<parameters>
<parameter name="tree">
<parameter_description> a #GTree.
</parameter_description>
</parameter>
</parameters>
<return> the passed in #GTree.

</return>
</function>

<function name="g_timeout_source_new">
<description>
Creates a new timeout source.

The source will not initially be associated with any #GMainContext
and must be added to one with g_source_attach() before it will be
executed.


</description>
<parameters>
<parameter name="interval">
<parameter_description> the timeout interval in milliseconds.
</parameter_description>
</parameter>
</parameters>
<return> the newly-created timeout source
</return>
</function>

<function name="g_main_context_get_poll_func">
<description>
Gets the poll function set by g_main_context_set_poll_func().


</description>
<parameters>
<parameter name="context">
<parameter_description> a #GMainContext
</parameter_description>
</parameter>
</parameters>
<return> the poll function
</return>
</function>

<function name="g_array_set_size">
<description>
Sets the size of the array, expanding it if necessary. If the array
was created with @clear_ set to %TRUE, the new elements are set to 0.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the new size of the #GArray.
</parameter_description>
</parameter>
</parameters>
<return> the #GArray.
</return>
</function>

<function name="g_unichar_toupper">
<description>
Converts a character to uppercase.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> the result of converting @c to uppercase.
If @c is not an lowercase or titlecase character,
or has no upper case equivalent @c is returned unchanged.
</return>
</function>

<function name="g_byte_array_prepend">
<description>
Adds the given data to the start of the #GByteArray. The array will
grow in size automatically if necessary.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GByteArray.
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> the byte data to be added.
</parameter_description>
</parameter>
<parameter name="len">
<parameter_description> the number of bytes to add.
</parameter_description>
</parameter>
</parameters>
<return> the #GByteArray.
</return>
</function>

<function name="g_param_spec_internal">
<description>
Creates a new #GParamSpec instance.

A property name consists of segments consisting of ASCII letters and
digits, separated by either the '-' or '_' character. The first
character of a property name must be a letter. Names which violate these
rules lead to undefined behaviour.

When creating and looking up a #GParamSpec, either separator can be
used, but they cannot be mixed. Using '-' is considerably more
efficient and in fact required when using property names as detail
strings for signals.

Beyond the name, #GParamSpec&lt;!-- --&gt;s have two more descriptive
strings associated with them, the @nick, which should be suitable
for use as a label for the property in a property editor, and the
@blurb, which should be a somewhat longer description, suitable for
e.g. a tooltip. The @nick and @blurb should ideally be localized.


</description>
<parameters>
<parameter name="param_type">
<parameter_description> the #GType for the property; must be derived from #G_TYPE_PARAM
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> the canonical name of the property
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> the nickname of the property
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> a short description of the property
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> a combination of #GParamFlags
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated #GParamSpec instance
</return>
</function>

<function name="g_io_channel_set_line_term">
<description>
This sets the string that #GIOChannel uses to determine
where in the file a line break occurs.

</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="line_term">
<parameter_description> The line termination string. Use %NULL for autodetect.
Autodetection breaks on &quot;\n&quot;, &quot;\r\n&quot;, &quot;\r&quot;, &quot;\0&quot;, and
the Unicode paragraph separator. Autodetection should
not be used for anything other than file-based channels.
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> The length of the termination string. If -1 is passed, the
string is assumed to be nul-terminated. This option allows
termination strings with embedded nuls.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_boxed_free">
<description>
Free the boxed structure @boxed which is of type @boxed_type.

</description>
<parameters>
<parameter name="boxed_type">
<parameter_description> The type of @boxed.
</parameter_description>
</parameter>
<parameter name="boxed">
<parameter_description> The boxed structure to be freed.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_sequence_get_begin_iter">
<description>
Returns the begin iterator for @seq.

Since: 2.14

</description>
<parameters>
<parameter name="seq">
<parameter_description> a #GSequence
</parameter_description>
</parameter>
</parameters>
<return> the begin iterator for @seq.

</return>
</function>

<function name="g_type_register_dynamic">
<description>
Registers @type_name as the name of a new dynamic type derived from
@parent_type.  The type system uses the information contained in the
#GTypePlugin structure pointed to by @plugin to manage the type and its
instances (if not abstract).  The value of @flags determines the nature
(e.g. abstract or not) of the type.


</description>
<parameters>
<parameter name="parent_type">
<parameter_description> Type from which this type will be derived.
</parameter_description>
</parameter>
<parameter name="type_name">
<parameter_description> 0-terminated string used as the name of the new type.
</parameter_description>
</parameter>
<parameter name="plugin">
<parameter_description> The #GTypePlugin structure to retrieve the #GTypeInfo from.
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> Bitwise combination of #GTypeFlags values.
</parameter_description>
</parameter>
</parameters>
<return> The new type identifier or #G_TYPE_INVALID if registration failed.
</return>
</function>

<function name="g_option_context_set_translate_func">
<description>
Sets the function which is used to translate the contexts 
user-visible strings, for &lt;option&gt;--help&lt;/option&gt; output. 
If @func is %NULL, strings are not translated.

Note that option groups have their own translation functions, 
this function only affects the @parameter_string (see g_option_context_new()), 
the summary (see g_option_context_set_summary()) and the description 
(see g_option_context_set_description()).

If you are using gettext(), you only need to set the translation
domain, see g_option_context_set_translation_domain().

Since: 2.12

</description>
<parameters>
<parameter name="context">
<parameter_description> a #GOptionContext
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the #GTranslateFunc, or %NULL 
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> user data to pass to @func, or %NULL
</parameter_description>
</parameter>
<parameter name="destroy_notify">
<parameter_description> a function which gets called to free @data, or %NULL
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_io_channel_get_buffer_condition">
<description>
This function returns a #GIOCondition depending on whether there
is data to be read/space to write data in the internal buffers in 
the #GIOChannel. Only the flags %G_IO_IN and %G_IO_OUT may be set.


</description>
<parameters>
<parameter name="channel">
<parameter_description> A #GIOChannel
</parameter_description>
</parameter>
</parameters>
<return> A #GIOCondition
</return>
</function>

<function name="g_variant_type_equal">
<description>
Compares @type1 and @type2 for equality.

Only returns %TRUE if the types are exactly equal.  Even if one type
is an indefinite type and the other is a subtype of it, %FALSE will
be returned if they are not exactly equal.  If you want to check for
subtypes, use g_variant_type_is_subtype_of().

The argument types of @type1 and @type2 are only #gconstpointer to
allow use with #GHashTable without function pointer casting.  For
both arguments, a valid #GVariantType must be provided.

Since 2.24

</description>
<parameters>
<parameter name="type1">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
<parameter name="type2">
<parameter_description> a #GVariantType
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if @type1 and @type2 are exactly equal
</return>
</function>

<function name="g_sequence_iter_move">
<description>
Returns the #GSequenceIter which is @delta positions away from @iter.
If @iter is closer than -@delta positions to the beginning of the sequence,
the begin iterator is returned. If @iter is closer than @delta positions
to the end of the sequence, the end iterator is returned.

Since: 2.14

</description>
<parameters>
<parameter name="iter">
<parameter_description> a #GSequenceIter
</parameter_description>
</parameter>
<parameter name="delta">
<parameter_description> A positive or negative number indicating how many positions away
from @iter the returned #GSequenceIter will be.
</parameter_description>
</parameter>
</parameters>
<return> a #GSequenceIter which is @delta positions away from @iter.

</return>
</function>

<function name="g_get_charset">
<description>
Obtains the character set for the &lt;link linkend=&quot;setlocale&quot;&gt;current 
locale&lt;/link&gt;; you might use this character set as an argument to 
g_convert(), to convert from the current locale's encoding to some 
other encoding. (Frequently g_locale_to_utf8() and g_locale_from_utf8()
are nice shortcuts, though.)

On Windows the character set returned by this function is the
so-called system default ANSI code-page. That is the character set
used by the &quot;narrow&quot; versions of C library and Win32 functions that
handle file names. It might be different from the character set
used by the C library's current locale.

The return value is %TRUE if the locale's encoding is UTF-8, in that
case you can perhaps avoid calling g_convert().

The string returned in @charset is not allocated, and should not be
freed.


</description>
<parameters>
<parameter name="charset">
<parameter_description> return location for character set name
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the returned charset is UTF-8
</return>
</function>

<function name="g_object_thaw_notify">
<description>
Reverts the effect of a previous call to
g_object_freeze_notify(). The freeze count is decreased on @object
and when it reaches zero, all queued &quot;notify&quot; signals are emitted.

It is an error to call this function when the freeze count is zero.

</description>
<parameters>
<parameter name="object">
<parameter_description> a #GObject
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_queue_is_empty">
<description>
Returns %TRUE if the queue is empty.


</description>
<parameters>
<parameter name="queue">
<parameter_description> a #GQueue.
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the queue is empty.
</return>
</function>

<function name="g_test_queue_destroy">
<description>
This function enqueus a callback @destroy_func() to be executed
during the next test case teardown phase. This is most useful
to auto destruct allocted test resources at the end of a test run.
Resources are released in reverse queue order, that means enqueueing
callback A before callback B will cause B() to be called before
A() during teardown.

Since: 2.16

</description>
<parameters>
<parameter name="destroy_func">
<parameter_description>       Destroy callback for teardown phase.
</parameter_description>
</parameter>
<parameter name="destroy_data">
<parameter_description>       Destroy callback data.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_regex_get_string_number">
<description>
Retrieves the number of the subexpression named @name.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> #GRegex structure
</parameter_description>
</parameter>
<parameter name="name">
<parameter_description> name of the subexpression
</parameter_description>
</parameter>
</parameters>
<return> The number of the subexpression or -1 if @name
does not exists

</return>
</function>

<function name="g_array_sort_with_data">
<description>
Like g_array_sort(), but the comparison function receives an extra
user data argument.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GArray.
</parameter_description>
</parameter>
<parameter name="compare_func">
<parameter_description> comparison function.
</parameter_description>
</parameter>
<parameter name="user_data">
<parameter_description> data to pass to @compare_func.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_variant_n_children">
<description>
Determines the number of children in a container #GVariant instance.
This includes variants, maybes, arrays, tuples and dictionary
entries.  It is an error to call this function on any other type of
#GVariant.

For variants, the return value is always 1.  For values with maybe
types, it is always zero or one.  For arrays, it is the length of the
array.  For tuples it is the number of tuple items (which depends
only on the type).  For dictionary entries, it is always 2

This function is O(1).

Since: 2.24

</description>
<parameters>
<parameter name="value">
<parameter_description> a container #GVariant
</parameter_description>
</parameter>
</parameters>
<return> the number of children in the container
</return>
</function>

<function name="g_unichar_istitle">
<description>
Determines if a character is titlecase. Some characters in
Unicode which are composites, such as the DZ digraph
have three case variants instead of just two. The titlecase
form is used at the beginning of a word where only the
first letter is capitalized. The titlecase form of the DZ
digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z.


</description>
<parameters>
<parameter name="c">
<parameter_description> a Unicode character
</parameter_description>
</parameter>
</parameters>
<return> %TRUE if the character is titlecase
</return>
</function>

<function name="g_io_channel_write_chars">
<description>
Replacement for g_io_channel_write() with the new API.

On seekable channels with encodings other than %NULL or UTF-8, generic
mixing of reading and writing is not allowed. A call to g_io_channel_write_chars ()
may only be made on a channel from which data has been read in the
cases described in the documentation for g_io_channel_set_encoding ().


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="buf">
<parameter_description> a buffer to write data from
</parameter_description>
</parameter>
<parameter name="count">
<parameter_description> the size of the buffer. If -1, the buffer
is taken to be a nul-terminated string.
</parameter_description>
</parameter>
<parameter name="bytes_written">
<parameter_description> The number of bytes written. This can be nonzero
even if the return value is not %G_IO_STATUS_NORMAL.
If the return value is %G_IO_STATUS_NORMAL and the
channel is blocking, this will always be equal
to @count if @count &gt;= 0.
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> a location to return an error of type #GConvertError
or #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> the status of the operation.
</return>
</function>

<function name="g_source_get_can_recurse">
<description>
Checks whether a source is allowed to be called recursively.
see g_source_set_can_recurse().


</description>
<parameters>
<parameter name="source">
<parameter_description> a #GSource
</parameter_description>
</parameter>
</parameters>
<return> whether recursion is allowed.
</return>
</function>

<function name="g_variant_builder_clear">
<description>
Releases all memory associated with a #GVariantBuilder without
freeing the #GVariantBuilder structure itself.

It typically only makes sense to do this on a stack-allocated
#GVariantBuilder if you want to abort building the value part-way
through.  This function need not be called if you call
g_variant_builder_end() and it also doesn't need to be called on
builders allocated with g_variant_builder_new (see
g_variant_builder_free() for that).

This function leaves the #GVariantBuilder structure set to all-zeros.
It is valid to call this function on either an initialised
#GVariantBuilder or one that is set to all-zeros but it is not valid
to call this function on uninitialised memory.

Since: 2.24

</description>
<parameters>
<parameter name="builder">
<parameter_description> a #GVariantBuilder
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_tree_new">
<description>
Creates a new #GTree.


</description>
<parameters>
<parameter name="key_compare_func">
<parameter_description> the function used to order the nodes in the #GTree.
It should return values similar to the standard strcmp() function -
0 if the two arguments are equal, a negative value if the first argument 
comes before the second, or a positive value if the first argument comes 
after the second.
</parameter_description>
</parameter>
</parameters>
<return> a new #GTree.
</return>
</function>

<function name="g_param_spec_object">
<description>
Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT
derived property.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="object_type">
<parameter_description> %G_TYPE_OBJECT derived type of this property
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_timeout_add">
<description>
Sets a function to be called at regular intervals, with the default
priority, #G_PRIORITY_DEFAULT.  The function is called repeatedly
until it returns %FALSE, at which point the timeout is automatically
destroyed and the function will not be called again.  The first call
to the function will be at the end of the first @interval.

Note that timeout functions may be delayed, due to the processing of other
event sources. Thus they should not be relied on for precise timing.
After each call to the timeout function, the time of the next
timeout is recalculated based on the current time and the given interval
(it does not try to 'catch up' time lost in delays).

If you want to have a timer in the &quot;seconds&quot; range and do not care
about the exact time of the first call of the timer, use the
g_timeout_add_seconds() function; this function allows for more
optimizations and more efficient system power usage.

This internally creates a main loop source using g_timeout_source_new()
and attaches it to the main loop context using g_source_attach(). You can
do these steps manually if you need greater control.


</description>
<parameters>
<parameter name="interval">
<parameter_description> the time between calls to the function, in milliseconds
(1/1000ths of a second)
</parameter_description>
</parameter>
<parameter name="function">
<parameter_description> function to call
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description>     data to pass to @function
</parameter_description>
</parameter>
</parameters>
<return> the ID (greater than 0) of the event source.
</return>
</function>

<function name="g_mapped_file_get_length">
<description>
Returns the length of the contents of a #GMappedFile.

Since: 2.8

</description>
<parameters>
<parameter name="file">
<parameter_description> a #GMappedFile
</parameter_description>
</parameter>
</parameters>
<return> the length of the contents of @file.

</return>
</function>

<function name="g_param_spec_string">
<description>
Creates a new #GParamSpecString instance.

See g_param_spec_internal() for details on property names.


</description>
<parameters>
<parameter name="name">
<parameter_description> canonical name of the property specified
</parameter_description>
</parameter>
<parameter name="nick">
<parameter_description> nick name for the property specified
</parameter_description>
</parameter>
<parameter name="blurb">
<parameter_description> description of the property specified
</parameter_description>
</parameter>
<parameter name="default_value">
<parameter_description> default value for the property specified
</parameter_description>
</parameter>
<parameter name="flags">
<parameter_description> flags for the property specified
</parameter_description>
</parameter>
</parameters>
<return> a newly created parameter specification
</return>
</function>

<function name="g_test_rand_double_range">
<description>
Get a reproducible random floating pointer number out of a specified range,
see g_test_rand_int() for details on test case random numbers.

Since: 2.16

</description>
<parameters>
<parameter name="range_start">
<parameter_description> the minimum value returned by this function
</parameter_description>
</parameter>
<parameter name="range_end">
<parameter_description> the minimum value not returned by this function
</parameter_description>
</parameter>
</parameters>
<return> a number with @range_start &lt;= number &lt; @range_end.

</return>
</function>

<function name="g_io_channel_read_unichar">
<description>
Reads a Unicode character from @channel.
This function cannot be called on a channel with %NULL encoding.


</description>
<parameters>
<parameter name="channel">
<parameter_description> a #GIOChannel
</parameter_description>
</parameter>
<parameter name="thechar">
<parameter_description> a location to return a character
</parameter_description>
</parameter>
<parameter name="error">
<parameter_description> a location to return an error of type #GConvertError
or #GIOChannelError
</parameter_description>
</parameter>
</parameters>
<return> a #GIOStatus
</return>
</function>

<function name="g_once">
<description>
The first call to this routine by a process with a given #GOnce
struct calls @func with the given argument. Thereafter, subsequent
calls to g_once()  with the same #GOnce struct do not call @func
again, but return the stored result of the first call. On return
from g_once(), the status of @once will be %G_ONCE_STATUS_READY.

For example, a mutex or a thread-specific data key must be created
exactly once. In a threaded environment, calling g_once() ensures
that the initialization is serialized across multiple threads.

&lt;note&gt;&lt;para&gt;Calling g_once() recursively on the same #GOnce struct in
@func will lead to a deadlock.&lt;/para&gt;&lt;/note&gt;

&lt;informalexample&gt;
&lt;programlisting&gt;
gpointer
get_debug_flags (void)
{
static GOnce my_once = G_ONCE_INIT;

g_once (&amp;my_once, parse_debug_flags, NULL);

return my_once.retval;
}
&lt;/programlisting&gt;
&lt;/informalexample&gt;

Since: 2.4

</description>
<parameters>
<parameter name="once">
<parameter_description> a #GOnce structure
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> the #GThreadFunc function associated to @once. This function
is called only once, regardless of the number of times it and
its associated #GOnce struct are passed to g_once().
</parameter_description>
</parameter>
<parameter name="arg">
<parameter_description> data to be passed to @func
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

<function name="g_time_val_to_iso8601">
<description>
Converts @time_ into an ISO 8601 encoded string, relative to the
Coordinated Universal Time (UTC).

Since: 2.12

</description>
<parameters>
<parameter name="time_">
<parameter_description> a #GTimeVal
</parameter_description>
</parameter>
</parameters>
<return> a newly allocated string containing an ISO 8601 date

</return>
</function>

<function name="g_regex_match_all">
<description>
Using the standard algorithm for regular expression matching only
the longest match in the string is retrieved. This function uses
a different algorithm so it can retrieve all the possible matches.
For more documentation see g_regex_match_all_full().

A #GMatchInfo structure, used to get information on the match, is
stored in @match_info if not %NULL. Note that if @match_info is
not %NULL then it is created even if the function returns %FALSE,
i.e. you must free it regardless if regular expression actually
matched.

@string is not copied and is used in #GMatchInfo internally. If
you use any #GMatchInfo method (except g_match_info_free()) after
freeing or modifying @string then the behaviour is undefined.

Since: 2.14

</description>
<parameters>
<parameter name="regex">
<parameter_description> a #GRegex structure from g_regex_new()
</parameter_description>
</parameter>
<parameter name="string">
<parameter_description> the string to scan for matches
</parameter_description>
</parameter>
<parameter name="match_options">
<parameter_description> match options
</parameter_description>
</parameter>
<parameter name="match_info">
<parameter_description> pointer to location where to store
the #GMatchInfo, or %NULL if you do not need it
</parameter_description>
</parameter>
</parameters>
<return> %TRUE is the string matched, %FALSE otherwise

</return>
</function>

<function name="g_signal_handlers_block_matched">
<description>
Blocks all handlers on an instance that match a certain selection criteria.
The criteria mask is passed as an OR-ed combination of #GSignalMatchType
flags, and the criteria values are passed as arguments.
Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC
or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
If no handlers were found, 0 is returned, the number of blocked handlers
otherwise.


</description>
<parameters>
<parameter name="instance">
<parameter_description> The instance to block handlers from.
</parameter_description>
</parameter>
<parameter name="mask">
<parameter_description> Mask indicating which of @signal_id, @detail, @closure, @func
and/or @data the handlers have to match.
</parameter_description>
</parameter>
<parameter name="signal_id">
<parameter_description> Signal the handlers have to be connected to.
</parameter_description>
</parameter>
<parameter name="detail">
<parameter_description> Signal detail the handlers have to be connected to.
</parameter_description>
</parameter>
<parameter name="closure">
<parameter_description> The closure the handlers will invoke.
</parameter_description>
</parameter>
<parameter name="func">
<parameter_description> The C closure callback of the handlers (useless for non-C closures).
</parameter_description>
</parameter>
<parameter name="data">
<parameter_description> The closure data of the handlers' closures.
</parameter_description>
</parameter>
</parameters>
<return> The number of handlers that matched.
</return>
</function>

<function name="g_ptr_array_set_size">
<description>
Sets the size of the array. When making the array larger,
newly-added elements will be set to %NULL. When making it smaller,
if @array has a non-%NULL #GDestroyNotify function then it will be
called for the removed elements.

</description>
<parameters>
<parameter name="array">
<parameter_description> a #GPtrArray.
</parameter_description>
</parameter>
<parameter name="length">
<parameter_description> the new length of the pointer array.
</parameter_description>
</parameter>
</parameters>
<return></return>
</function>

</root>
