85a86
> Since: 2.8
100d100
< Since: 2.8
106c106,107
< Return value: the number of threads currently running
---
> Returns the number of threads currently running in @pool.
> 
119,149d119
< <function name="GCompletionStrncmpFunc">
< <description>
< Specifies the type of the function passed to
< g_completion_set_compare(). This is used when you use strings as
< #GCompletion items.
< 
< </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> maximal number of bytes to compare.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> an integer less than, equal to, or greater than zero if
< the first @n bytes of @s1 is found, respectively, to be
< less than, to match, or to be greater than the first @n
< bytes of @s2.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
157a128
> Since: 2.12
181d151
< Since: 2.12
206d175
< and this is a test.
212c181,184
< Returns: a canonical representation for the string
---
> Returns a canonical representation for @string. Interned strings can
> be compared for equality by comparing the pointers, instead of using strcmp().
> 
> Since: 2.10
223d194
< Since: 2.10
380,384d350
< <parameter name="Returns">
< <parameter_description> a pointer to the allocated atom, cast to a pointer to
< @type.
< </parameter_description>
< </parameter>
386c352,354
< <return></return>
---
> <return> a pointer to the allocated atom, cast to a pointer to
> @type.
> </return>
495a464,469
> 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
505,510d478
< 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
571c539,543
< Returns: the string searched with @match_info
---
> 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
582d553
< Since: 2.14
588c559,564
< Return value: A negative number if @a comes before @b, 0 if they are
---
> 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
604d579
< Since: 2.14
672a648
> Since: 2.4
687d662
< Since: 2.4
739c714,716
< Return value: A random number.
---
> Returns the next random #gdouble from @rand_ equally distributed over
> the range [0..1).
> 
836a814
> Since: 2.22
847d824
< Since: 2.22
858a836
> Since: 2.12
882d859
< Since: 2.12
888c865,867
< Return value: the main group of @context, or %NULL if @context doesn't
---
> Returns a pointer to the main group of @context.
> 
> Since: 2.6
901d879
< Since: 2.6
904a883,924
> <function name="implemented">
> <description>
> it is possible to maintain a sorted list of n elements in time O(n
> log n). The data contained in each element can be either integer
> values, by using of the &lt;link
> linkend=&quot;glib-Type-Conversion-Macros&quot;&gt;Type Conversion Macros&lt;/link&gt;,
> or simply pointers to any type of data.
> 
> A #GSequence is accessed through &lt;firstterm&gt;iterators&lt;/firstterm&gt;,
> represented by a #GSequenceIter. An iterator represents a position
> between two elements of the sequence. For example, the
> &lt;firstterm&gt;begin&lt;/firstterm&gt; iterator represents the gap immediately
> before the first element of the sequence, and the
> &lt;firstterm&gt;end&lt;/firstterm&gt; iterator represents the gap immediately
> after the last element. In an empty sequence, the begin and end
> iterators are the same.
> 
> Some methods on #GSequence operate on ranges of items. For example
> g_sequence_foreach_range() will call a user-specified function on
> each element with the given range. The range is delimited by the
> gaps represented by the passed-in iterators, so if you pass in the
> begin and end iterators, the range in question is the entire
> sequence.
> 
> The function g_sequence_get() is used with an iterator to access the
> element immediately following the gap that the iterator represents.
> The iterator is said to &lt;firstterm&gt;point&lt;/firstterm&gt; to that element.
> 
> Iterators are stable across most operations on a #GSequence. For
> example an iterator pointing to some element of a sequence will
> continue to point to that element even after the sequence is sorted.
> Even moving an element to another sequence using for example
> g_sequence_move_range() will not invalidate the iterators pointing
> to it. The only operation that will invalidate an iterator is when
> the element it points to is removed from any sequence.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
938a959
> Since: 2.12
962d982
< Since: 2.12
1002c1022,1024
< Return value: The start group of the key file.
---
> Returns the name of the start group of the file. 
> 
> Since: 2.6
1013d1034
< Since: 2.6
1024a1046
> Since: 2.10
1032d1053
< Since: 2.10
1116c1137,1144
< Return value: a string owned by GLib that must not be modified 
---
> 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;
> 
> Since: 2.6
1123d1150
< Since: 2.6
1159a1187
> Since: 2.18
1175d1202
< Since: 2.18
1213,1241d1239
< <function name="GTraverseFunc">
< <description>
< Specifies the type of function passed to g_tree_traverse(). It is
< passed the key and value of each node, together with the @user_data
< parameter passed to g_tree_traverse(). If the function returns
< %TRUE, the traversal is stopped.
< 
< </description>
< <parameters>
< <parameter name="key">
< <parameter_description> a key of a #GTree node.
< </parameter_description>
< </parameter>
< <parameter name="value">
< <parameter_description> the value corresponding to the key.
< </parameter_description>
< </parameter>
< <parameter name="data">
< <parameter_description> user data passed to g_tree_traverse().
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> %TRUE to stop the traversal.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
1246a1245
> Since: 2.10
1257d1255
< Since: 2.10
1297,1326d1294
< <function name="GHashFunc">
< <description>
< Specifies the type of the hash function which is passed to
< g_hash_table_new() when a #GHashTable is created.
< 
< The function is passed a key and should return a #guint hash value.
< The functions g_direct_hash(), g_int_hash() and g_str_hash() provide
< hash functions which can be used when the key is a #gpointer, #gint,
< and #gchar* respectively.
< 
< &lt;!-- FIXME: Need more here. --&gt; The hash values should be evenly
< distributed over a fairly large range? The modulus is taken with the
< hash table size (a prime number) to find the 'bucket' to place each
< key into. The function should also be very fast, since it is called
< for each key lookup.
< 
< </description>
< <parameters>
< <parameter name="key">
< <parameter_description> a key.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> the hash value corresponding to the key.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
1330a1299,1301
> 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.
1341,1343d1311
< 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.
1354a1323
> Since: 2.4
1374d1342
< Since: 2.4
1528,1549d1495
< <function name="GSList">
< <description>
< The #GSList struct is used for each element in the singly-linked
< list.
< 
< </description>
< <parameters>
< <parameter name="data">
< <parameter_description> holds the element's data, which can be a pointer to any kind
< of data, or any integer value using the &lt;link
< linkend=&quot;glib-Type-Conversion-Macros&quot;&gt;Type Conversion
< Macros&lt;/link&gt;.
< </parameter_description>
< </parameter>
< <parameter name="next">
< <parameter_description> contains the link to the next element in the list.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
1588,1591d1533
< <parameter name="Returns">
< <parameter_description> the data previously stored at @key_id, or %NULL if none.
< </parameter_description>
< </parameter>
1593c1535,1536
< <return></return>
---
> <return> the data previously stored at @key_id, or %NULL if none.
> </return>
1600a1544
> Since: 2.12
1617d1560
< Since: 2.12
1621,1656d1563
< <function name="GTraverseType">
< <description>
< Specifies the type of traveral performed by g_tree_traverse(),
< g_node_traverse() and g_node_find().
< 
< </description>
< <parameters>
< <parameter name="G_IN_ORDER">
< <parameter_description> vists a node's left child first, then the node itself,
< then its right child. This is the one to use if you
< want the output sorted according to the compare
< function.
< </parameter_description>
< </parameter>
< <parameter name="G_PRE_ORDER">
< <parameter_description> visits a node, then its children.
< </parameter_description>
< </parameter>
< <parameter name="G_POST_ORDER">
< <parameter_description> visits the node's children, then the node itself.
< </parameter_description>
< </parameter>
< <parameter name="G_LEVEL_ORDER">
< <parameter_description> is not implemented for &lt;link
< linkend=&quot;glib-Balanced-Binary-Trees&quot;&gt;Balanced Binary
< Trees&lt;/link&gt;.  For &lt;link
< linkend=&quot;glib-N-ary-Trees&quot;&gt;N-ary Trees&lt;/link&gt;, it
< vists the root node first, then its children, then
< its grandchildren, and so on. Note that this is less
< efficient than the other orders.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
1744a1652,1665
> <function name="is">
> <description>
> A #GOnce struct controls a one-time initialization function. Any
> one-time initialization function must have its own unique #GOnce
> struct.
> 
> Since: 2.4
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
1753a1675
> Since: 2.14
1768d1689
< Since: 2.14
1824a1746
> Since: 2.4
1840d1761
< Since: 2.4
1856,1859d1776
< <parameter name="Returns">
< <parameter_description> the corresponding pointer.
< </parameter_description>
< </parameter>
1861c1778,1779
< <return></return>
---
> <return> the corresponding pointer.
> </return>
1907,1918d1824
< <function name="GPatternSpec">
< <description>
< A &lt;structname&gt;GPatternSpec&lt;/structname&gt; is the 'compiled' form of a
< pattern. This structure is opaque and its fields cannot be accessed
< directly.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
1948a1855
> Since: 2.8
1963d1869
< Since: 2.8
2027a1934
> Since: 2.2
2034d1940
< Since: 2.2
2040c1946,1948
< Return value: the length of @seq
---
> Returns the length of @seq
> 
> Since: 2.14
2051d1958
< Since: 2.14
2079a1987
> Since: 2.16
2086d1993
< Since: 2.16
2119a2027
> Since: 2.4
2135d2042
< Since: 2.4
2291c2198,2199
< Returns: the data of the first element in the queue, or %NULL if the queue
---
> Returns the first element of the queue.
> 
2307c2215,2244
< Return value: a %NULL-terminated array of strings owned by GLib that must 
---
> 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;
> 
> 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
2314d2250
< Since: 2.6
2338,2373d2273
< <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>
< 
2406a2307
> Since: 2.14
2417d2317
< Since: 2.14
2537a2438
> Since: 2.12
2568d2468
< Since: 2.12
2622a2523
> Since: 2.22
2633d2533
< Since: 2.22
2661,2696d2560
< <function name="GIOCondition">
< <description>
< A bitwise combination representing a condition to watch for on an
< event source.
< 
< </description>
< <parameters>
< <parameter name="G_IO_IN">
< <parameter_description> There is data to read.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_OUT">
< <parameter_description> Data can be written (without blocking).
< </parameter_description>
< </parameter>
< <parameter name="G_IO_PRI">
< <parameter_description> There is urgent data to read.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_ERR">
< <parameter_description> Error condition.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_HUP">
< <parameter_description> Hung up (the connection has been broken, usually for
< pipes and sockets).
< </parameter_description>
< </parameter>
< <parameter name="G_IO_NVAL">
< <parameter_description> Invalid request. The file descriptor is not open.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
2811c2675,2684
< Return value: a newly allocated string or %NULL if the specified 
---
> 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
2839d2711
< Since: 2.6
2921a2794
> Since: 2.12
2940d2812
< Since: 2.12
2953a2826
> Since: 2.4
2976d2848
< Since: 2.4
3035a2908,2935
> <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>
> 
3039a2940
> Since: 2.2
3054d2954
< Since: 2.2
3095c2995,2997
< Return value: whether @iter is the begin iterator
---
> Returns whether @iter is the begin iterator
> 
> Since: 2.14
3106d3007
< Since: 2.14
3141a3043,3065
> <function name="then">
> <description>
> want the output sorted according to the compare
> function.
> @G_PRE_ORDER: visits a node, then its children.
> @G_POST_ORDER: visits the node's children, then the node itself.
> @G_LEVEL_ORDER: is not implemented for &lt;link
> linkend=&quot;glib-Balanced-Binary-Trees&quot;&gt;Balanced Binary
> Trees&lt;/link&gt;.  For &lt;link
> linkend=&quot;glib-N-ary-Trees&quot;&gt;N-ary Trees&lt;/link&gt;, it
> vists the root node first, then its children, then
> its grandchildren, and so on. Note that this is less
> efficient than the other orders.
> 
> Specifies the type of traveral performed by g_tree_traverse(),
> g_node_traverse() and g_node_find().
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
3182,3185d3105
< <parameter name="Returns">
< <parameter_description> %TRUE if @string matches @pspec
< </parameter_description>
< </parameter>
3187c3107,3108
< <return></return>
---
> <return> %TRUE if @string matches @pspec
> </return>
3248c3169,3170
< Returns: the first #GFlagsValue which is set in @value, or %NULL if
---
> Returns the first #GFlagsValue which is set in @value.
> 
3302,3305d3223
< <parameter name="Returns">
< <parameter_description> the number of records deleted.
< </parameter_description>
< </parameter>
3307c3225,3226
< <return></return>
---
> <return> the number of records deleted.
> </return>
3313a3233
> Deprecated:2.2: Use g_io_channel_write_chars() instead.
3336d3255
< Deprecated:2.2: Use g_io_channel_write_chars() instead.
3347a3267
> Since: 2.6
3374d3293
< Since: 2.6
3436a3356
> Since: 2.2
3456d3375
< Since: 2.2
3564c3483,3485
< Return value: the first link in @queue, or %NULL if @queue is empty
---
> Returns the first link in @queue
> 
> Since: 2.4
3575d3495
< Since: 2.4
3587,3590d3506
< <parameter name="Returns">
< <parameter_description> a pointer to the newly-allocated #GList element.
< </parameter_description>
< </parameter>
3592c3508,3509
< <return></return>
---
> <return> a pointer to the newly-allocated #GList element.
> </return>
3687,3690d3603
< <parameter name="Returns">
< <parameter_description> a new #GCond.
< </parameter_description>
< </parameter>
3692c3605,3606
< <return></return>
---
> <return> a new #GCond.
> </return>
3718,3721d3631
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
3723c3633,3634
< <return></return>
---
> <return> the #GArray.
> </return>
3728c3639,3646
< Return value: a newly allocated string or %NULL if the specified
---
> 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
3748d3665
< Since: 2.12
3768a3686,3705
> <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>
> 
3787c3724
< <function name="GStaticRWLock">
---
> <function name="g_thread_pool_stop_unused_threads">
3789,3866c3726,3728
< The #GStaticRWLock struct represents a read-write lock. A read-write
< lock can be used for protecting data that some portions of code only
< read from, while others also write. In such situations it is
< desirable that several readers can read at once, whereas of course
< only one writer may write at a time. Take a look at the following
< example:
< 
< &lt;example&gt;
< &lt;title&gt;An array with access functions&lt;/title&gt;
< &lt;programlisting&gt;
< GStaticRWLock rwlock = G_STATIC_RW_LOCK_INIT;
< GPtrArray *array;
< 
< gpointer
< my_array_get (guint index)
< {
< gpointer retval = NULL;
< 
< if (!array)
< return NULL;
< 
< g_static_rw_lock_reader_lock (&amp;rwlock);
< if (index &lt; array-&gt;len)
< retval = g_ptr_array_index (array, index);
< g_static_rw_lock_reader_unlock (&amp;rwlock);
< 
< return retval;
< }
< 
< void
< my_array_set (guint index, gpointer data)
< {
< g_static_rw_lock_writer_lock (&amp;rwlock);
< 
< if (!array)
< array = g_ptr_array_new (&lt;!-- --&gt;);
< 
< if (index &gt;= array-&gt;len)
< g_ptr_array_set_size (array, index+1);
< g_ptr_array_index (array, index) = data;
< 
< g_static_rw_lock_writer_unlock (&amp;rwlock);
< }
< &lt;/programlisting&gt;
< &lt;/example&gt;
< 
< This example shows an array which can be accessed by many readers
< (the &lt;function&gt;my_array_get()&lt;/function&gt; function) simultaneously,
< whereas the writers (the &lt;function&gt;my_array_set()&lt;/function&gt;
< function) will only be allowed once at a time and only if no readers
< currently access the array. This is because of the potentially
< dangerous resizing of the array. Using these functions is fully
< multi-thread safe now.
< 
< Most of the time, writers should have precedence over readers. That
< means, for this implementation, that as soon as a writer wants to
< lock the data, no other reader is allowed to lock the data, whereas,
< of course, the readers that already have locked the data are allowed
< to finish their operation. As soon as the last reader unlocks the
< data, the writer will lock it.
< 
< Even though #GStaticRWLock is not opaque, it should only be used
< with the following functions.
< 
< All of the &lt;function&gt;g_static_rw_lock_*&lt;/function&gt; functions can be
< used even if g_thread_init() has not been called. Then they do
< nothing, apart from &lt;function&gt;g_static_rw_lock_*_trylock&lt;/function&gt;,
< which does nothing but returning %TRUE.
< 
< &lt;note&gt;&lt;para&gt;A read-write lock has a higher overhead than a mutex. For
< example, both g_static_rw_lock_reader_lock() and
< g_static_rw_lock_reader_unlock() have to lock and unlock a
< #GStaticMutex, so it takes at least twice the time to lock and unlock
< a #GStaticRWLock that it does to lock and unlock a #GStaticMutex. So
< only data structures that are accessed by multiple readers, and which
< keep the lock for a considerable time justify a #GStaticRWLock. The
< above example most probably would fare better with a
< #GStaticMutex.&lt;/para&gt;&lt;/note&gt;
---
> 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().
3975a3838
> Since: 2.14
4010d3872
< Since: 2.14
4084c3946,3949
< Returns: the transation of @str to the current locale
---
> 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).
> 
4098a3964,3969
> 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
4108,4113d3978
< 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
4161c4026
< <function name="SECTION">
---
> <function name="g_mkstemp">
4163,4182c4028,4038
< The basic concept of the signal system is that of the
< &lt;emphasis&gt;emission&lt;/emphasis&gt; of a signal. Signals are introduced
< per-type and are identified through strings.  Signals introduced
< for a parent type are available in derived types as well, so
< basically they are a per-type facility that is inherited.  A signal
< emission mainly involves invocation of a certain set of callbacks
< in precisely defined manner. There are two main categories of such
< callbacks, per-object 
< &lt;footnote&gt;&lt;para&gt;Although signals can deal with any kind of instantiatable 
< type, i'm referring to those types as &quot;object types&quot; in the following, 
< simply because that is the context most users will encounter signals in.
< &lt;/para&gt;&lt;/footnote&gt;
< ones and user provided ones.
< The per-object callbacks are most often referred to as &quot;object method
< handler&quot; or &quot;default (signal) handler&quot;, while user provided callbacks are
< usually just called &quot;signal handler&quot;.
< The object method handler is provided at signal creation time (this most
< frequently happens at the end of an object class' creation), while user
< provided handlers are frequently connected and disconnected to/from a certain
< signal on certain object instances.
---
> 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.
4184,4218d4039
< A signal emission consists of five stages, unless prematurely stopped:
< &lt;variablelist&gt;
< &lt;varlistentry&gt;&lt;term&gt;&lt;/term&gt;&lt;listitem&gt;&lt;para&gt;
< 1 - Invocation of the object method handler for %G_SIGNAL_RUN_FIRST signals
< &lt;/para&gt;&lt;/listitem&gt;&lt;/varlistentry&gt;
< &lt;varlistentry&gt;&lt;term&gt;&lt;/term&gt;&lt;listitem&gt;&lt;para&gt;
< 2 - Invocation of normal user-provided signal handlers (&lt;emphasis&gt;after&lt;/emphasis&gt; flag %FALSE)
< &lt;/para&gt;&lt;/listitem&gt;&lt;/varlistentry&gt;
< &lt;varlistentry&gt;&lt;term&gt;&lt;/term&gt;&lt;listitem&gt;&lt;para&gt;
< 3 - Invocation of the object method handler for %G_SIGNAL_RUN_LAST signals
< &lt;/para&gt;&lt;/listitem&gt;&lt;/varlistentry&gt;
< &lt;varlistentry&gt;&lt;term&gt;&lt;/term&gt;&lt;listitem&gt;&lt;para&gt;
< 4 - Invocation of user provided signal handlers, connected with an &lt;emphasis&gt;after&lt;/emphasis&gt; flag of %TRUE
< &lt;/para&gt;&lt;/listitem&gt;&lt;/varlistentry&gt;
< &lt;varlistentry&gt;&lt;term&gt;&lt;/term&gt;&lt;listitem&gt;&lt;para&gt;
< 5 - Invocation of the object method handler for %G_SIGNAL_RUN_CLEANUP signals
< &lt;/para&gt;&lt;/listitem&gt;&lt;/varlistentry&gt;
< &lt;/variablelist&gt;
< The user-provided signal handlers are called in the order they were
< connected in.
< All handlers may prematurely stop a signal emission, and any number of
< handlers may be connected, disconnected, blocked or unblocked during
< a signal emission.
< There are certain criteria for skipping user handlers in stages 2 and 4
< of a signal emission.
< First, user handlers may be &lt;emphasis&gt;blocked&lt;/emphasis&gt;, blocked handlers are omitted
< during callback invocation, to return from the &quot;blocked&quot; state, a
< handler has to get unblocked exactly the same amount of times
< it has been blocked before.
< Second, upon emission of a %G_SIGNAL_DETAILED signal, an additional
< &quot;detail&quot; argument passed in to g_signal_emit() has to match the detail
< argument of the signal handler currently subject to invocation.
< Specification of no detail argument for signal handlers (omission of the
< detail part of the signal specification upon connection) serves as a
< wildcard and matches any detail argument passed in to emission.
4222,4228c4043,4044
< <parameter name="short_description">
< <parameter_description> A means for customization of object behaviour
< and a general purpose notification mechanism
< </parameter_description>
< </parameter>
< <parameter name="title">
< <parameter_description> Signals
---
> <parameter name="tmpl">
> <parameter_description> template filename
4232c4048,4052
< <return></return>
---
> <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>
4291a4112,4137
> <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>
> 
4396c4242,4244
< Return value: The position of @link_, or -1 if the link is
---
> Returns the position of @link_ in @queue.
> 
> Since: 2.4
4412d4259
< Since: 2.4
4463c4310
< <function name="G_THREADS_ENABLED">
---
> <function name="g_test_rand_double">
4465,4470c4312,4315
< This macro is defined if GLib was compiled with thread support. This
< does not necessarily mean that there is a thread implementation
< available, but it does mean that the infrastructure is in place and
< that once you provide a thread implementation to g_thread_init(),
< GLib will be multi-thread safe. If #G_THREADS_ENABLED is not
< defined, then Glib is not, and cannot be, multi-thread safe.
---
> Get a reproducible random floating point number,
> see g_test_rand_int() for details on test case random numbers.
> 
> Since: 2.16
4475c4320,4322
< <return></return>
---
> <return> a random number from the seeded random number generator.
> 
> </return>
4484a4332
> Since: 2.22
4499d4346
< Since: 2.22
4538,4541d4384
< <parameter name="Returns">
< <parameter_description> the #GByteArray.
< </parameter_description>
< </parameter>
4543c4386,4387
< <return></return>
---
> <return> the #GByteArray.
> </return>
4643a4488
> Since: 2.8
4650d4494
< Since: 2.8
4654c4498
< <function name="g_thread_foreach">
---
> <function name="g_date_set_time_t">
4656,4661c4500,4502
< 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.
---
> 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.
4663,4664c4504,4507
< Due to thread lifetime checks, this function has an execution complexity
< which is quadratic in the number of existing threads.
---
> To set the value of a date to the current day, you could write:
> |[
> g_date_set_time_t (date, time (NULL)); 
> ]|
4670,4671c4513,4514
< <parameter name="thread_func">
< <parameter_description> function to call for all GThread structures
---
> <parameter name="date">
> <parameter_description> a #GDate 
4674,4675c4517,4518
< <parameter name="user_data">
< <parameter_description>   second argument to @thread_func
---
> <parameter name="timet">
> <parameter_description> &lt;type&gt;time_t&lt;/type&gt; value to set
4691a4535
> Since: 2.22
4702d4545
< Since: 2.22
4751c4594
< <function name="GThreadFunctions">
---
> <function name="target">
4753,4760c4596
< This function table is used by g_thread_init() to initialize the
< thread system. The functions in the table are directly used by their
< g_* prepended counterparts (described in this document).  For
< example, if you call g_mutex_new() then mutex_new() from the table
< provided to g_thread_init() will be called.
< 
< &lt;note&gt;&lt;para&gt;Do not use this struct unless you know what you are
< doing.&lt;/para&gt;&lt;/note&gt;
---
> The data structure used for automatic completion.
4764,4838c4600,4602
< <parameter name="mutex_new">
< <parameter_description> virtual function pointer for g_mutex_new()
< </parameter_description>
< </parameter>
< <parameter name="mutex_lock">
< <parameter_description> virtual function pointer for g_mutex_lock()
< </parameter_description>
< </parameter>
< <parameter name="mutex_trylock">
< <parameter_description> virtual function pointer for g_mutex_trylock()
< </parameter_description>
< </parameter>
< <parameter name="mutex_unlock">
< <parameter_description> virtual function pointer for g_mutex_unlock()
< </parameter_description>
< </parameter>
< <parameter name="mutex_free">
< <parameter_description> virtual function pointer for g_mutex_free()
< </parameter_description>
< </parameter>
< <parameter name="cond_new">
< <parameter_description> virtual function pointer for g_cond_new()
< </parameter_description>
< </parameter>
< <parameter name="cond_signal">
< <parameter_description> virtual function pointer for g_cond_signal()
< </parameter_description>
< </parameter>
< <parameter name="cond_broadcast">
< <parameter_description> virtual function pointer for g_cond_broadcast()
< </parameter_description>
< </parameter>
< <parameter name="cond_wait">
< <parameter_description> virtual function pointer for g_cond_wait()
< </parameter_description>
< </parameter>
< <parameter name="cond_timed_wait">
< <parameter_description> virtual function pointer for g_cond_timed_wait()
< </parameter_description>
< </parameter>
< <parameter name="cond_free">
< <parameter_description> virtual function pointer for g_cond_free()
< </parameter_description>
< </parameter>
< <parameter name="private_new">
< <parameter_description> virtual function pointer for g_private_new()
< </parameter_description>
< </parameter>
< <parameter name="private_get">
< <parameter_description> virtual function pointer for g_private_get()
< </parameter_description>
< </parameter>
< <parameter name="private_set">
< <parameter_description> virtual function pointer for g_private_set()
< </parameter_description>
< </parameter>
< <parameter name="thread_create">
< <parameter_description> virtual function pointer for g_thread_create()
< </parameter_description>
< </parameter>
< <parameter name="thread_yield">
< <parameter_description> virtual function pointer for g_thread_yield()
< </parameter_description>
< </parameter>
< <parameter name="thread_join">
< <parameter_description> virtual function pointer for g_thread_join()
< </parameter_description>
< </parameter>
< <parameter name="thread_exit">
< <parameter_description> virtual function pointer for g_thread_exit()
< </parameter_description>
< </parameter>
< <parameter name="thread_set_priority">
< <parameter_description> virtual function pointer for
< g_thread_set_priority()
---
> <parameter name="prefix">
> <parameter_description> the last prefix passed to g_completion_complete() or
> g_completion_complete_utf8().
4841,4842c4605,4606
< <parameter name="thread_self">
< <parameter_description> virtual function pointer for g_thread_self()
---
> <parameter name="cache">
> <parameter_description> the list of items which begin with @prefix.
4845,4847c4609,4611
< <parameter name="thread_equal">
< <parameter_description> used internally by recursive mutex locks and by some
< assertion checks
---
> <parameter name="strncmp_func">
> <parameter_description> The function to use when comparing strings.  Use
> g_completion_set_compare() to modify this function.
4864,4867d4627
< <parameter name="Returns">
< <parameter_description> the next element, or %NULL if there are no more elements.
< </parameter_description>
< </parameter>
4869c4629,4630
< <return></return>
---
> <return> the next element, or %NULL if there are no more elements.
> </return>
4964c4725,4734
< Return value: a newly allocated string or %NULL if the specified 
---
> 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
4988d4757
< Since: 2.6
5051a4821
> Since: 2.14
5087d4856
< Since: 2.14
5273,5335d5041
< <function name="GIOFuncs">
< <description>
< A table of functions used to handle different types of #GIOChannel
< in a generic way.
< 
< </description>
< <parameters>
< <parameter name="io_read">
< <parameter_description> reads raw bytes from the channel.  This is called from
< various functions such as g_io_channel_read_chars() to
< read raw bytes from the channel.  Encoding and buffering
< issues are dealt with at a higher level.
< </parameter_description>
< </parameter>
< <parameter name="io_write">
< <parameter_description> writes raw bytes to the channel.  This is called from
< various functions such as g_io_channel_write_chars() to
< write raw bytes to the channel.  Encoding and buffering
< issues are dealt with at a higher level.
< </parameter_description>
< </parameter>
< <parameter name="io_seek">
< <parameter_description> (optional) seeks the channel.  This is called from
< g_io_channel_seek() on channels that support it.
< </parameter_description>
< </parameter>
< <parameter name="io_close">
< <parameter_description> closes the channel.  This is called from
< g_io_channel_close() after flushing the buffers.
< </parameter_description>
< </parameter>
< <parameter name="io_create_watch">
< <parameter_description> creates a watch on the channel.  This call
< corresponds directly to g_io_create_watch().
< </parameter_description>
< </parameter>
< <parameter name="io_free">
< <parameter_description> called from g_io_channel_unref() when the channel needs to
< be freed.  This function must free the memory associated
< with the channel, including freeing the #GIOChannel
< structure itself.  The channel buffers have been flushed
< and possibly @io_close has been called by the time this
< function is called.
< </parameter_description>
< </parameter>
< <parameter name="io_set_flags">
< <parameter_description> sets the #GIOFlags on the channel.  This is called
< from g_io_channel_set_flags() with all flags except
< for %G_IO_FLAG_APPEND and %G_IO_FLAG_NONBLOCK masked
< out.
< </parameter_description>
< </parameter>
< <parameter name="io_get_flags">
< <parameter_description> gets the #GIOFlags for the channel.  This function
< need only return the %G_IO_FLAG_APPEND and
< %G_IO_FLAG_NONBLOCK flags; g_io_channel_get_flags()
< automatically adds the others as appropriate.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
5437,5441d5142
< <parameter name="Returns">
< <parameter_description> %TRUE if the initialization section should be entered,
< %FALSE and blocks otherwise
< </parameter_description>
< </parameter>
5443c5144,5146
< <return></return>
---
> <return> %TRUE if the initialization section should be entered,
> %FALSE and blocks otherwise
> </return>
5630a5334
> Since: 2.6
5641d5344
< Since: 2.6
5647c5350,5352
< Return value: the last link in @queue, or %NULL if @queue is empty
---
> Returns the last link @queue.
> 
> Since: 2.4
5658d5362
< Since: 2.4
5712,5735d5415
< <function name="GSequenceIter">
< <description>
< The #GSequenceIter struct is an opaque data type representing an
< iterator pointing into a #GSequence.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
< <function name="GHashTableIter">
< <description>
< A GHashTableIter structure represents an iterator that can be used
< to iterate over the elements of a #GHashTable. GHashTableIter
< structures are typically allocated on the stack and then initialized
< with g_hash_table_iter_init().
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
5754,5812d5433
< <function name="GStaticMutex">
< <description>
< A #GStaticMutex works like a #GMutex, but it has one significant
< advantage. It doesn't need to be created at run-time like a #GMutex,
< but can be defined at compile-time. Here is a shorter, easier and
< safer version of our &lt;function&gt;give_me_next_number()&lt;/function&gt;
< example:
< 
< &lt;example&gt;
< &lt;title&gt;
< Using &lt;structname&gt;GStaticMutex&lt;/structname&gt;
< to simplify thread-safe programming
< &lt;/title&gt;
< &lt;programlisting&gt;
< int
< give_me_next_number (void)
< {
< static int current_number = 0;
< int ret_val;
< static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
< 
< g_static_mutex_lock (&amp;mutex);
< ret_val = current_number = calc_next_number (current_number);
< g_static_mutex_unlock (&amp;mutex);
< 
< return ret_val;
< }
< &lt;/programlisting&gt;
< &lt;/example&gt;
< 
< Sometimes you would like to dynamically create a mutex. If you don't
< want to require prior calling to g_thread_init(), because your code
< should also be usable in non-threaded programs, you are not able to
< use g_mutex_new() and thus #GMutex, as that requires a prior call to
< g_thread_init(). In theses cases you can also use a #GStaticMutex.
< It must be initialized with g_static_mutex_init() before using it
< and freed with with g_static_mutex_free() when not needed anymore to
< free up any allocated resources.
< 
< Even though #GStaticMutex is not opaque, it should only be used with
< the following functions, as it is defined differently on different
< platforms.
< 
< All of the &lt;function&gt;g_static_mutex_*&lt;/function&gt; functions apart
< from &lt;function&gt;g_static_mutex_get_mutex&lt;/function&gt; can also be used
< even if g_thread_init() has not yet been called. Then they do
< nothing, apart from &lt;function&gt;g_static_mutex_trylock&lt;/function&gt;,
< which does nothing but returning %TRUE.
< 
< &lt;note&gt;&lt;para&gt;All of the &lt;function&gt;g_static_mutex_*&lt;/function&gt;
< functions are actually macros. Apart from taking their addresses, you
< can however use them as if they were functions.&lt;/para&gt;&lt;/note&gt;
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
5865c5486,5490
< Return value: the ID (greater than 0) for the source
---
> 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().
> 
5896,5931d5520
< <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>
< 
5937a5527
> Since: 2.12
5960d5549
< Since: 2.12
5983,5997d5571
< <function name="GThread">
< <description>
< The #GThread struct represents a running thread. It has three public
< read-only members, but the underlying struct is bigger, so you must
< not copy this struct.
< 
< &lt;note&gt;&lt;para&gt;Resources for a joinable thread are not fully released
< until g_thread_join() is called for that thread.&lt;/para&gt;&lt;/note&gt;
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
6000c5574,5580
< Return value: the value of the environment variable, or %NULL if
---
> 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.
> 
6016c5596
< <function name="GSequence">
---
> <function name="g_signal_chain_from_overridden_handler">
6018,6019c5598,5603
< The #GSequence struct is an opaque data type representing a
< &lt;link linkend=&quot;glib-Sequences&quot;&gt;Sequence&lt;/link&gt; data type.
---
> 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
6022a5607,5616
> <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>
6143a5738
> Since: 2.16
6163d5757
< Since: 2.16
6210a5805
> Since: 2.16
6229d5823
< Since: 2.16
6357a5952
> Deprecated:2.2: Use g_io_channel_read_chars() instead.
6381d5975
< Deprecated:2.2: Use g_io_channel_read_chars() instead.
6386a5981,5992
> 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;
6402,6405d6007
< <parameter name="Returns">
< <parameter_description> the element of the #GArray at the index given by @i.
< </parameter_description>
< </parameter>
6407,6418c6009
< <return>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;
---
> <return> the element of the #GArray at the index given by @i.
6448a6040
> Since: 2.16
6461d6052
< Since: 2.16
6480a6072
> Since: 2.16
6492d6083
< Since: 2.16
6652a6244
> Since: 2.18
6676d6267
< Since: 2.18
6681a6273,6274
> Returns a string describing the given signal, e.g. &quot;Segmentation fault&quot;.
> You should use this function in preference to strsignal(), because it 
6683c6276,6277
< Returns: a UTF-8 string describing the signal. If the signal is unknown,
---
> the strsignal() function.
> 
6722a6317,6326
> <function name="however">
> <description>
> safe.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
6852a6457
> Since: 2.14
6876d6480
< Since: 2.14
6886a6491
> Since: 2.6
6909d6513
< Since: 2.6
6946a6551,6573
> <function name="against">
> <description>
> semantics as the standard glob() function: '*' matches an arbitrary,
> possibly empty, string, '?' matches an arbitrary character.
> 
> Note that in contrast to glob(), the '/' character
> &lt;emphasis&gt;can&lt;/emphasis&gt; be matched by the wildcards, there are no
> '[...]' character ranges and '*' and '?' can
> &lt;emphasis&gt;not&lt;/emphasis&gt; be escaped to include them literally in a
> pattern.
> 
> When multiple strings must be matched against the same pattern, it
> is better to compile the pattern to a #GPatternSpec using
> g_pattern_spec_new() and use g_pattern_match_string() instead of
> g_pattern_match_simple(). This avoids the overhead of repeated
> pattern compilation.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
6958a6586
> Since: 2.14
6969d6596
< Since: 2.14
7004a6632
> Since: 2.12
7039d6666
< Since: 2.12
7082a6710
> Since: 2.2
7098d6725
< Since: 2.2
7109a6737
> Since: 2.12
7132d6759
< Since: 2.12
7150,7190d6776
< <parameter name="Returns">
< <parameter_description> the data element corresponding to the string, or %NULL if
< it is not found.
< </parameter_description>
< </parameter>
< </parameters>
< <return></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>
7192c6778,6780
< <return></return>
---
> <return> the data element corresponding to the string, or %NULL if
> it is not found.
> </return>
7263a6852
> Since: 2.4
7284d6872
< Since: 2.4
7315a6904,6923
> <function name="been">
> <description>
> %G_TRAVERSE_LEAFS.
> @G_TRAVERSE_NON_LEAVES: only non-leaf nodes should be visited. This
> name has been introduced in 2.6, for older
> version use %G_TRAVERSE_NON_LEAFS.
> @G_TRAVERSE_ALL: all nodes should be visited.
> @G_TRAVERSE_MASK: a mask of all traverse flags.
> @G_TRAVERSE_LEAFS: identical to %G_TRAVERSE_LEAVES.
> @G_TRAVERSE_NON_LEAFS: identical to %G_TRAVERSE_NON_LEAVES.
> 
> Specifies which nodes are visited during several of the tree
> functions, including g_node_traverse() and g_node_find().
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
7361,7379d6968
< <function name="G_STATIC_MUTEX_INIT">
< <description>
< A #GStaticMutex must be initialized with this macro, before it can
< be used. This macro can used be to initialize a variable, but it
< cannot be assigned to a variable. In that case you have to use
< g_static_mutex_init().
< 
< &lt;informalexample&gt;
< &lt;programlisting&gt;
< GStaticMutex my_mutex = G_STATIC_MUTEX_INIT;
< &lt;/programlisting&gt;
< &lt;/informalexample&gt;
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
7433,7436d7021
< <parameter name="Returns">
< <parameter_description> a new #GIOChannel.
< </parameter_description>
< </parameter>
7438c7023,7024
< <return></return>
---
> <return> a new #GIOChannel.
> </return>
7471c7057,7064
< Return value: a %NULL-terminated string array or %NULL if the specified 
---
> 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
7499d7091
< Since: 2.6
7680,7704d7271
< <function name="GList">
< <description>
< The #GList struct is used for each element in a doubly-linked list.
< 
< </description>
< <parameters>
< <parameter name="data">
< <parameter_description> holds the element's data, which can be a pointer to any kind
< of data, or any integer value using the &lt;link
< linkend=&quot;glib-Type-Conversion-Macros&quot;&gt;Type Conversion
< Macros&lt;/link&gt;.
< </parameter_description>
< </parameter>
< <parameter name="next">
< <parameter_description> contains the link to the next element in the list.
< </parameter_description>
< </parameter>
< <parameter name="prev">
< <parameter_description> contains the link to the previous element in the list.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
7711a7279
> Since: 2.6
7732d7299
< Since: 2.6
7738c7305,7307
< Returns: %TRUE if the previous match operation succeeded, 
---
> Returns whether the previous match operation succeeded.
> 
> Since: 2.14
7750d7318
< Since: 2.14
7780,7784d7347
< <parameter name="Returns">
< <parameter_description> seconds elapsed as a floating point value, including any
< fractional part.
< </parameter_description>
< </parameter>
7786c7349,7351
< <return></return>
---
> <return> seconds elapsed as a floating point value, including any
> fractional part.
> </return>
7856a7422
> Since: 2.6
7864d7429
< Since: 2.6
7905,7949c7470
< <function name="G_LOCK_DEFINE">
< <description>
< The %G_LOCK_* macros provide a convenient interface to #GStaticMutex
< with the advantage that they will expand to nothing in programs
< compiled against a thread-disabled GLib, saving code and memory
< there. #G_LOCK_DEFINE defines a lock. It can appear anywhere
< variable definitions may appear in programs, i.e. in the first block
< of a function or outside of functions. The @name parameter will be
< mangled to get the name of the #GStaticMutex. This means that you
< can use names of existing variables as the parameter - e.g. the name
< of the variable you intent to protect with the lock. Look at our
< &lt;function&gt;give_me_next_number()&lt;/function&gt; example using the
< %G_LOCK_* macros:
< 
< &lt;example&gt;
< &lt;title&gt;Using the %G_LOCK_* convenience macros&lt;/title&gt;
< &lt;programlisting&gt;
< G_LOCK_DEFINE (current_number);
< 
< int
< give_me_next_number (void)
< {
< static int current_number = 0;
< int ret_val;
< 
< G_LOCK (current_number);
< ret_val = current_number = calc_next_number (current_number);
< G_UNLOCK (current_number);
< 
< return ret_val;
< }
< &lt;/programlisting&gt;
< &lt;/example&gt;
< 
< </description>
< <parameters>
< <parameter name="name">
< <parameter_description> the name of the lock.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
< <function name="g_tree_insert">
---
> <function name="g_tree_insert">
8116a7638
> Since: 2.14
8135d7656
< Since: 2.14
8141c7662,7672
< Returns: The version information.
---
> 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
8148d7678
< Since: 2.6
8152c7682
< <function name="g_param_spec_int64">
---
> <function name="the">
8154,8157c7684
< Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
< 
< See g_param_spec_internal() for details on property names.
< 
---
> domains.
8161,8188d7687
< <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>
8190,8191c7689
< <return> a newly created parameter specification
< </return>
---
> <return></return>
8241c7739,7740
< Return Value: %TRUE if the @channel is buffered. 
---
> Returns whether @channel is buffered.
> 
8435c7934,7936
< Return value: The position of the first element in @queue which contains @data, or -1 if no element in @queue contains @data.
---
> Returns the position of the first element in @queue which contains @data.
> 
> Since: 2.4
8450d7950
< Since: 2.4
8483,8509d7982
< <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>
< 
8550c8023,8024
< Returns: the #GEnumValue for @value, or %NULL if @value is not a
---
> Returns the #GEnumValue for a value.
> 
8585c8059,8061
< Return value: the end iterator for @seq
---
> Returns the end iterator for @seg
> 
> Since: 2.14
8596d8071
< Since: 2.14
8628,8641c8103
< 
< </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
< the string value of a #GVariant instance with a string
---
> Returns the string value of a #GVariant instance with a string
8655,8755d8116
< </return>
< </function>
< 
< <function name="GMutex">
< <description>
< The #GMutex struct is an opaque data structure to represent a mutex
< (mutual exclusion). It can be used to protect data against shared
< access. Take for example the following function:
< 
< &lt;example&gt;
< &lt;title&gt;A function which will not work in a threaded environment&lt;/title&gt;
< &lt;programlisting&gt;
< int
< give_me_next_number (void)
< {
< static int current_number = 0;
< 
< /&lt;!-- --&gt;* now do a very complicated calculation to calculate the new
< * number, this might for example be a random number generator
< *&lt;!-- --&gt;/
< current_number = calc_next_number (current_number);
< 
< return current_number;
< }
< &lt;/programlisting&gt;
< &lt;/example&gt;
< 
< It is easy to see that this won't work in a multi-threaded
< application. There current_number must be protected against shared
< access. A first naive implementation would be:
< 
< &lt;example&gt;
< &lt;title&gt;The wrong way to write a thread-safe function&lt;/title&gt;
< &lt;programlisting&gt;
< int
< give_me_next_number (void)
< {
< static int current_number = 0;
< int ret_val;
< static GMutex * mutex = NULL;
< 
< if (!mutex) mutex = g_mutex_new (&lt;!-- --&gt;);
< 
< g_mutex_lock (mutex);
< ret_val = current_number = calc_next_number (current_number);
< g_mutex_unlock (mutex);
< 
< return ret_val;
< }
< &lt;/programlisting&gt;
< &lt;/example&gt;
< 
< This looks like it would work, but there is a race condition while
< constructing the mutex and this code cannot work reliable. Please do
< not use such constructs in your own programs! One working solution
< is:
< 
< &lt;example&gt;
< &lt;title&gt;A correct thread-safe function&lt;/title&gt;
< &lt;programlisting&gt;
< static GMutex *give_me_next_number_mutex = NULL;
< 
< /&lt;!-- --&gt;* this function must be called before any call to
< * give_me_next_number(&lt;!-- --&gt;)
< *
< * it must be called exactly once.
< *&lt;!-- --&gt;/
< void
< init_give_me_next_number (void)
< {
< g_assert (give_me_next_number_mutex == NULL);
< give_me_next_number_mutex = g_mutex_new (&lt;!-- --&gt;);
< }
< 
< int
< give_me_next_number (void)
< {
< static int current_number = 0;
< int ret_val;
< 
< g_mutex_lock (give_me_next_number_mutex);
< ret_val = current_number = calc_next_number (current_number);
< g_mutex_unlock (give_me_next_number_mutex);
< 
< return ret_val;
< }
< &lt;/programlisting&gt;
< &lt;/example&gt;
< 
< #GStaticMutex provides a simpler and safer way of doing this.
< 
< If you want to use a mutex, and your code should also work without
< calling g_thread_init() first, then you can not use a #GMutex, as
< g_mutex_new() requires that the thread system be initialized. Use a
< #GStaticMutex instead.
< 
< A #GMutex should only be accessed via the following functions.
< 
< &lt;note&gt;&lt;para&gt;All of the &lt;function&gt;g_mutex_*&lt;/function&gt; functions are
< actually macros. Apart from taking their addresses, you can however
< use them as if they were functions.&lt;/para&gt;&lt;/note&gt;
8758a8120,8127
> <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>
8760c8129,8130
< <return></return>
---
> <return> the constant string
> </return>
8780,8783d8149
< <parameter name="Returns">
< <parameter_description> the #GByteArray.
< </parameter_description>
< </parameter>
8785c8151,8152
< <return></return>
---
> <return> the #GByteArray.
> </return>
8817a8185,8190
> 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
8827,8832d8199
< 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
8906a8274
> Since: 2.6
8918d8285
< Since: 2.6
8966a8334,8365
> <function name="unique">
> <description>
> Quarks are associations between strings and integer identifiers.
> Given either the string or the #GQuark identifier it is possible to
> retrieve the other.
> 
> Quarks are used for both &lt;link
> linkend=&quot;glib-datasets&quot;&gt;Datasets&lt;/link&gt; and &lt;link
> linkend=&quot;glib-keyed-data-lists&quot;&gt;Keyed Data Lists&lt;/link&gt;.
> 
> To create a new quark from a string, use g_quark_from_string() or
> g_quark_from_static_string().
> 
> To find the string corresponding to a given #GQuark, use
> g_quark_to_string().
> 
> To find the #GQuark corresponding to a given string, use
> g_quark_try_string().
> 
> Another use for the string pool maintained for the quark functions
> is string interning, using g_intern_string() or
> g_intern_static_string(). An interned string is a canonical
> representation for a string. One important advantage of interned
> strings is that they can be compared for equality by a simple
> pointer comparision, rather than using strcmp().
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
8995c8394,8504
< Return value: The main loop recursion level in the current thread
---
> 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;
> 
9042c8551,8554
< Return value: whether @error has @domain and @code
---
> Returns %TRUE if @error matches @domain and @code, %FALSE
> otherwise. In particular, when @error is %NULL, %FALSE will
> be returned.
> 
9128c8640,8641
< Calls a function for each element of a #GSList.
---
> Specifies the type of functions passed to g_list_foreach() and
> g_slist_foreach().
9132,9143d8644
< <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>
9187a8689
> Since: 2.6
9204d8705
< Since: 2.6
9211a8713
> Since: 2.22
9222d8723
< Since: 2.22
9255a8757
> Since: 2.4
9272d8773
< Since: 2.4
9313c8814
< <function name="g_match_info_expand_references">
---
> <function name="for">
9315c8816,8835
< Returns: the expanded string, or %NULL if an error occurred
---
> The #GTree structure and its associated functions provide a sorted
> collection of key/value pairs optimized for searching and traversing
> in order.
> 
> To create a new #GTree use g_tree_new().
> 
> To insert a key/value pair into a #GTree use g_tree_insert().
> 
> To lookup the value corresponding to a given key, use
> g_tree_lookup() and g_tree_lookup_extended().
> 
> To find out the number of nodes in a #GTree, use g_tree_nnodes(). To
> get the height of a #GTree, use g_tree_height().
> 
> To traverse a #GTree, calling a function for each node visited in
> the traversal, use g_tree_foreach().
> 
> To remove a key/value pair use g_tree_remove().
> 
> To destroy a #GTree, use g_tree_destroy().
9319,9330d8838
< <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>
9332,9335c8840
< <return> the expanded string, or %NULL if an error occurred
< 
< Since: 2.14
< </return>
---
> <return></return>
9512,9515d9016
< <parameter name="Returns">
< <parameter_description> the new #GArray.
< </parameter_description>
< </parameter>
9517c9018,9019
< <return></return>
---
> <return> the new #GArray.
> </return>
9548,9557d9049
< <function name="G_THREAD_ERROR">
< <description>
< The error domain of the GLib thread subsystem.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
9575a9068
> Since: 2.6
9587d9079
< Since: 2.6
9591,9608d9082
< <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>
< 
9665a9140,9143
> Returns the file descriptor of the #GIOChannel.
> 
> On Windows this function returns the file descriptor or socket of
> the #GIOChannel.
9673,9676d9150
< <parameter name="Returns">
< <parameter_description> the file descriptor of the #GIOChannel.
< </parameter_description>
< </parameter>
9678,9681c9152
< <return>the file descriptor of the #GIOChannel.
< 
< On Windows this function returns the file descriptor or socket of
< the #GIOChannel.
---
> <return> the file descriptor of the #GIOChannel.
9781c9252
< <function name="GNodeTraverseFunc">
---
> <function name="g_type_interface_add_prerequisite">
9783,9786c9254,9258
< Specifies the type of function passed to g_node_traverse(). The
< function is called with each of the nodes visited, together with the
< user data passed to g_node_traverse(). If the function returns
< %TRUE, then the traversal is stopped.
---
> 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.
9790,9795c9262,9263
< <parameter name="node">
< <parameter_description> a #GNode.
< </parameter_description>
< </parameter>
< <parameter name="data">
< <parameter_description> user data passed to g_node_traverse().
---
> <parameter name="interface_type">
> <parameter_description> #GType value of an interface type.
9798,9799c9266,9267
< <parameter name="Returns">
< <parameter_description> %TRUE to stop the traversal.
---
> <parameter name="prerequisite_type">
> <parameter_description> #GType value of an interface or instantiatable type.
9811a9280
> Since: 2.6
9824d9292
< Since: 2.6
9828,9896c9296
< <function name="GCond">
< <description>
< The #GCond struct is an opaque data structure that represents a
< condition. Threads can block on a #GCond if they find a certain
< condition to be false. If other threads change the state of this
< condition they signal the #GCond, and that causes the waiting
< threads to be woken up.
< 
< &lt;example&gt;
< &lt;title&gt;
< Using GCond to block a thread until a condition is satisfied
< &lt;/title&gt;
< &lt;programlisting&gt;
< GCond* data_cond = NULL; /&lt;!-- --&gt;* Must be initialized somewhere *&lt;!-- --&gt;/
< GMutex* data_mutex = NULL; /&lt;!-- --&gt;* Must be initialized somewhere *&lt;!-- --&gt;/
< gpointer current_data = NULL;
< 
< void
< push_data (gpointer data)
< {
< g_mutex_lock (data_mutex);
< current_data = data;
< g_cond_signal (data_cond);
< g_mutex_unlock (data_mutex);
< }
< 
< gpointer
< pop_data (void)
< {
< gpointer data;
< 
< g_mutex_lock (data_mutex);
< while (!current_data)
< g_cond_wait (data_cond, data_mutex);
< data = current_data;
< current_data = NULL;
< g_mutex_unlock (data_mutex);
< 
< return data;
< }
< &lt;/programlisting&gt;
< &lt;/example&gt;
< 
< Whenever a thread calls &lt;function&gt;pop_data()&lt;/function&gt; now, it will
< wait until current_data is non-%NULL, i.e. until some other thread
< has called &lt;function&gt;push_data()&lt;/function&gt;.
< 
< &lt;note&gt;&lt;para&gt;It is important to use the g_cond_wait() and
< g_cond_timed_wait() functions only inside a loop which checks for the
< condition to be true.  It is not guaranteed that the waiting thread
< will find the condition fulfilled after it wakes up, even if the
< signaling thread left the condition in that state: another thread may
< have altered the condition before the waiting thread got the chance
< to be woken up, even if the condition itself is protected by a
< #GMutex, like above.&lt;/para&gt;&lt;/note&gt;
< 
< A #GCond should only be accessed via the following functions.
< 
< &lt;note&gt;&lt;para&gt;All of the &lt;function&gt;g_cond_*&lt;/function&gt; functions are
< actually macros. Apart from taking their addresses, you can however
< use them as if they were functions.&lt;/para&gt;&lt;/note&gt;
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
< <function name="g_source_remove_by_user_data">
---
> <function name="g_filename_to_uri">
9898,9900c9298,9299
< 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.
---
> Converts an absolute filename to an escaped ASCII-encoded URI, with the path
> component following Section 3.3. of RFC 2396.
9905,9906c9304,9316
< <parameter name="user_data">
< <parameter_description> the user_data for the callback.
---
> <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.
9910c9320,9321
< <return> %TRUE if a source was found and removed. 
---
> <return> a newly-allocated string holding the resulting
> URI, or %NULL on an error.
9924a9336
> Since: 2.16
9945d9356
< Since: 2.16
9992a9404
> Since: 2.22
10004d9415
< Since: 2.22
10075c9486,9488
< Return value: A random number.
---
> Returns the next random #guint32 from @rand_ equally distributed over
> the range [0..2^32-1].
> 
10164a9578
> Since: 2.14
10179d9592
< Since: 2.14
10420a9834
> Since: 2.14
10456d9869
< Since: 2.14
10494c9907
< <function name="g_param_spec_override">
---
> <function name="syscall">
10496,10498c9909,9959
< 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.
---
> Specifies properties of a #GIOChannel. Some of the flags can only be
> read with g_io_channel_get_flags(), but not changed with
> g_io_channel_set_flags().
> 
> </description>
> <parameters>
> <parameter name="G_IO_FLAG_NONBLOCK">
> <parameter_description> turns on nonblocking mode, corresponds to
> %O_NONBLOCK/%O_NDELAY (see the documentation of
> the UNIX open() syscall).
> </parameter_description>
> </parameter>
> <parameter name="G_IO_FLAG_IS_READABLE">
> <parameter_description> indicates that the io channel is readable.
> This flag can not be changed.
> </parameter_description>
> </parameter>
> <parameter name="G_IO_FLAG_IS_WRITEABLE">
> <parameter_description> indicates that the io channel is writable.
> This flag can not be changed.
> </parameter_description>
> </parameter>
> <parameter name="G_IO_FLAG_IS_SEEKABLE">
> <parameter_description> indicates that the io channel is seekable,
> i.e. that g_io_channel_seek_position() can
> be used on it.  This flag can not be changed.
> </parameter_description>
> </parameter>
> <parameter name="G_IO_FLAG_MASK">
> <parameter_description> the mask that specifies all the valid flags.
> </parameter_description>
> </parameter>
> <parameter name="G_IO_FLAG_GET_MASK">
> <parameter_description> the mask of the flags that are returned from
> g_io_channel_get_flags().
> </parameter_description>
> </parameter>
> <parameter name="G_IO_FLAG_SET_MASK">
> <parameter_description> the mask of the flags that the user can modify
> with g_io_channel_set_flags().
> </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.
10520c9981,9985
< Returns: Location of the #GTypeValueTable associated with @type or
---
> 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;
> 
10582,10593d10046
< <function name="GMemChunk">
< <description>
< The #GMemChunk struct is an opaque data structure representing a
< memory chunk. It should be accessed only through the use of the
< following functions.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
10861c10314,10321
< Return value: the length of the @queue.
---
> 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.  
> 
10892a10353
> Since: 2.12
10912d10372
< Since: 2.12
10931,10932c10391,10429
< <parameter name="Returns">
< <parameter_description> Whether the compiled patterns are equal
---
> </parameters>
> <return> Whether the compiled patterns are equal
> </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
10936c10433,10435
< <return></return>
---
> <return> the expanded string, or %NULL if an error occurred
> 
> </return>
10946a10446
> Since: 2.6
10962d10461
< Since: 2.6
10968c10467,10469
< Returns: the summary
---
> Returns the summary. See g_option_context_set_summary().
> 
> Since: 2.12
10979d10479
< Since: 2.12
10983c10483,10526
< <function name="GRand">
---
> <function name="pseudo">
> <description>
> PRNG, which was originally developed by Makoto Matsumoto and Takuji
> Nishimura. Further information can be found at
> &lt;ulink url=&quot;http://www.math.keio.ac.jp/~matumoto/emt.html&quot;&gt;
> www.math.keio.ac.jp/~matumoto/emt.html&lt;/ulink&gt;.
> 
> If you just need a random number, you simply call the
> &lt;function&gt;g_random_*&lt;/function&gt; functions, which will create a
> globally used #GRand and use the according
> &lt;function&gt;g_rand_*&lt;/function&gt; functions internally. Whenever you
> need a stream of reproducible random numbers, you better create a
> #GRand yourself and use the &lt;function&gt;g_rand_*&lt;/function&gt; functions
> directly, which will also be slightly faster. Initializing a #GRand
> with a certain seed will produce exactly the same series of random
> numbers on all platforms. This can thus be used as a seed for e.g.
> games.
> 
> The &lt;function&gt;g_rand*_range&lt;/function&gt; functions will return high
> quality equally distributed random numbers, whereas for example the
> &lt;literal&gt;(g_random_int()%max)&lt;/literal&gt; approach often
> doesn't yield equally distributed numbers.
> 
> GLib changed the seeding algorithm for the pseudo-random number
> generator Mersenne Twister, as used by
> &lt;structname&gt;GRand&lt;/structname&gt; and &lt;structname&gt;GRandom&lt;/structname&gt;.
> This was necessary, because some seeds would yield very bad
> pseudo-random streams.  Also the pseudo-random integers generated by
> &lt;function&gt;g_rand*_int_range()&lt;/function&gt; will have a slightly better
> equal distribution with the new version of GLib.
> 
> The original seeding and generation algorithms, as found in GLib
> 2.0.x, can be used instead of the new ones by setting the
> environment variable &lt;envar&gt;G_RANDOM_VERSION&lt;/envar&gt; to the value of
> '2.0'. Use the GLib-2.0 algorithms only if you have sequences of
> numbers generated with Glib-2.0 that you need to reproduce exactly.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
> <function name="g_object_class_override_property">
10985,10986c10528,10547
< The #GRand struct is an opaque data structure. It should only be
< accessed through the &lt;function&gt;g_rand_*&lt;/function&gt; functions.
---
> 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
10989a10551,10563
> <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>
11035c10609
< <function name="GByteArray">
---
> <function name="g_io_channel_win32_new_socket">
11037,11038c10611,10618
< The &lt;structname&gt;GByteArray&lt;/structname&gt; struct allows access to the
< public fields of a &lt;structname&gt;GByteArray&lt;/structname&gt;.
---
> 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.
11042,11048c10622,10623
< <parameter name="data">
< <parameter_description> a pointer to the element data. The data may be moved as
< elements are added to the #GByteArray.
< </parameter_description>
< </parameter>
< <parameter name="len">
< <parameter_description> the number of elements in the #GByteArray.
---
> <parameter name="socket">
> <parameter_description> a Winsock socket
11052c10627,10628
< <return></return>
---
> <return> a new #GIOChannel
> </return>
11070a10647,10655
> <function name="iterator">
> <description>
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
11079a10665
> Since: 2.12
11098d10683
< Since: 2.12
11126c10711,10715
< Returns: The corresponding #GTypeInterface structure of the parent
---
> 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.
> 
11160,11195d10748
< <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>
< 
11264c10817,10824
< Returns: the contents of @file, or %NULL.
---
> 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
11275d10834
< Since: 2.8
11392a10952,11043
> <function name="string">
> <description>
> Keyed data lists provide lists of arbitrary data elements which can
> be accessed either with a string or with a #GQuark corresponding to
> the string.
> 
> The #GQuark methods are quicker, since the strings have to be
> converted to #GQuarks anyway.
> 
> Data lists are used for associating arbitrary data with #GObjects,
> using g_object_set_data() and related functions.
> 
> To create a datalist, use g_datalist_init().
> 
> To add data elements to a datalist use g_datalist_id_set_data(),
> g_datalist_id_set_data_full(), g_datalist_set_data() and
> g_datalist_set_data_full().
> 
> To get data elements from a datalist use g_datalist_id_get_data()
> and g_datalist_get_data().
> 
> To iterate over all data elements in a datalist use
> g_datalist_foreach() (not thread-safe).
> 
> To remove data elements from a datalist use
> g_datalist_id_remove_data() and g_datalist_remove_data().
> 
> To remove all data elements from a datalist, use g_datalist_clear().
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
> <function name="advantage">
> <description>
> but can be defined at compile-time. Here is a shorter, easier and
> safer version of our &lt;function&gt;give_me_next_number()&lt;/function&gt;
> example:
> 
> &lt;example&gt;
> &lt;title&gt;
> Using &lt;structname&gt;GStaticMutex&lt;/structname&gt;
> to simplify thread-safe programming
> &lt;/title&gt;
> &lt;programlisting&gt;
> int
> give_me_next_number (void)
> {
> static int current_number = 0;
> int ret_val;
> static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
> 
> g_static_mutex_lock (&amp;mutex);
> ret_val = current_number = calc_next_number (current_number);
> g_static_mutex_unlock (&amp;mutex);
> 
> return ret_val;
> }
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> Sometimes you would like to dynamically create a mutex. If you don't
> want to require prior calling to g_thread_init(), because your code
> should also be usable in non-threaded programs, you are not able to
> use g_mutex_new() and thus #GMutex, as that requires a prior call to
> g_thread_init(). In theses cases you can also use a #GStaticMutex.
> It must be initialized with g_static_mutex_init() before using it
> and freed with with g_static_mutex_free() when not needed anymore to
> free up any allocated resources.
> 
> Even though #GStaticMutex is not opaque, it should only be used with
> the following functions, as it is defined differently on different
> platforms.
> 
> All of the &lt;function&gt;g_static_mutex_*&lt;/function&gt; functions apart
> from &lt;function&gt;g_static_mutex_get_mutex&lt;/function&gt; can also be used
> even if g_thread_init() has not yet been called. Then they do
> nothing, apart from &lt;function&gt;g_static_mutex_trylock&lt;/function&gt;,
> which does nothing but returning %TRUE.
> 
> &lt;note&gt;&lt;para&gt;All of the &lt;function&gt;g_static_mutex_*&lt;/function&gt;
> functions are actually macros. Apart from taking their addresses, you
> can however use them as if they were functions.&lt;/para&gt;&lt;/note&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
11538a11190
> Since: 2.6
11562d11213
< Since: 2.6
11589,11592d11239
< <parameter name="Returns">
< <parameter_description> a new #GAllocator.
< </parameter_description>
< </parameter>
11594c11241,11242
< <return></return>
---
> <return> a new #GAllocator.
> </return>
11635a11284
> Since: 2.4
11655d11303
< Since: 2.4
11664a11313
> Since: 2.4
11680d11328
< Since: 2.4
11803a11452
> Since: 2.12
11830d11478
< Since: 2.12
11930a11579
> Since: 2.16
11941d11589
< Since: 2.16
11947a11596,11597
> returns the given field of the record at the given index. The
> returned value should not be changed.
11963,11966d11612
< <parameter name="Returns">
< <parameter_description> the field of the record.
< </parameter_description>
< </parameter>
11968,11969c11614
< <return>the given field of the record at the given index. The
< returned value should not be changed.
---
> <return> the field of the record.
11985,11989d11629
< <parameter name="Returns">
< <parameter_description> the #GQuark identifying the string, or 0 if @string is
< %NULL.
< </parameter_description>
< </parameter>
11991c11631,11633
< <return></return>
---
> <return> the #GQuark identifying the string, or 0 if @string is
> %NULL.
> </return>
12057,12060d11698
< <parameter name="Returns">
< <parameter_description> the data previously stored at @key_id, or %NULL if none.
< </parameter_description>
< </parameter>
12062c11700,11701
< <return></return>
---
> <return> the data previously stored at @key_id, or %NULL if none.
> </return>
12088,12103d11726
< <function name="GVariantBuilder">
< <description>
< A utility type for constructing container-type #GVariant instances.
< 
< This is an opaque structure and may only be accessed using the
< following functions.
< 
< #GVariantBuilder is not threadsafe in any way.  Do not attempt to
< access it from more than one thread.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
12148,12171d11770
< <function name="G_VARIANT_PARSE_ERROR">
< <description>
< Error domain for GVariant text format parsing.  Specific error codes
< are not currently defined for this domain.  See #GError for
< information on error domains.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
< <function name="G_SHELL_ERROR">
< <description>
< Error domain for shell functions. Errors in this domain will be from
< the #GShellError enumeration. See #GError for information on error
< domains.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
12175a11775
> Since: 2.12
12190d11789
< Since: 2.12
12247,12248c11846,11869
< <parameter name="Returns">
< <parameter_description> the pointer which was removed.
---
> </parameters>
> <return> the pointer which was removed.
> </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
12252c11873,11874
< <return></return>
---
> <return> -1, 0 or +1, for a less than, equal to or greater than result
> </return>
12280a11903
> Since: 2.2
12300d11922
< Since: 2.2
12480,12483d12101
< <parameter name="Returns">
< <parameter_description> the #GByteArray.
< </parameter_description>
< </parameter>
12485c12103,12104
< <return></return>
---
> <return> the #GByteArray.
> </return>
12534c12153,12161
< Return value: the length of the @queue.
---
> 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.
> 
12546a12174,12183
> <function name="memory">
> <description>
> following functions.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
12591,12621d12227
< <function name="GHRFunc">
< <description>
< Specifies the type of the function passed to
< g_hash_table_foreach_remove(). It is called with each key/value
< pair, together with the @user_data parameter passed to
< g_hash_table_foreach_remove(). It should return %TRUE if the
< key/value pair should be removed from the #GHashTable.
< 
< </description>
< <parameters>
< <parameter name="key">
< <parameter_description> a key.
< </parameter_description>
< </parameter>
< <parameter name="value">
< <parameter_description> the value associated with the key.
< </parameter_description>
< </parameter>
< <parameter name="user_data">
< <parameter_description> user data passed to g_hash_table_remove().
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> %TRUE if the key/value pair should be removed from the
< #GHashTable.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
12748,12751d12353
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
12753c12355,12356
< <return></return>
---
> <return> the #GArray.
> </return>
12841a12445
> Since: 2.16
12862d12465
< Since: 2.16
12898a12502
> Since: 2.10
12909d12512
< Since: 2.10
12913c12516
< <function name="G_LOCK">
---
> <function name="can">
12915,12916c12518,12533
< Works like g_mutex_lock(), but for a lock defined with
< #G_LOCK_DEFINE.
---
> &lt;informalexample&gt;
> &lt;programlisting&gt;
> GStaticPrivate my_private = G_STATIC_PRIVATE_INIT;
> &lt;/programlisting&gt;
> &lt;/informalexample&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
> <function name="following">
> <description>
> #GVariantBuilder is not threadsafe in any way.  Do not attempt to
> access it from more than one thread.
12920,12923d12536
< <parameter name="name">
< <parameter_description> the name of the lock.
< </parameter_description>
< </parameter>
12970,12974d12582
< <parameter name="Returns">
< <parameter_description> %TRUE if the pointer is removed. %FALSE if the pointer is
< not found in the array.
< </parameter_description>
< </parameter>
12976c12584,12586
< <return></return>
---
> <return> %TRUE if the pointer is removed. %FALSE if the pointer is
> not found in the array.
> </return>
13040a12651,12656
> 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
13050,13055d12665
< 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
13117a12728
> Since: 2.6
13132d12742
< Since: 2.6
13139a12750
> Since: 2.6
13154d12764
< Since: 2.6
13267a12878
> Since: 2.18
13283d12893
< Since: 2.18
13292d12901
< @Returns:  #TRUE if @instance is valid, #FALSE otherwise.
13301c12910,12911
< <return></return>
---
> <return>  #TRUE if @instance is valid, #FALSE otherwise.
> </return>
13333a12944,12952
> <function name="parameter">
> <description>
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
13336c12955,12962
< Returns: %TRUE if a handler is connected to the signal, %FALSE
---
> 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.
> 
13419,13454d13044
< <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>
< 
13459a13050
> Since: 2.12
13474d13064
< Since: 2.12
13496c13086
< <function name="g_param_spec_set_qdata">
---
> <function name="data">
13498,13503d13087
< 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.
13507,13518d13090
< <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>
13523c13095,13171
< <function name="g_thread_exit">
---
> <function name="grow">
> <description>
> Pointer Arrays are similar to Arrays but are used only for storing
> pointers.
> 
> &lt;note&gt;&lt;para&gt;If you remove elements from the array, elements at the
> end of the array are moved into the space previously occupied by the
> removed element. This means that you should not rely on the index of
> particular elements remaining the same. You should also be careful
> when deleting elements while iterating over the array.&lt;/para&gt;&lt;/note&gt;
> 
> To create a pointer array, use g_ptr_array_new().
> 
> To add elements to a pointer array, use g_ptr_array_add().
> 
> To remove elements from a pointer array, use g_ptr_array_remove(),
> g_ptr_array_remove_index() or g_ptr_array_remove_index_fast().
> 
> To access an element of a pointer array, use g_ptr_array_index().
> 
> To set the size of a pointer array, use g_ptr_array_set_size().
> 
> To free a pointer array, use g_ptr_array_free().
> 
> &lt;example&gt;
> &lt;title&gt;Using a #GPtrArray&lt;/title&gt;
> &lt;programlisting&gt;
> GPtrArray *gparray;
> gchar *string1 = &quot;one&quot;, *string2 = &quot;two&quot;, *string3 = &quot;three&quot;;
> 
> gparray = g_ptr_array_new (&lt;!-- --&gt;);
> g_ptr_array_add (gparray, (gpointer) string1);
> g_ptr_array_add (gparray, (gpointer) string2);
> g_ptr_array_add (gparray, (gpointer) string3);
> 
> if (g_ptr_array_index (gparray, 0) != (gpointer) string1)
> g_print (&quot;ERROR: got %p instead of %p\n&quot;,
> g_ptr_array_index (gparray, 0), string1);
> 
> g_ptr_array_free (gparray, TRUE);
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> </description>
> <parameters>
> </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">
13553a13202,13246
> <function name="automatically">
> <description>
> Arrays are similar to standard C arrays, except that they grow
> automatically as elements are added.
> 
> Array elements can be of any size (though all elements of one array
> are the same size), and the array can be automatically cleared to
> '0's and zero-terminated.
> 
> To create a new array use g_array_new().
> 
> To add elements to an array, use g_array_append_val(),
> g_array_append_vals(), g_array_prepend_val(), and
> g_array_prepend_vals().
> 
> To access an element of an array, use g_array_index().
> 
> To set the size of an array, use g_array_set_size().
> 
> To free an array, use g_array_free().
> 
> &lt;example&gt;
> &lt;title&gt;Using a #GArray to store #gint values&lt;/title&gt;
> &lt;programlisting&gt;
> GArray *garray;
> gint i;
> /&lt;!-- --&gt;* We create a new array to store gint values.
> We don't want it zero-terminated or cleared to 0's. *&lt;!-- --&gt;/
> garray = g_array_new (FALSE, FALSE, sizeof (gint));
> for (i = 0; i &lt; 10000; i++)
> g_array_append_val (garray, i);
> for (i = 0; i &lt; 10000; i++)
> if (g_array_index (garray, gint, i) != i)
> g_print (&quot;ERROR: got %d instead of %d\n&quot;,
> g_array_index (garray, gint, i), i);
> g_array_free (garray, TRUE);
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
13621a13315
> Since: 2.22
13632d13325
< Since: 2.22
13657c13350,13357
< Returns: 0 if the information was successfully retrieved, -1 if an error 
---
> 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.
> 
> See your C library manual for more details about stat().
> 
> Since: 2.6
13674d13373
< Since: 2.6
13688a13388
> Since: 2.14	
13699d13398
< Since: 2.14	
13702a13402,13411
> <function name="equality">
> <description>
> and %FALSE otherwise.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
13777,13821d13485
< <function name="GOnce">
< <description>
< A #GOnce struct controls a one-time initialization function. Any
< one-time initialization function must have its own unique #GOnce
< struct.
< 
< Since: 2.4
< 
< </description>
< <parameters>
< <parameter name="status">
< <parameter_description> the status of the #GOnce
< </parameter_description>
< </parameter>
< <parameter name="retval">
< <parameter_description> the value returned by the call to the function, if @status
< is %G_ONCE_STATUS_READY
< </parameter_description>
< </parameter>
< </parameters>
< <return></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>
< 
13941a13606
> Since: 2.16
13956d13620
< Since: 2.16
14124a13789
> Since: 2.6
14158d13822
< Since: 2.6
14164c13828,13829
< Return value: the maximal number of unused threads
---
> Returns the maximal allowed number of unused threads.
> 
14244,14248d13908
< <parameter name="Returns">
< <parameter_description> the element data if @free_segment is %FALSE, otherwise
< %NULL.  The element data should be freed using g_free().
< </parameter_description>
< </parameter>
14250c13910,13912
< <return></return>
---
> <return> the element data if @free_segment is %FALSE, otherwise
> %NULL.  The element data should be freed using g_free().
> </return>
14299c13961,13964
< Returns: %TRUE if @file_name is an absolute path. 
---
> 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.
> 
14346a14012
> Since: 2.14
14369d14034
< Since: 2.14
14405c14070
< <function name="g_filename_to_uri">
---
> <function name="g_source_remove_by_user_data">
14407,14408c14072,14074
< Converts an absolute filename to an escaped ASCII-encoded URI, with the path
< component following Section 3.3. of RFC 2396.
---
> 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.
14413,14425c14079,14080
< <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 name="user_data">
> <parameter_description> the user_data for the callback.
14429,14430c14084
< <return> a newly-allocated string holding the resulting
< URI, or %NULL on an error.
---
> <return> %TRUE if a source was found and removed. 
14468,14471d14121
< <parameter name="Returns">
< <parameter_description> a pointer to the allocated atom.
< </parameter_description>
< </parameter>
14473c14123,14124
< <return></return>
---
> <return> a pointer to the allocated atom.
> </return>
14479a14131
> Since: 2.6
14502d14153
< Since: 2.6
14513a14165
> Since: 2.12
14520d14171
< Since: 2.12
14527a14179
> Since: 2.4
14542d14193
< Since: 2.4
14656c14307,14308
< Return value: the number of unprocessed tasks
---
> Returns the number of tasks still unprocessed in @pool.
> 
14779a14432
> Since: 2.14
14807d14459
< Since: 2.14
14824a14477
> Since: 2.22
14846d14498
< Since: 2.22
14874a14527,14540
> <function name="array">
> <description>
> Contains the public fields of a pointer array.
> 
> </description>
> <parameters>
> <parameter name="len">
> <parameter_description> number of pointers in the array.
> </parameter_description>
> </parameter>
> </parameters>
> <return></return>
> </function>
> 
14936c14602
< <function name="g_value_array_remove">
---
> <function name="given">
14938c14604,14627
< Remove the value at position @index_ from @value_array.
---
> A #GHashTable provides associations between keys and values which is
> optimized so that given a key, the associated value can be found
> very quickly.
> 
> Note that neither keys nor values are copied when inserted into the
> #GHashTable, so they must exist for the lifetime of the #GHashTable.
> This means that the use of static strings is OK, but temporary
> strings (i.e. those created in buffers and those returned by GTK+
> widgets) should be copied with g_strdup() before being inserted.
> 
> If keys or values are dynamically allocated, you must be careful to
> ensure that they are freed when they are removed from the
> #GHashTable, and also when they are overwritten by new insertions
> into the #GHashTable. It is also not advisable to mix static strings
> and dynamically-allocated strings in a #GHashTable, because it then
> becomes difficult to determine whether the string should be freed.
> 
> To create a #GHashTable, use g_hash_table_new().
> 
> To insert a key and value into a #GHashTable, use
> g_hash_table_insert().
> 
> To lookup a value corresponding to a given key, use
> g_hash_table_lookup() and g_hash_table_lookup_extended().
14939a14629,14635
> To remove a key and value, use g_hash_table_remove().
> 
> To call a function for each key and value pair use
> g_hash_table_foreach() or use a iterator to iterate over the
> key/value pairs in the hash table, see #GHashTableIter.
> 
> To destroy a #GHashTable use g_hash_table_destroy().
14943,14950d14638
< <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>
14952,14953c14640
< <return> the #GValueArray passed in as @value_array
< </return>
---
> <return></return>
14964,14967d14650
< <parameter name="Returns">
< <parameter_description> a pointer to the newly-allocated #GSList element.
< </parameter_description>
< </parameter>
14969c14652,14653
< <return></return>
---
> <return> a pointer to the newly-allocated #GSList element.
> </return>
15000c14684,14688
< Return value: Whether the channel will be closed on the final unref of
---
> 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.
> 
15039a14728
> Since: 2.16
15051d14739
< Since: 2.16
15059a14748
> Since: 2.2
15079d14767
< Since: 2.2
15083,15107d14770
< <function name="GStaticRecMutex">
< <description>
< A #GStaticRecMutex works like a #GStaticMutex, but it can be locked
< multiple times by one thread. If you enter it n times, you have to
< unlock it n times again to let other threads lock it. An exception
< is the function g_static_rec_mutex_unlock_full(): that allows you to
< unlock a #GStaticRecMutex completely returning the depth, (i.e. the
< number of times this mutex was locked). The depth can later be used
< to restore the state of the #GStaticRecMutex by calling
< g_static_rec_mutex_lock_full().
< 
< Even though #GStaticRecMutex is not opaque, it should only be used
< with the following functions.
< 
< All of the &lt;function&gt;g_static_rec_mutex_*&lt;/function&gt; functions can
< be used even if g_thread_init() has not been called. Then they do
< nothing, apart from &lt;function&gt;g_static_rec_mutex_trylock&lt;/function&gt;,
< which does nothing but returning %TRUE.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
15110c14773,14777
< Returns: #GRegex object used in @match_info
---
> 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
15121d14787
< Since: 2.14
15193,15197d14858
< <parameter name="Returns">
< <parameter_description> the element data if @free_segment is %FALSE, otherwise
< %NULL.  The element data should be freed using g_free().
< </parameter_description>
< </parameter>
15199c14860,14862
< <return></return>
---
> <return> the element data if @free_segment is %FALSE, otherwise
> %NULL.  The element data should be freed using g_free().
> </return>
15203a14867,14869
> 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.
15216,15219d14881
< <parameter name="Returns">
< <parameter_description> %TRUE if a record matches.
< </parameter_description>
< </parameter>
15221,15223c14883
< <return>%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.
---
> <return> %TRUE if a record matches.
15229c14889,14893
< Returns: a UTF-8 string describing the error code. If the error code 
---
> 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.
> 
15303a14968
> Since: 2.16
15310d14974
< Since: 2.16
15323a14988
> Since: 2.22
15335d14999
< Since: 2.22
15365a15030,15038
> <function name="accessed">
> <description>
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
15477,15481d15149
< <parameter name="Returns">
< <parameter_description> the pointer array if @free_seg is %FALSE, otherwise %NULL.
< The pointer array should be freed using g_free().
< </parameter_description>
< </parameter>
15483c15151,15153
< <return></return>
---
> <return> the pointer array if @free_seg is %FALSE, otherwise %NULL.
> The pointer array should be freed using g_free().
> </return>
15550a15221,15226
> 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
15560c15236,15237
< the 64-bit unsigned integer value of @value.
---
> </return>
> </function>
15562,15563c15239,15246
< It is an error to call this function with a @value of any type
< other than %G_VARIANT_TYPE_UINT64.
---
> <function name="multiple">
> <description>
> unlock it n times again to let other threads lock it. An exception
> is the function g_static_rec_mutex_unlock_full(): that allows you to
> unlock a #GStaticRecMutex completely returning the depth, (i.e. the
> number of times this mutex was locked). The depth can later be used
> to restore the state of the #GStaticRecMutex by calling
> g_static_rec_mutex_lock_full().
15565,15566c15248,15259
< Since: 2.24
< </return>
---
> Even though #GStaticRecMutex is not opaque, it should only be used
> with the following functions.
> 
> All of the &lt;function&gt;g_static_rec_mutex_*&lt;/function&gt; functions can
> be used even if g_thread_init() has not been called. Then they do
> nothing, apart from &lt;function&gt;g_static_rec_mutex_trylock&lt;/function&gt;,
> which does nothing but returning %TRUE.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
15571c15264,15266
< Return value: A random number.
---
> Returns the next random #gint32 from @rand_ equally distributed over
> the range [@begin..@end-1].
> 
15823a15519,15528
> <function name="considered">
> <description>
> functions.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
15940,15951d15644
< <function name="GRelation">
< <description>
< The #GRelation struct is an opaque data structure to represent a
< &lt;link linkend=&quot;glib-Relations-and-Tuples&quot;&gt;Relation&lt;/link&gt;. It should
< only be accessed via the following functions.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
15970,15974d15662
< <parameter name="Returns">
< <parameter_description> a pointer to the allocated atom, cast to a pointer to
< @type.
< </parameter_description>
< </parameter>
15976c15664,15666
< <return></return>
---
> <return> a pointer to the allocated atom, cast to a pointer to
> @type.
> </return>
15991,15994d15680
< <parameter name="Returns">
< <parameter_description> the new #GCompletion.
< </parameter_description>
< </parameter>
15996c15682,15683
< <return></return>
---
> <return> the new #GCompletion.
> </return>
16034,16037d15720
< <parameter name="Returns">
< <parameter_description> the string associated with the #GQuark.
< </parameter_description>
< </parameter>
16039c15722,15723
< <return></return>
---
> <return> the string associated with the #GQuark.
> </return>
16200a15885
> Since: 2.6
16215d15899
< Since: 2.6
16218a15903,15911
> <function name="only">
> <description>
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
16277,16298d15969
< <function name="GShellError">
< <description>
< Error codes returned by shell functions.
< 
< </description>
< <parameters>
< <parameter name="G_SHELL_ERROR_BAD_QUOTING">
< <parameter_description> Mismatched or otherwise mangled quoting.
< </parameter_description>
< </parameter>
< <parameter name="G_SHELL_ERROR_EMPTY_STRING">
< <parameter_description> String to be parsed was empty.
< </parameter_description>
< </parameter>
< <parameter name="G_SHELL_ERROR_FAILED">
< <parameter_description> Some other error.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
16327a15999
> Since: 2.12
16350d16021
< Since: 2.12
16370,16385d16040
< <function name="GDestroyNotify">
< <description>
< Specifies the type of function which is called when a data element
< is destroyed. It is passed the pointer to the data element and
< should free any memory and resources allocated for it.
< 
< </description>
< <parameters>
< <parameter name="data">
< <parameter_description> the data element.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
16411c16066,16067
< Return value: the number of currently unused threads
---
> Returns the number of currently unused threads.
> 
16537a16194
> Since: 2.8
16557d16213
< Since: 2.8
16577,16580d16232
< <parameter name="Returns">
< <parameter_description> %TRUE if @string matches @pspec
< </parameter_description>
< </parameter>
16582c16234,16235
< <return></return>
---
> <return> %TRUE if @string matches @pspec
> </return>
16672c16325,16332
< Return value: a string owned by GLib that must not be modified 
---
> 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;
> 
> Since: 2.6
16679d16338
< Since: 2.6
16892,16902d16550
< <function name="GQuark">
< <description>
< A GQuark is a non-zero integer which uniquely identifies a
< particular string. A GQuark value of zero is associated to %NULL.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
16941a16590
> Since: 2.8
16957d16605
< Since: 2.8
16989c16637,16648
< Return value: a newly allocated %NULL-terminated string array
---
> 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
17022d16680
< Since: 2.6
17075,17078d16732
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
17080c16734,16735
< <return></return>
---
> <return> the #GArray.
> </return>
17121c16776,16779
< Returns: new head of @list
---
> Returns the new head of the list. Contrast with 
> g_slist_remove() which removes only the first node 
> matching the given data.
> 
17138,17149d16795
< <function name="GIOChannel">
< <description>
< A data structure representing an IO Channel. The fields should be
< considered private and should only be accessed with the following
< functions.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
17226a16873,16882
> <function name="called">
> <description>
> with the @user_data parameter supplied to g_dataset_foreach().
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
17275a16932
> Since: 2.22
17286d16942
< Since: 2.22
17315a16972,16985
> <function name="comes">
> <description>
> @a.
> 
> A #GSequenceIterCompareFunc is a function used to compare iterators.
> It must return zero if the iterators compare equal, a negative value
> if @a comes before @b, and a positive value if @b comes before @a.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
17340,17351d17009
< <function name="GCache">
< <description>
< The #GCache struct is an opaque data structure containing
< information about a #GCache. It should only be accessed via the
< following functions.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
17398a17057,17059
> 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().
17414,17417d17074
< <parameter name="Returns">
< <parameter_description> the records (tuples) that matched.
< </parameter_description>
< </parameter>
17419,17421c17076
< <return>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().
---
> <return> the records (tuples) that matched.
17487,17512d17141
< <function name="GCompareFunc">
< <description>
< Specifies the type of a comparison function used to compare two
< values.  The function should return a negative integer if the first
< value comes before the second, 0 if they are equal, or a positive
< integer if the first value comes after the second.
< 
< </description>
< <parameters>
< <parameter name="a">
< <parameter_description> a value.
< </parameter_description>
< </parameter>
< <parameter name="b">
< <parameter_description> a value to compare with.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> negative value if @a &lt; @b; zero if @a = @b; positive
< value if @a &gt; @b.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
17611a17241
> Since: 2.14
17638d17267
< Since: 2.14
17663a17293,17298
> 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
17673,17678d17307
< 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
17684c17313,17316
< Return value: a #GSequenceIter pointing to the next position after @iter.
---
> Returns an iterator pointing to the next position after @iter. If
> @iter is the end iterator, the end iterator is returned.
> 
> Since: 2.14
17695d17326
< Since: 2.14
17712,17715d17342
< <parameter name="Returns">
< <parameter_description> the new #GPtrArray.
< </parameter_description>
< </parameter>
17717c17344,17345
< <return></return>
---
> <return> the new #GPtrArray.
> </return>
17790a17419
> Since: 2.6
17814d17442
< Since: 2.6
17838c17466,17469
< Return value: an #GSequenceIter pointing to the position where @data
---
> Returns an iterator pointing to the position where @data would
> be inserted according to @cmp_func and @cmp_data.
> 
> Since: 2.14
17866d17496
< Since: 2.14
17870c17500
< <function name="g_cclosure_marshal_VOID__UINT_POINTER">
---
> <function name="g_type_class_unref">
17872,17873c17502,17505
< 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;.
---
> 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.
17877,17916c17509,17510
< <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 name="g_class">
> <parameter_description> The #GTypeClass structure to unreference.
17960,17985d17553
< <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>
< 
18020a17589
> Since: 2.14
18031d17599
< Since: 2.14
18068a17637
> Since: 2.14
18081d17649
< Since: 2.14
18087c17655,17656
< Returns: the invocation hint of the innermost signal emission.
---
> Returns the invocation hint of the innermost signal emission of instance.
> 
18102c17671,17673
< Returns: The corresponding plugin if @type is a dynamic type,
---
> Returns the #GTypePlugin structure for @type or
> %NULL if @type does not have a #GTypePlugin structure.
> 
18156a17728
> Since: 2.6
18176d17747
< Since: 2.6
18233,18268d17803
< <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>
< 
18317a17853
> Since: 2.20
18333d17868
< Since: 2.20
18398a17934
> Since: 2.14
18412d17947
< Since: 2.14
18470a18006
> Since: 2.22
18478d18013
< Since: 2.22
18545a18081
> Since: 2.12
18568d18103
< Since: 2.12
18597,18650d18131
< <function name="GPrivate">
< <description>
< The #GPrivate struct is an opaque data structure to represent a
< thread private data key. Threads can thereby obtain and set a
< pointer which is private to the current thread. Take our
< &lt;function&gt;give_me_next_number(&lt;!-- --&gt;)&lt;/function&gt; example from
< above.  Suppose we don't want &lt;literal&gt;current_number&lt;/literal&gt; to be
< shared between the threads, but instead to be private to each thread.
< This can be done as follows:
< 
< &lt;example&gt;
< &lt;title&gt;Using GPrivate for per-thread data&lt;/title&gt;
< &lt;programlisting&gt;
< GPrivate* current_number_key = NULL; /&lt;!-- --&gt;* Must be initialized somewhere
< with g_private_new (g_free); *&lt;!-- --&gt;/
< 
< int
< give_me_next_number (void)
< {
< int *current_number = g_private_get (current_number_key);
< 
< if (!current_number)
< {
< current_number = g_new (int, 1);
< *current_number = 0;
< g_private_set (current_number_key, current_number);
< }
< 
< *current_number = calc_next_number (*current_number);
< 
< return *current_number;
< }
< &lt;/programlisting&gt;
< &lt;/example&gt;
< 
< Here the pointer belonging to the key
< &lt;literal&gt;current_number_key&lt;/literal&gt; is read. If it is %NULL, it has
< not been set yet. Then get memory for an integer value, assign this
< memory to the pointer and write the pointer back. Now we have an
< integer value that is private to the current thread.
< 
< The #GPrivate struct should only be accessed via the following
< functions.
< 
< &lt;note&gt;&lt;para&gt;All of the &lt;function&gt;g_private_*&lt;/function&gt; functions are
< actually macros. Apart from taking their addresses, you can however
< use them as if they were functions.&lt;/para&gt;&lt;/note&gt;
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
18654a18136
> Since: 2.2
18669d18150
< Since: 2.2
18718a18200,18205
> 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
18728,18733d18214
< 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
18754,18757d18234
< <parameter name="Returns">
< <parameter_description> %TRUE if @string matches @pspec
< </parameter_description>
< </parameter>
18759c18236,18237
< <return></return>
---
> <return> %TRUE if @string matches @pspec
> </return>
18825a18304
> Since: 2.8
18836d18314
< Since: 2.8
18844a18323
> Since: 2.16
18867d18345
< Since: 2.16
18873c18351,18353
< Return value: The number of items in @queue.
---
> Returns the number of items in @queue.
> 
> Since: 2.4
18884d18363
< Since: 2.4
18890,18899c18369
< 
< </description>
< <parameters>
< <parameter name="value">
< <parameter_description> a #GVariant instance
< </parameter_description>
< </parameter>
< </parameters>
< <return> the serialised form of @value, or %NULL
< a pointer to the serialised form of a #GVariant instance.
---
> Returns a pointer to the serialised form of a #GVariant instance.
18915a18386,18394
> 
> </description>
> <parameters>
> <parameter name="value">
> <parameter_description> a #GVariant instance
> </parameter_description>
> </parameter>
> </parameters>
> <return> the serialised form of @value, or %NULL
18934a18414
> Since: 2.2
18950d18429
< Since: 2.2
18953a18433,18445
> <function name="read">
> <description>
> not copy this struct.
> 
> &lt;note&gt;&lt;para&gt;Resources for a joinable thread are not fully released
> until g_thread_join() is called for that thread.&lt;/para&gt;&lt;/note&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
18991,18994d18482
< <parameter name="Returns">
< <parameter_description> %TRUE, if @mutex could be locked.
< </parameter_description>
< </parameter>
18996c18484,18485
< <return></return>
---
> <return> %TRUE, if @mutex could be locked.
> </return>
19024a18514,18523
> <function name="using">
> <description>
> Since: 2.24
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
19038,19041d18536
< <parameter name="Returns">
< <parameter_description> %TRUE, if @lock could be locked for writing.
< </parameter_description>
< </parameter>
19043c18538,18539
< <return></return>
---
> <return> %TRUE, if @lock could be locked for writing.
> </return>
19056,19060d18551
< <parameter name="Returns">
< <parameter_description> the previous element, or %NULL if there are no previous
< elements.
< </parameter_description>
< </parameter>
19062c18553,18555
< <return></return>
---
> <return> the previous element, or %NULL if there are no previous
> elements.
> </return>
19089c18582,18584
< Return value: A random number.
---
> Returns the next random #gdouble from @rand_ equally distributed over
> the range [@begin..@end).
> 
19185c18680
< <function name="GCompletion">
---
> <function name="g_list_index">
19187,19216c18682,18683
< The data structure used for automatic completion.
< 
< </description>
< <parameters>
< <parameter name="items">
< <parameter_description> list of target items (strings or data structures).
< </parameter_description>
< </parameter>
< <parameter name="func">
< <parameter_description> function which is called to get the string associated with a
< target item. It is %NULL if the target items are strings.
< </parameter_description>
< </parameter>
< <parameter name="prefix">
< <parameter_description> the last prefix passed to g_completion_complete() or
< g_completion_complete_utf8().
< </parameter_description>
< </parameter>
< <parameter name="cache">
< <parameter_description> the list of items which begin with @prefix.
< </parameter_description>
< </parameter>
< <parameter name="strncmp_func">
< <parameter_description> The function to use when comparing strings.  Use
< g_completion_set_compare() to modify this function.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
---
> Gets the position of the element containing 
> the given data (starting from 0).
19218,19221d18684
< <function name="GSeekType">
< <description>
< An enumeration specifying the base position for a
< g_io_channel_seek_position() operation.
19225,19234c18688,18689
< <parameter name="G_SEEK_CUR">
< <parameter_description> the current position in the file.
< </parameter_description>
< </parameter>
< <parameter name="G_SEEK_SET">
< <parameter_description> the start of the file.
< </parameter_description>
< </parameter>
< <parameter name="G_SEEK_END">
< <parameter_description> the end of the file.
---
> <parameter name="list">
> <parameter_description> a #GList
19237,19249c18692,18693
< </parameters>
< <return></return>
< </function>
< 
< <function name="GThreadError">
< <description>
< Possible errors of thread related functions.
< 
< </description>
< <parameters>
< <parameter name="G_THREAD_ERROR_AGAIN">
< <parameter_description> a thread couldn't be created due to resource
< shortage. Try again later.
---
> <parameter name="data">
> <parameter_description> the data to find
19253,19266c18697,18699
< <return></return>
< </function>
< 
< <function name="GParamSpecPool">
< <description>
< A #GParamSpecPool maintains a collection of #GParamSpec&lt;!-- --&gt;s which can be
< quickly accessed by owner and name. The implementation of the #GObject property
< system uses such a pool to store the #GParamSpecs of the properties all object
< types.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
---
> <return> the index of the element containing the data, 
> or -1 if the data is not found
> </return>
19451a18885
> Since: 2.6
19478d18911
< Since: 2.6
19506a18940
> Since: 2.16
19517d18950
< Since: 2.16
19757a19191
> Since: 2.14
19777d19210
< Since: 2.14
19784a19218
> Since: 2.12
19801d19234
< Since: 2.12
19807c19240,19281
< Return value: whether a test was %TRUE
---
> 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.
> 
19953a19428,19442
> <function name="of">
> <description>
> linkend=&quot;glib-Type-Conversion-Macros&quot;&gt;Type Conversion
> Macros&lt;/link&gt;.
> @next: contains the link to the next element in the list.
> @prev: contains the link to the previous element in the list.
> 
> The #GList struct is used for each element in a doubly-linked list.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
19971,19991d19459
< <function name="Check">
< <description>
< The first check comes from the Unicode guarantee to never encode
< a point above 0x0010ffff, since UTF-16 couldn't represent it.
< 
< The second check covers surrogate pairs (category Cs).
< 
< The last two checks cover &quot;Noncharacter&quot;: defined as:
< &quot;A code point that is permanently reserved for
< internal use, and that should never be interchanged. In
< Unicode 3.1, these consist of the values U+nFFFE and U+nFFFF
< (where n is from 0 to 10_16) and the values U+FDD0..U+FDEF.&quot;
< 
< @param Char the character
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
20063c19531,19532
< Creates a new #GCache.
---
> (&lt;emphasis&gt;not&lt;/emphasis&gt; a value as the prototype implies) and
> should return a duplicate of the key.
20067,20108d19535
< <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>
< <parameter name="Returns">
< <parameter_description> a new #GCache.
< </parameter_description>
< </parameter>
20174a19602
> Since: 2.6
20186d19613
< Since: 2.6
20206a19634
> Since: 2.6
20228d19655
< Since: 2.6
20234c19661,19664
< Returns: ISO 8601 week number of the year.
---
> Returns the week of the year, where weeks are interpreted according
> to ISO 8601. 
> 
> Since: 2.6
20245d19674
< Since: 2.6
20324,20327d19752
< <parameter name="Returns">
< <parameter_description> the new #GArray.
< </parameter_description>
< </parameter>
20329c19754,19755
< <return></return>
---
> <return> the new #GArray.
> </return>
20394c19820
< <function name="GTimer">
---
> <function name="with">
20396c19822,19850
< Opaque datatype that records a start time.
---
> compiled against a thread-disabled GLib, saving code and memory
> there. #G_LOCK_DEFINE defines a lock. It can appear anywhere
> variable definitions may appear in programs, i.e. in the first block
> of a function or outside of functions. The @name parameter will be
> mangled to get the name of the #GStaticMutex. This means that you
> can use names of existing variables as the parameter - e.g. the name
> of the variable you intent to protect with the lock. Look at our
> &lt;function&gt;give_me_next_number()&lt;/function&gt; example using the
> %G_LOCK_* macros:
> 
> &lt;example&gt;
> &lt;title&gt;Using the %G_LOCK_* convenience macros&lt;/title&gt;
> &lt;programlisting&gt;
> G_LOCK_DEFINE (current_number);
> 
> int
> give_me_next_number (void)
> {
> static int current_number = 0;
> int ret_val;
> 
> G_LOCK (current_number);
> ret_val = current_number = calc_next_number (current_number);
> G_UNLOCK (current_number);
> 
> return ret_val;
> }
> &lt;/programlisting&gt;
> &lt;/example&gt;
20416a19871
> Since: 2.12
20427d19881
< Since: 2.12
20446a19901
> Since: 2.18
20457d19911
< Since: 2.18
20464a19919
> Since: 2.16
20475d19929
< Since: 2.16
20575c20029,20031
< Returns: %TRUE if g_value_copy() is possible with @src_type and @dest_type.
---
> Returns whether a #GValue of type @src_type can be copied into
> a #GValue of type @dest_type.
> 
20689a20146
> Since: 2.16
20704d20160
< Since: 2.16
20792,20795d20247
< <parameter name="Returns">
< <parameter_description> the #GByteArray.
< </parameter_description>
< </parameter>
20797c20249,20250
< <return></return>
---
> <return> the #GByteArray.
> </return>
20802c20255,20264
< Return value: a newly allocated string or %NULL if the specified 
---
> 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
20826d20287
< Since: 2.6
20830,20871d20290
< <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>
< 
20907,20910d20325
< <parameter name="Returns">
< <parameter_description> a newly-allocated #GPatternSpec
< </parameter_description>
< </parameter>
20912c20327,20328
< <return></return>
---
> <return> a newly-allocated #GPatternSpec
> </return>
20976a20393
> Since: 2.14
20991d20407
< Since: 2.14
21032c20448
< <function name="g_io_channel_win32_new_socket">
---
> <function name="g_direct_hash">
21034,21037c20450,20452
< 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.
---
> 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.
21039,21041d20453
< 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.
21045,21050c20457,20458
< <parameter name="socket">
< <parameter_description> a Winsock socket
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> a new #GIOChannel
---
> <parameter name="v">
> <parameter_description> a #gpointer key
21054c20462,20463
< <return></return>
---
> <return> a hash value corresponding to the key.
> </return>
21057c20466
< <function name="GMarkupCollectType">
---
> <function name="g_bookmark_file_get_visited">
21059,21062c20468
< A mixed enumerated type and flags field.  You must specify one type
< (string, strdup, boolean, tristate).  Additionally, you may
< optionally bitwise OR the type with the flag
< %G_MARKUP_COLLECT_OPTIONAL.
---
> Gets the time the bookmark for @uri was last visited.
21064,21065c20470,20473
< It is likely that this enum will be extended in the future to
< support other types.
---
> 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
21069,21097c20477,20478
< <parameter name="G_MARKUP_COLLECT_INVALID">
< <parameter_description> used to terminate the list of attributes
< to collect.
< </parameter_description>
< </parameter>
< <parameter name="G_MARKUP_COLLECT_STRING">
< <parameter_description> collect the string pointer directly from
< the attribute_values[] array.  Expects a
< parameter of type (const char **).  If
< %G_MARKUP_COLLECT_OPTIONAL is specified
< and the attribute isn't present then the
< pointer will be set to %NULL.
< </parameter_description>
< </parameter>
< <parameter name="G_MARKUP_COLLECT_STRDUP">
< <parameter_description> as with %G_MARKUP_COLLECT_STRING, but
< expects a parameter of type (char **) and
< g_strdup()s the returned pointer.  The
< pointer must be freed with g_free().
< </parameter_description>
< </parameter>
< <parameter name="G_MARKUP_COLLECT_BOOLEAN">
< <parameter_description> expects a parameter of type (gboolean *)
< and parses the attribute value as a
< boolean.  Sets %FALSE if the attribute
< isn't present.  Valid boolean values
< consist of (case insensitive) &quot;false&quot;,
< &quot;f&quot;, &quot;no&quot;, &quot;n&quot;, &quot;0&quot; and &quot;true&quot;, &quot;t&quot;,
< &quot;yes&quot;, &quot;y&quot;, &quot;1&quot;.
---
> <parameter name="bookmark">
> <parameter_description> a #GBookmarkFile
21100,21105c20481,20482
< <parameter name="G_MARKUP_COLLECT_TRISTATE">
< <parameter_description> as with %G_MARKUP_COLLECT_BOOLEAN, but
< in the case of a missing attribute a
< value is set that compares equal to
< neither %FALSE nor %TRUE.
< G_MARKUP_COLLECT_OPTIONAL is implied.
---
> <parameter name="uri">
> <parameter_description> a valid URI
21108,21139c20485,20486
< <parameter name="G_MARKUP_COLLECT_OPTIONAL">
< <parameter_description> can be bitwise ORed with the other
< fields.  If present, allows the
< attribute not to appear.  A default
< value is set depending on what value
< type is used.
< </parameter_description>
< </parameter>
< </parameters>
< <return></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.
< 
< 
< </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 name="error">
> <parameter_description> return location for a #GError, or %NULL
21145d20491
< Since: 2.12
21182,21185d20527
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
21187c20529,20530
< <return></return>
---
> <return> the #GArray.
> </return>
21267,21302d20609
< <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>
< 
21337a20645
> Since: 2.14
21348d20655
< Since: 2.14
21399,21438c20706
< <function name="GTraverseFlags">
< <description>
< Specifies which nodes are visited during several of the tree
< functions, including g_node_traverse() and g_node_find().
< 
< </description>
< <parameters>
< <parameter name="G_TRAVERSE_LEAVES">
< <parameter_description> only leaf nodes should be visited. This name has
< been introduced in 2.6, for older version use
< %G_TRAVERSE_LEAFS.
< </parameter_description>
< </parameter>
< <parameter name="G_TRAVERSE_NON_LEAVES">
< <parameter_description> only non-leaf nodes should be visited. This
< name has been introduced in 2.6, for older
< version use %G_TRAVERSE_NON_LEAFS.
< </parameter_description>
< </parameter>
< <parameter name="G_TRAVERSE_ALL">
< <parameter_description> all nodes should be visited.
< </parameter_description>
< </parameter>
< <parameter name="G_TRAVERSE_MASK">
< <parameter_description> a mask of all traverse flags.
< </parameter_description>
< </parameter>
< <parameter name="G_TRAVERSE_LEAFS">
< <parameter_description> identical to %G_TRAVERSE_LEAVES.
< </parameter_description>
< </parameter>
< <parameter name="G_TRAVERSE_NON_LEAFS">
< <parameter_description> identical to %G_TRAVERSE_NON_LEAVES.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
< <function name="g_param_values_cmp">
---
> <function name="children">
21440,21442c20708
< 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.
---
> child.
21443a20710,20711
> The #GNode struct represents one node in a
> &lt;link linkend=&quot;glib-N-ary-Trees&quot;&gt;N-ary Tree&lt;/link&gt;. fields
21447,21458d20714
< <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>
21460,21461c20716
< <return> -1, 0 or +1, for a less than, equal to or greater than result
< </return>
---
> <return></return>
21519a20775,20793
> <function name="to">
> <description>
> A #GCache allows sharing of complex data structures, in order to
> save system resources.
> 
> GTK+ uses caches for #GtkStyles and #GdkGCs. These consume a lot of
> resources, so a #GCache is used to see if a #GtkStyle or #GdkGC with
> the required properties already exists. If it does, then the
> existing object is used instead of creating a new one.
> 
> #GCache uses keys and values. A #GCache key describes the properties
> of a particular resource. A #GCache value is the actual resource.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
21540c20814,20817
< Returns: a newly-allocated zero-terminated array of #GType containing
---
> Returns the prerequisites of an interfaces type.
> 
> Since: 2.2
> 
21595a20873
> Since: 2.22
21618d20895
< Since: 2.22
21761a21039
> Since: 2.18
21781d21058
< Since: 2.18
21787c21064,21071
< Return value: a %NULL-terminated array of strings owned by GLib that must 
---
> 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;
> 
> Since: 2.6
21794d21077
< Since: 2.6
21797a21081,21146
> <function name="condition">
> <description>
> condition to be false. If other threads change the state of this
> condition they signal the #GCond, and that causes the waiting
> threads to be woken up.
> 
> &lt;example&gt;
> &lt;title&gt;
> Using GCond to block a thread until a condition is satisfied
> &lt;/title&gt;
> &lt;programlisting&gt;
> GCond* data_cond = NULL; /&lt;!-- --&gt;* Must be initialized somewhere *&lt;!-- --&gt;/
> GMutex* data_mutex = NULL; /&lt;!-- --&gt;* Must be initialized somewhere *&lt;!-- --&gt;/
> gpointer current_data = NULL;
> 
> void
> push_data (gpointer data)
> {
> g_mutex_lock (data_mutex);
> current_data = data;
> g_cond_signal (data_cond);
> g_mutex_unlock (data_mutex);
> }
> 
> gpointer
> pop_data (void)
> {
> gpointer data;
> 
> g_mutex_lock (data_mutex);
> while (!current_data)
> g_cond_wait (data_cond, data_mutex);
> data = current_data;
> current_data = NULL;
> g_mutex_unlock (data_mutex);
> 
> return data;
> }
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> Whenever a thread calls &lt;function&gt;pop_data()&lt;/function&gt; now, it will
> wait until current_data is non-%NULL, i.e. until some other thread
> has called &lt;function&gt;push_data()&lt;/function&gt;.
> 
> &lt;note&gt;&lt;para&gt;It is important to use the g_cond_wait() and
> g_cond_timed_wait() functions only inside a loop which checks for the
> condition to be true.  It is not guaranteed that the waiting thread
> will find the condition fulfilled after it wakes up, even if the
> signaling thread left the condition in that state: another thread may
> have altered the condition before the waiting thread got the chance
> to be woken up, even if the condition itself is protected by a
> #GMutex, like above.&lt;/para&gt;&lt;/note&gt;
> 
> A #GCond should only be accessed via the following functions.
> 
> &lt;note&gt;&lt;para&gt;All of the &lt;function&gt;g_cond_*&lt;/function&gt; functions are
> actually macros. Apart from taking their addresses, you can however
> use them as if they were functions.&lt;/para&gt;&lt;/note&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
21899a21249,21698
> <function name="large">
> <description>
> lifting of restrictions.  The &lt;ulink
> url='http://dbus.freedesktop.org/doc/dbus-specification.html'&gt;DBus
> specification&lt;/ulink&gt;, therefore, provides a significant amount of
> information that is useful when working with GVariant.
> 
> The first major change with respect to the DBus type system is the
> introduction of maybe (or &quot;nullable&quot;) types.  Any type in GVariant can be
> converted to a maybe type, in which case, &quot;nothing&quot; (or &quot;null&quot;) becomes a
> valid value.  Maybe types have been added by introducing the
> character &quot;&lt;literal&gt;m&lt;/literal&gt;&quot; to type strings.
> 
> The second major change is that the GVariant type system supports the
> concept of &quot;indefinite types&quot; -- types that are less specific than
> the normal types found in DBus.  For example, it is possible to speak
> of &quot;an array of any type&quot; in GVariant, where the DBus type system
> would require you to speak of &quot;an array of integers&quot; or &quot;an array of
> strings&quot;.  Indefinite types have been added by introducing the
> characters &quot;&lt;literal&gt;*&lt;/literal&gt;&quot;, &quot;&lt;literal&gt;?&lt;/literal&gt;&quot; and
> &quot;&lt;literal&gt;r&lt;/literal&gt;&quot; to type strings.
> 
> Finally, all arbitrary restrictions relating to the complexity of
> types are lifted along with the restriction that dictionary entries
> may only appear nested inside of arrays.
> 
> Just as in DBus, GVariant types are described with strings (&quot;type
> strings&quot;).  Subject to the differences mentioned above, these strings
> are of the same form as those found in DBus.  Note, however: DBus
> always works in terms of messages and therefore individual type
> strings appear nowhere in its interface.  Instead, &quot;signatures&quot;
> are a concatenation of the strings of the type of each argument in a
> message.  GVariant deals with single values directly so GVariant type
> strings always describe the type of exactly one value.  This means
> that a DBus signature string is generally not a valid GVariant type
> string -- except in the case that it is the signature of a message
> containing exactly one argument.
> 
> An indefinite type is similar in spirit to what may be called an
> abstract type in other type systems.  No value can exist that has an
> indefinite type as its type, but values can exist that have types
> that are subtypes of indefinite types.  That is to say,
> g_variant_get_type() will never return an indefinite type, but
> calling g_variant_is_a() with an indefinite type may return %TRUE.
> For example, you can not have a value that represents &quot;an array of no
> particular type&quot;, but you can have an &quot;array of integers&quot; which
> certainly matches the type of &quot;an array of no particular type&quot;, since
> &quot;array of integers&quot; is a subtype of &quot;array of no particular type&quot;.
> 
> This is similar to how instances of abstract classes may not
> directly exist in other type systems, but instances of their
> non-abstract subtypes may.  For example, in GTK, no object that has
> the type of #GtkBin can exist (since #GtkBin is an abstract class),
> but a #GtkWindow can certainly be instantiated, and you would say
> that the #GtkWindow is a #GtkBin (since #GtkWindow is a subclass of
> #GtkBin).
> 
> A detailed description of GVariant type strings is given here:
> 
> &lt;refsect2 id='gvariant-typestrings'&gt;
> &lt;title&gt;GVariant Type Strings&lt;/title&gt;
> &lt;para&gt;
> A GVariant type string can be any of the following:
> &lt;/para&gt;
> &lt;itemizedlist&gt;
> &lt;listitem&gt;
> &lt;para&gt;
> any basic type string (listed below)
> &lt;/para&gt;
> &lt;/listitem&gt;
> &lt;listitem&gt;
> &lt;para&gt;
> &quot;&lt;literal&gt;v&lt;/literal&gt;&quot;, &quot;&lt;literal&gt;r&lt;/literal&gt;&quot; or
> &quot;&lt;literal&gt;*&lt;/literal&gt;&quot;
> &lt;/para&gt;
> &lt;/listitem&gt;
> &lt;listitem&gt;
> &lt;para&gt;
> one of the characters '&lt;literal&gt;a&lt;/literal&gt;' or
> '&lt;literal&gt;m&lt;/literal&gt;', followed by another type string
> &lt;/para&gt;
> &lt;/listitem&gt;
> &lt;listitem&gt;
> &lt;para&gt;
> the character '&lt;literal&gt;(&lt;/literal&gt;', followed by a concatenation
> of zero or more other type strings, followed by the character
> '&lt;literal&gt;)&lt;/literal&gt;'
> &lt;/para&gt;
> &lt;/listitem&gt;
> &lt;listitem&gt;
> &lt;para&gt;
> the character '&lt;literal&gt;{&lt;/literal&gt;', followed by a basic type
> string (see below), followed by another type string, followed by
> the character '&lt;literal&gt;}&lt;/literal&gt;'
> &lt;/para&gt;
> &lt;/listitem&gt;
> &lt;/itemizedlist&gt;
> &lt;para&gt;
> A basic type string describes a basic type (as per
> g_variant_type_is_basic()) and is always a single
> character in length.  The valid basic type strings are
> &quot;&lt;literal&gt;b&lt;/literal&gt;&quot;, &quot;&lt;literal&gt;y&lt;/literal&gt;&quot;,
> &quot;&lt;literal&gt;n&lt;/literal&gt;&quot;, &quot;&lt;literal&gt;q&lt;/literal&gt;&quot;,
> &quot;&lt;literal&gt;i&lt;/literal&gt;&quot;, &quot;&lt;literal&gt;u&lt;/literal&gt;&quot;,
> &quot;&lt;literal&gt;x&lt;/literal&gt;&quot;, &quot;&lt;literal&gt;t&lt;/literal&gt;&quot;,
> &quot;&lt;literal&gt;h&lt;/literal&gt;&quot;, &quot;&lt;literal&gt;d&lt;/literal&gt;&quot;,
> &quot;&lt;literal&gt;s&lt;/literal&gt;&quot;, &quot;&lt;literal&gt;o&lt;/literal&gt;&quot;,
> &quot;&lt;literal&gt;g&lt;/literal&gt;&quot; and &quot;&lt;literal&gt;?&lt;/literal&gt;&quot;.
> &lt;/para&gt;
> &lt;para&gt;
> The above definition is recursive to arbitrary depth.
> &quot;&lt;literal&gt;aaaaai&lt;/literal&gt;&quot; and &quot;&lt;literal&gt;(ui(nq((y)))s)&lt;/literal&gt;&quot;
> are both valid type strings, as is
> &quot;&lt;literal&gt;a(aa(ui)(qna{ya(yd)}))&lt;/literal&gt;&quot;.
> &lt;/para&gt;
> &lt;para&gt;
> The meaning of each of the characters is as follows:
> &lt;/para&gt;
> &lt;informaltable&gt;
> &lt;tgroup cols='2'&gt;
> &lt;tbody&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;emphasis role='strong'&gt;Character&lt;/emphasis&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;emphasis role='strong'&gt;Meaning&lt;/emphasis&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;b&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_BOOLEAN; a boolean value.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;y&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_BYTE; a byte.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;n&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_INT16; a signed 16 bit
> integer.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;q&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_UINT16; an unsigned 16 bit
> integer.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;i&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_INT32; a signed 32 bit
> integer.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;u&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_UINT32; an unsigned 32 bit
> integer.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;x&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_INT64; a signed 64 bit
> integer.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;t&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_UINT64; an unsigned 64 bit
> integer.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;h&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_HANDLE; a signed 32 bit
> value that, by convention, is used as an index into an array
> of file descriptors that are sent alongside a DBus message.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;d&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_DOUBLE; a double precision
> floating point value.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;s&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_STRING; a string.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;o&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_OBJECT_PATH; a string in
> the form of a DBus object path.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;g&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_STRING; a string in the
> form of a DBus type signature.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;?&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_BASIC; an indefinite type
> that is a supertype of any of the basic types.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;v&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_VARIANT; a container type
> that contain any other type of value.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;a&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> used as a prefix on another type string to mean an array of
> that type; the type string &quot;&lt;literal&gt;ai&lt;/literal&gt;&quot;, for
> example, is the type of an array of 32 bit signed integers.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;m&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> used as a prefix on another type string to mean a &quot;maybe&quot;, or
> &quot;nullable&quot;, version of that type; the type string
> &quot;&lt;literal&gt;ms&lt;/literal&gt;&quot;, for example, is the type of a value
> that maybe contains a string, or maybe contains nothing.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;()&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> used to enclose zero or more other concatenated type strings
> to create a tuple type; the type string
> &quot;&lt;literal&gt;(is)&lt;/literal&gt;&quot;, for example, is the type of a pair
> of an integer and a string.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;r&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_TUPLE; an indefinite type
> that is a supertype of any tuple type, regardless of the
> number of items.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;{}&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> used to enclose a basic type string concatenated with another
> type string to create a dictionary entry type, which usually
> appears inside of an array to form a dictionary; the type
> string &quot;&lt;literal&gt;a{sd}&lt;/literal&gt;&quot;, for example, is the type of
> a dictionary that maps strings to double precision floating
> point values.
> &lt;/para&gt;
> &lt;para&gt;
> The first type (the basic type) is the key type and the second
> type is the value type.  The reason that the first type is
> restricted to being a basic type is so that it can easily be
> hashed.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;row&gt;
> &lt;entry&gt;
> &lt;para&gt;
> &lt;literal&gt;*&lt;/literal&gt;
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;entry&gt;
> &lt;para&gt;
> the type string of %G_VARIANT_TYPE_ANY; the indefinite type
> that is a supertype of all types.  Note that, as with all type
> strings, this character represents exactly one type.  It
> cannot be used inside of tuples to mean &quot;any number of items&quot;.
> &lt;/para&gt;
> &lt;/entry&gt;
> &lt;/row&gt;
> &lt;/tbody&gt;
> &lt;/tgroup&gt;
> &lt;/informaltable&gt;
> &lt;para&gt;
> Any type string of a container that contains an indefinite type is,
> itself, an indefinite type.  For example, the type string
> &quot;&lt;literal&gt;a*&lt;/literal&gt;&quot; (corresponding to %G_VARIANT_TYPE_ARRAY) is
> an indefinite type that is a supertype of every array type.
> &quot;&lt;literal&gt;(*s)&lt;/literal&gt;&quot; is a supertype of all tuples that
> contain exactly two items where the second item is a string.
> &lt;/para&gt;
> &lt;para&gt;
> &quot;&lt;literal&gt;a{?*}&lt;/literal&gt;&quot; is an indefinite type that is a
> supertype of all arrays containing dictionary entries where the key
> is any basic type and the value is any type at all.  This is, by
> definition, a dictionary, so this type string corresponds to
> %G_VARIANT_TYPE_DICTIONARY.  Note that, due to the restriction that
> the key of a dictionary entry must be a basic type,
> &quot;&lt;literal&gt;{**}&lt;/literal&gt;&quot; is not a valid type string.
> &lt;/para&gt;
> &lt;/refsect2&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
21956a21756,21767
> <function name="small">
> <description>
> data structures. Since 2.10, it has been completely replaced by the
> &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice allocator&lt;/link&gt; and
> deprecated.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
21959c21770,21778
< Return value: the values associated with the key as a list of
---
> 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
21987d21805
< Since: 2.6
22097,22100d21914
< <parameter name="Returns">
< <parameter_description> %TRUE if @cond was signalled, or %FALSE on timeout.
< </parameter_description>
< </parameter>
22102,22120c21916,21917
< <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>
---
> <return> %TRUE if @cond was signalled, or %FALSE on timeout.
> </return>
22207a22005,22006
> Returns a random #gboolean from @rand_. This corresponds to a
> unbiased coin toss.
22215,22218d22013
< <parameter name="Returns">
< <parameter_description> a random #gboolean.
< </parameter_description>
< </parameter>
22220,22221c22015
< <return>a random #gboolean from @rand_. This corresponds to a
< unbiased coin toss.
---
> <return> a random #gboolean.
22264c22058,22060
< Return value: the #GSequence that @iter points into.
---
> Returns the #GSequence that @iter points into.
> 
> Since: 2.14
22275d22070
< Since: 2.14
22281c22076,22078
< Return value: the #GHashTable associated with @iter.
---
> Returns the #GHashTable associated with @iter.
> 
> Since: 2.16
22292d22088
< Since: 2.16
22295a22092,22101
> <function name="public">
> <description>
> you must not copy this struct.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
22298c22104,22112
< Return value: the value associated with the key as a double, or
---
> 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
22322d22135
< Since: 2.12
22331a22145
> Since: 2.22
22343d22156
< Since: 2.22
22347,22382d22159
< <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>
< 
22399,22402d22175
< <parameter name="Returns">
< <parameter_description> the new #GByteArray.
< </parameter_description>
< </parameter>
22404c22177,22178
< <return></return>
---
> <return> the new #GByteArray.
> </return>
22408a22183,22187
> 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
22418,22422d22196
< 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
22462,22523d22235
< <function name="GCompareDataFunc">
< <description>
< Specifies the type of a comparison function used to compare two
< values.  The function should return a negative integer if the first
< value comes before the second, 0 if they are equal, or a positive
< integer if the first value comes after the second.
< 
< </description>
< <parameters>
< <parameter name="a">
< <parameter_description> a value.
< </parameter_description>
< </parameter>
< <parameter name="b">
< <parameter_description> a value to compare with.
< </parameter_description>
< </parameter>
< <parameter name="user_data">
< <parameter_description> user data to pass to comparison function.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> negative value if @a &lt; @b; zero if @a = @b; positive
< value if @a &gt; @b.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
< <function name="GFunc">
< <description>
< Specifies the type of functions passed to g_list_foreach() and
< g_slist_foreach().
< 
< </description>
< <parameters>
< <parameter name="data">
< <parameter_description> the element's data.
< </parameter_description>
< </parameter>
< <parameter name="user_data">
< <parameter_description> user data passed to g_list_foreach() or
< g_slist_foreach().
< </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>
< 
22546c22258
< <function name="GPtrArray">
---
> <function name="g_param_spec_int64">
22548c22260
< Contains the public fields of a pointer array.
---
> Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
22550,22563c22262
< </description>
< <parameters>
< <parameter name="pdata">
< <parameter_description> points to the array of pointers, which may be moved when the
< array grows.
< </parameter_description>
< </parameter>
< <parameter name="len">
< <parameter_description> number of pointers in the array.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
---
> See g_param_spec_internal() for details on property names.
22565,22568d22263
< <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;.
22572,22573c22267,22268
< <parameter name="closure">
< <parameter_description> the #GClosure to which the marshaller belongs
---
> <parameter name="name">
> <parameter_description> canonical name of the property specified
22576,22577c22271,22272
< <parameter name="return_value">
< <parameter_description> ignored
---
> <parameter name="nick">
> <parameter_description> nick name for the property specified
22580,22581c22275,22276
< <parameter name="n_param_values">
< <parameter_description> 2
---
> <parameter name="blurb">
> <parameter_description> description of the property specified
22584,22585c22279,22280
< <parameter name="param_values">
< <parameter_description> a #GValue array holding the instance and the #GObject* parameter
---
> <parameter name="minimum">
> <parameter_description> minimum value for the property specified
22588,22590c22283,22284
< <parameter name="invocation_hint">
< <parameter_description> the invocation hint given as the last argument
< to g_closure_invoke()
---
> <parameter name="maximum">
> <parameter_description> maximum value for the property specified
22593,22594c22287,22292
< <parameter name="marshal_data">
< <parameter_description> additional data specified when registering the marshaller
---
> <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
22598c22296,22297
< <return></return>
---
> <return> a newly created parameter specification
> </return>
22700c22399
< <function name="g_variant_new_byte">
---
> <function name="chunks">
22702c22401,22433
< Creates a new byte #GVariant instance.
---
> Memory chunks provide an space-efficient way to allocate equal-sized
> pieces of memory, called atoms. However, due to the administrative
> overhead (in particular for #G_ALLOC_AND_FREE, and when used from
> multiple threads), they are in practise often slower than direct use
> of g_malloc(). Therefore, memory chunks have been deprecated in
> favor of the &lt;link linkend=&quot;glib-Memory-Slices&quot;&gt;slice
> allocator&lt;/link&gt;, which has been added in 2.10. All internal uses of
> memory chunks in GLib have been converted to the
> &lt;literal&gt;g_slice&lt;/literal&gt; API.
> 
> There are two types of memory chunks, #G_ALLOC_ONLY, and
> #G_ALLOC_AND_FREE. &lt;itemizedlist&gt; &lt;listitem&gt;&lt;para&gt; #G_ALLOC_ONLY
> chunks only allow allocation of atoms. The atoms can never be freed
> individually. The memory chunk can only be free in its entirety.
> &lt;/para&gt;&lt;/listitem&gt; &lt;listitem&gt;&lt;para&gt; #G_ALLOC_AND_FREE chunks do
> allow atoms to be freed individually. The disadvantage of this is
> that the memory chunk has to keep track of which atoms have been
> freed. This results in more memory being used and a slight
> degradation in performance. &lt;/para&gt;&lt;/listitem&gt; &lt;/itemizedlist&gt;
> 
> To create a memory chunk use g_mem_chunk_new() or the convenience
> macro g_mem_chunk_create().
> 
> To allocate a new atom use g_mem_chunk_alloc(),
> g_mem_chunk_alloc0(), or the convenience macros g_chunk_new() or
> g_chunk_new0().
> 
> To free an atom use g_mem_chunk_free(), or the convenience macro
> g_chunk_free(). (Atoms can only be freed if the memory chunk is
> created with the type set to #G_ALLOC_AND_FREE.)
> 
> To free any blocks of memory which are no longer being used, use
> g_mem_chunk_clean(). To clean all memory chunks, use g_blow_chunks().
22704c22435,22496
< Since: 2.24
---
> To reset the memory chunk, freeing all of the atoms, use
> g_mem_chunk_reset().
> 
> To destroy a memory chunk, use g_mem_chunk_destroy().
> 
> To help debug memory chunks, use g_mem_chunk_info() and
> g_mem_chunk_print().
> 
> &lt;example&gt;
> &lt;title&gt;Using a #GMemChunk&lt;/title&gt;
> &lt;programlisting&gt;
> GMemChunk *mem_chunk;
> gchar *mem[10000];
> gint i;
> 
> /&lt;!-- --&gt;* Create a GMemChunk with atoms 50 bytes long, and memory
> blocks holding 100 bytes. Note that this means that only 2 atoms
> fit into each memory block and so isn't very efficient. *&lt;!-- --&gt;/
> mem_chunk = g_mem_chunk_new (&quot;test mem chunk&quot;, 50, 100, G_ALLOC_AND_FREE);
> /&lt;!-- --&gt;* Now allocate 10000 atoms. *&lt;!-- --&gt;/
> for (i = 0; i &lt; 10000; i++)
> {
> mem[i] = g_chunk_new (gchar, mem_chunk);
> /&lt;!-- --&gt;* Fill in the atom memory with some junk. *&lt;!-- --&gt;/
> for (j = 0; j &lt; 50; j++)
> mem[i][j] = i * j;
> }
> /&lt;!-- --&gt;* Now free all of the atoms. Note that since we are going to
> destroy the GMemChunk, this wouldn't normally be used. *&lt;!-- --&gt;/
> for (i = 0; i &lt; 10000; i++)
> {
> g_mem_chunk_free (mem_chunk, mem[i]);
> }
> /&lt;!-- --&gt;* We are finished with the GMemChunk, so we destroy it. *&lt;!-- --&gt;/
> g_mem_chunk_destroy (mem_chunk);
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> &lt;example&gt;
> &lt;title&gt;Using a #GMemChunk with data structures&lt;/title&gt;
> &lt;programlisting&gt;
> GMemChunk *array_mem_chunk;
> GRealArray *array;
> /&lt;!-- --&gt;* Create a GMemChunk to hold GRealArray structures, using
> the g_mem_chunk_create(&lt;!-- --&gt;) convenience macro. We want 1024 atoms in each
> memory block, and we want to be able to free individual atoms. *&lt;!-- --&gt;/
> array_mem_chunk = g_mem_chunk_create (GRealArray, 1024, G_ALLOC_AND_FREE);
> /&lt;!-- --&gt;* Allocate one atom, using the g_chunk_new(&lt;!-- --&gt;) convenience macro. *&lt;!-- --&gt;/
> array = g_chunk_new (GRealArray, array_mem_chunk);
> /&lt;!-- --&gt;* We can now use array just like a normal pointer to a structure. *&lt;!-- --&gt;/
> array-&gt;data            = NULL;
> array-&gt;len             = 0;
> array-&gt;alloc           = 0;
> array-&gt;zero_terminated = (zero_terminated ? 1 : 0);
> array-&gt;clear           = (clear ? 1 : 0);
> array-&gt;elt_size        = elt_size;
> /&lt;!-- --&gt;* We can free the element, so it can be reused. *&lt;!-- --&gt;/
> g_chunk_free (array, array_mem_chunk);
> /&lt;!-- --&gt;* We destroy the GMemChunk when we are finished with it. *&lt;!-- --&gt;/
> g_mem_chunk_destroy (array_mem_chunk);
> &lt;/programlisting&gt;
> &lt;/example&gt;
22708,22711d22499
< <parameter name="byte">
< <parameter_description> a #guint8 value
< </parameter_description>
< </parameter>
22713,22714c22501
< <return> a new byte #GVariant instance
< </return>
---
> <return></return>
22717c22504
< <function name="G_LOCK_EXTERN">
---
> <function name="g_variant_new_byte">
22719,22720c22506,22508
< This declares a lock, that is defined with #G_LOCK_DEFINE in another
< module.
---
> Creates a new byte #GVariant instance.
> 
> Since: 2.24
22724,22725c22512,22513
< <parameter name="name">
< <parameter_description> the name of the lock.
---
> <parameter name="byte">
> <parameter_description> a #guint8 value
22729c22517,22518
< <return></return>
---
> <return> a new byte #GVariant instance
> </return>
22743,22780d22531
< <parameter name="Returns">
< <parameter_description> %TRUE, if the thread system is initialized.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
< <function name="GObject">
< <description>
< The notify signal is emitted on an object when one of its
< properties has been changed. Note that getting this signal
< doesn't guarantee that the value of the property has actually
< changed, it may also be emitted when the setter for the property
< is called to reinstate the previous value.
< 
< This signal is typically used to obtain change notification for a
< single property, by specifying the property name as a detail in the
< g_signal_connect() call, like this:
< |[
< g_signal_connect (text_view-&gt;buffer, &quot;notify::paste-target-list&quot;,
< G_CALLBACK (gtk_text_view_target_list_notify),
< text_view)
< ]|
< It is important to note that you must use
< &lt;link linkend=&quot;canonical-parameter-name&quot;&gt;canonical&lt;/link&gt; parameter names as
< detail strings for the notify signal.
< 
< </description>
< <parameters>
< <parameter name="gobject">
< <parameter_description> the object which received the signal.
< </parameter_description>
< </parameter>
< <parameter name="pspec">
< <parameter_description> the #GParamSpec of the property which changed.
< </parameter_description>
< </parameter>
22782c22533,22534
< <return></return>
---
> <return> %TRUE, if the thread system is initialized.
> </return>
22832c22584,22590
< Return value: the ID (greater than 0) of the event source.
---
> 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.
> 
22890,22925d22647
< <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>
< 
22990,22995d22711
< 
< </description>
< <parameters>
< </parameters>
< <return> an empty #GKeyFile.
< 
22997,23005d22712
< </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.
< 
23009,23028d22715
< <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>
23030,23031c22717
< <return> a #GSequenceIter pointing to the position in @seq
< where @data would have been inserted according to @iter_cmp and @cmp_data.
---
> <return> an empty #GKeyFile.
23033d22718
< Since: 2.14
23037c22722
< <function name="g_main_context_unref">
---
> <function name="particular">
23039,23040d22723
< Decreases the reference count on a #GMainContext object by one. If
< the result is zero, free the context and free all associated memory.
23044,23047d22726
< <parameter name="context">
< <parameter_description> a #GMainContext
< </parameter_description>
< </parameter>
23052c22731
< <function name="GIOStatus">
---
> <function name="g_sequence_search_iter">
23054c22733,22737
< Stati returned by most of the #GIOFuncs functions.
---
> Like g_sequence_search(), but uses
> a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
> the compare function.
> 
> Since: 2.14
23058,23059c22741,22742
< <parameter name="G_IO_STATUS_ERROR">
< <parameter_description> An error occurred.
---
> <parameter name="seq">
> <parameter_description> a #GSequence
23062,23063c22745,22746
< <parameter name="G_IO_STATUS_NORMAL">
< <parameter_description> Success.
---
> <parameter name="data">
> <parameter_description> data for the new item
23066,23067c22749,22754
< <parameter name="G_IO_STATUS_EOF">
< <parameter_description> End of file.
---
> <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.
23070,23071c22757,22758
< <parameter name="G_IO_STATUS_AGAIN">
< <parameter_description> Resource temporarily unavailable.
---
> <parameter name="cmp_data">
> <parameter_description> user data passed to @iter_cmp
23075c22762,22765
< <return></return>
---
> <return> a #GSequenceIter pointing to the position in @seq
> where @data would have been inserted according to @iter_cmp and @cmp_data.
> 
> </return>
23078c22768
< <function name="G_TRYLOCK">
---
> <function name="g_main_context_unref">
23080,23081c22770,22771
< Works like g_mutex_trylock(), but for a lock defined with
< #G_LOCK_DEFINE.
---
> Decreases the reference count on a #GMainContext object by one. If
> the result is zero, free the context and free all associated memory.
23085,23090c22775,22776
< <parameter name="name">
< <parameter_description> the name of the lock.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> %TRUE, if the lock could be locked.
---
> <parameter name="context">
> <parameter_description> a #GMainContext
23121a22808
> Since: 2.14
23137d22823
< Since: 2.14
23160a22847
> Since: 2.22
23171d22857
< Since: 2.22
23177c22863,22866
< Return value: a #GSequenceIter pointing to the previous position before
---
> Returns an iterator pointing to the previous position before @iter. If
> @iter is the begin iterator, the begin iterator is returned.
> 
> Since: 2.14
23189d22877
< Since: 2.14
23209a22898,22907
> <function name="information">
> <description>
> following functions.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
23277a22976
> Since: 2.14
23312d23010
< Since: 2.14
23357a23056
> Since: 2.14
23368d23066
< Since: 2.14
23472a23171,23188
> <function name="a">
> <description>
> The second check covers surrogate pairs (category Cs).
> 
> The last two checks cover &quot;Noncharacter&quot;: defined as:
> &quot;A code point that is permanently reserved for
> internal use, and that should never be interchanged. In
> Unicode 3.1, these consist of the values U+nFFFE and U+nFFFF
> (where n is from 0 to 10_16) and the values U+FDD0..U+FDEF.&quot;
> 
> @param Char the character
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
23496a23213
> Since: 2.14
23532d23248
< Since: 2.14
23588a23305
> Since: 2.8
23603d23319
< Since: 2.8
23617a23334
> Since: 2.14
23633d23349
< Since: 2.14
23667a23384
> Since: 2.14
23682d23398
< Since: 2.14
23730a23447,23456
> <function name="member">
> <description>
> records, you must use g_tuples_index().
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
23775a23502
> Since: 2.16
23787d23513
< Since: 2.16
23813,23848d23538
< <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>
< 
23869a23560
> Since: 2.4
23898d23588
< Since: 2.4
23926a23617
> Deprecated:2.2: Use g_io_channel_seek_position() instead.
23948d23638
< Deprecated:2.2: Use g_io_channel_seek_position() instead.
23986a23677
> Since: 2.14
23997d23687
< Since: 2.14
24001c23691
< <function name="g_mkstemp">
---
> <function name="g_filename_display_basename">
24003,24004c23693,23696
< Opens a temporary file. See the mkstemp() documentation
< on most UNIX-like systems. 
---
> 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.
24006,24013c23698,23702
< 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.
---
> 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.
24014a23704,23705
> You must pass the whole absolute pathname to this functions so that
> translation of well known locations can be done.
24016,24028c23707,23708
< </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>
---
> This function is preferred over g_filename_display_name() if you know the
> whole path, as it allows translation.
24030,24032c23710
< <function name="g_filename_display_basename">
< <description>
< Return value: a newly allocated string containing
---
> Since: 2.6
24044d23721
< Since: 2.6
24052a23730
> Since: 2.12
24071d23748
< Since: 2.12
24198,24202d23874
< <parameter name="Returns">
< <parameter_description> the data element corresponding to the #GQuark, or %NULL if
< it is not found.
< </parameter_description>
< </parameter>
24204c23876,23878
< <return></return>
---
> <return> the data element corresponding to the #GQuark, or %NULL if
> it is not found.
> </return>
24250a23925
> Since: 2.12
24261d23935
< Since: 2.12
24267c23941,23945
< Return value: a newly allocated %NULL-terminated array of strings.
---
> 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
24283d23960
< Since: 2.12
24328a24006
> Since: 2.14
24355d24032
< Since: 2.14
24359,24393d24035
< <function name="GNode">
< <description>
< The #GNode struct represents one node in a
< &lt;link linkend=&quot;glib-N-ary-Trees&quot;&gt;N-ary Tree&lt;/link&gt;. fields
< 
< </description>
< <parameters>
< <parameter name="data">
< <parameter_description> contains the actual data of the node.
< </parameter_description>
< </parameter>
< <parameter name="next">
< <parameter_description> points to the node's next sibling (a sibling is another
< #GNode with the same parent).
< </parameter_description>
< </parameter>
< <parameter name="prev">
< <parameter_description> points to the node's previous sibling.
< </parameter_description>
< </parameter>
< <parameter name="parent">
< <parameter_description> points to the parent of the #GNode, or is %NULL if the
< #GNode is the root of the tree.
< </parameter_description>
< </parameter>
< <parameter name="children">
< <parameter_description> points to the first child of the #GNode.  The other
< children are accessed by using the @next pointer of each
< child.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
24414a24057,24062
> 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
24424,24429d24071
< 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
24454a24097
> Since: 2.4
24466d24108
< Since: 2.4
24601,24604c24243,24255
< <parameter name="Returns">
< <parameter_description> the new #GThread on success.
< </parameter_description>
< </parameter>
---
> </parameters>
> <return> the new #GThread on success.
> </return>
> </function>
> 
> <function name="really">
> <description>
> 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>
24686a24338
> Since: 2.4
24706d24357
< Since: 2.4
24776c24427,24435
< Return value: the value associated with the key as a boolean, 
---
> 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
24800d24458
< Since: 2.6
24804,24857d24461
< <function name="GIOFlags">
< <description>
< Specifies properties of a #GIOChannel. Some of the flags can only be
< read with g_io_channel_get_flags(), but not changed with
< g_io_channel_set_flags().
< 
< </description>
< <parameters>
< <parameter name="G_IO_FLAG_APPEND">
< <parameter_description> turns on append mode, corresponds to %O_APPEND
< (see the documentation of the UNIX open()
< syscall).
< </parameter_description>
< </parameter>
< <parameter name="G_IO_FLAG_NONBLOCK">
< <parameter_description> turns on nonblocking mode, corresponds to
< %O_NONBLOCK/%O_NDELAY (see the documentation of
< the UNIX open() syscall).
< </parameter_description>
< </parameter>
< <parameter name="G_IO_FLAG_IS_READABLE">
< <parameter_description> indicates that the io channel is readable.
< This flag can not be changed.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_FLAG_IS_WRITEABLE">
< <parameter_description> indicates that the io channel is writable.
< This flag can not be changed.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_FLAG_IS_SEEKABLE">
< <parameter_description> indicates that the io channel is seekable,
< i.e. that g_io_channel_seek_position() can
< be used on it.  This flag can not be changed.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_FLAG_MASK">
< <parameter_description> the mask that specifies all the valid flags.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_FLAG_GET_MASK">
< <parameter_description> the mask of the flags that are returned from
< g_io_channel_get_flags().
< </parameter_description>
< </parameter>
< <parameter name="G_IO_FLAG_SET_MASK">
< <parameter_description> the mask of the flags that the user can modify
< with g_io_channel_set_flags().
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
24894a24499,24501
> 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.
24905,24907d24511
< 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.
24914a24519,24520
> 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.
24925,24926d24530
< 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.
24947c24551,24552
< Return value: the number of key/value pairs in the #GHashTable.
---
> Returns the number of elements contained in the #GHashTable.
> 
24979a24585,24636
> <function name="thread">
> <description>
> pointer which is private to the current thread. Take our
> &lt;function&gt;give_me_next_number(&lt;!-- --&gt;)&lt;/function&gt; example from
> above.  Suppose we don't want &lt;literal&gt;current_number&lt;/literal&gt; to be
> shared between the threads, but instead to be private to each thread.
> This can be done as follows:
> 
> &lt;example&gt;
> &lt;title&gt;Using GPrivate for per-thread data&lt;/title&gt;
> &lt;programlisting&gt;
> GPrivate* current_number_key = NULL; /&lt;!-- --&gt;* Must be initialized somewhere
> with g_private_new (g_free); *&lt;!-- --&gt;/
> 
> int
> give_me_next_number (void)
> {
> int *current_number = g_private_get (current_number_key);
> 
> if (!current_number)
> {
> current_number = g_new (int, 1);
> *current_number = 0;
> g_private_set (current_number_key, current_number);
> }
> 
> *current_number = calc_next_number (*current_number);
> 
> return *current_number;
> }
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> Here the pointer belonging to the key
> &lt;literal&gt;current_number_key&lt;/literal&gt; is read. If it is %NULL, it has
> not been set yet. Then get memory for an integer value, assign this
> memory to the pointer and write the pointer back. Now we have an
> integer value that is private to the current thread.
> 
> The #GPrivate struct should only be accessed via the following
> functions.
> 
> &lt;note&gt;&lt;para&gt;All of the &lt;function&gt;g_private_*&lt;/function&gt; functions are
> actually macros. Apart from taking their addresses, you can however
> use them as if they were functions.&lt;/para&gt;&lt;/note&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
25010a24668
> Since: 2.12
25033d24690
< Since: 2.12
25065,25101d24721
< <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>
< 
25122c24742
< <function name="g_test_rand_double">
---
> <function name="number">
25124,25125c24744,24766
< Get a reproducible random floating point number,
< see g_test_rand_int() for details on test case random numbers.
---
> A #GRelation is a table of data which can be indexed on any number
> of fields, rather like simple database tables. A #GRelation contains
> a number of records, called tuples. Each record contains a number of
> fields. Records are not ordered, so it is not possible to find the
> record at a particular index.
> 
> Note that #GRelation tables are currently limited to 2 fields.
> 
> To create a GRelation, use g_relation_new().
> 
> To specify which fields should be indexed, use g_relation_index().
> Note that this must be called before any tuples are added to the
> #GRelation.
> 
> To add records to a #GRelation use g_relation_insert().
> 
> To determine if a given record appears in a #GRelation, use
> g_relation_exists(). Note that fields are compared directly, so
> pointers must point to the exact same position (i.e. different
> copies of the same string will not match.)
> 
> To count the number of records which have a particular value in a
> given field, use g_relation_count().
25126a24768,24778
> To get all the records which have a particular value in a given
> field, use g_relation_select(). To access fields of the resulting
> records, use g_tuples_index(). To free the resulting records use
> g_tuples_destroy().
> 
> To delete all records which have a particular value in a given
> field, use g_relation_delete().
> 
> To destroy the #GRelation, use g_relation_destroy().
> 
> To help debug #GRelation objects, use g_relation_print().
25131c24783,24784
< <return> a random number from the seeded random number generator.
---
> <return></return>
> </function>
25133c24786,24793
< Since: 2.16
---
> <function name="g_random_boolean">
> <description>
> Returns a random #gboolean. This corresponds to a unbiased coin toss.
> 
> </description>
> <parameters>
> </parameters>
> <return> a random #gboolean.
25195c24855,24858
< Return value: length of @str_array.
---
> Returns the length of the given %NULL-terminated 
> string array @str_array.
> 
> Since: 2.6
25206d24868
< Since: 2.6
25225a24888,24898
> <function name="passed">
> <description>
> parameter passed to g_tree_traverse(). If the function returns
> %TRUE, the traversal is stopped.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
25299a24973,24974
> Returns the number of tuples in a #GRelation that have the given
> value in the given field.
25315,25318d24989
< <parameter name="Returns">
< <parameter_description> the number of matches.
< </parameter_description>
< </parameter>
25320,25321c24991
< <return>the number of tuples in a #GRelation that have the given
< value in the given field.
---
> <return> the number of matches.
25400c25070,25071
< Returns: whether @handler_id identifies a handler connected to @instance.
---
> Returns whether @handler_id is the id of a handler connected to @instance.
> 
25419c25090,25095
< Returns: a canonical representation for the string
---
> 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
25430d25105
< Since: 2.10
25562,25578d25236
< <function name="G_STATIC_PRIVATE_INIT">
< <description>
< Every #GStaticPrivate must be initialized with this macro, before it
< can be used.
< 
< &lt;informalexample&gt;
< &lt;programlisting&gt;
< GStaticPrivate my_private = G_STATIC_PRIVATE_INIT;
< &lt;/programlisting&gt;
< &lt;/informalexample&gt;
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
25689a25348
> Since: 2.16
25705d25363
< Since: 2.16
25842c25500,25504
< Returns: the number of the highest back reference
---
> Returns the number of the highest back reference
> in the pattern, or 0 if the pattern does not contain
> back references.
> 
> Since: 2.14
25853d25514
< Since: 2.14
25856a25518,25553
> <function name="significant">
> <description>
> like a #GPrivate, but can be defined at compile-time. This is
> similar to the difference between #GMutex and #GStaticMutex. Now
> look at our &lt;function&gt;give_me_next_number()&lt;/function&gt; example with
> #GStaticPrivate:
> 
> &lt;example&gt;
> &lt;title&gt;Using GStaticPrivate for per-thread data&lt;/title&gt;
> &lt;programlisting&gt;
> int
> give_me_next_number (&lt;!-- --&gt;)
> {
> static GStaticPrivate current_number_key = G_STATIC_PRIVATE_INIT;
> int *current_number = g_static_private_get (&amp;current_number_key);
> 
> if (!current_number)
> {
> current_number = g_new (int,1);
> *current_number = 0;
> g_static_private_set (&amp;current_number_key, current_number, g_free);
> }
> 
> *current_number = calc_next_number (*current_number);
> 
> return *current_number;
> }
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
25877,25905d25573
< <function name="GIOFunc">
< <description>
< Specifies the type of function passed to g_io_add_watch() or
< g_io_add_watch_full(), which is called when the requested condition
< on a #GIOChannel is satisfied.
< 
< </description>
< <parameters>
< <parameter name="source">
< <parameter_description> the #GIOChannel event source
< </parameter_description>
< </parameter>
< <parameter name="condition">
< <parameter_description> the condition which has been satisfied
< </parameter_description>
< </parameter>
< <parameter name="data">
< <parameter_description> user data set in g_io_add_watch() or g_io_add_watch_full()
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> the function should return %FALSE if the event source
< should be removed
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
25958a25627
> Since: 2.14
25981d25649
< Since: 2.14
26045,26048d25712
< <parameter name="Returns">
< <parameter_description> the new #GThread on success.
< </parameter_description>
< </parameter>
26050c25714,25715
< <return></return>
---
> <return> the new #GThread on success.
> </return>
26054a25720,25725
> 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
26064,26069d25734
< 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
26073,26085d25737
< <function name="GTree">
< <description>
< The &lt;structname&gt;GTree&lt;/structname&gt; struct is an opaque data
< structure representing a &lt;link
< linkend=&quot;glib-Balanced-Binary-Trees&quot;&gt;Balanced Binary Tree&lt;/link&gt;. It
< should be accessed only by using the following functions.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
26213,26216d25864
< <parameter name="Returns">
< <parameter_description> the new #GByteArray.
< </parameter_description>
< </parameter>
26218c25866,25867
< <return></return>
---
> <return> the new #GByteArray.
> </return>
26264a25914
> Since: 2.8
26280d25929
< Since: 2.8
26289a25939
> Since: 2.4
26300d25949
< Since: 2.4
26395,26441d26043
< <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="GVariantIter">
< <description>
< #GVariantIter is an opaque data structure and can only be accessed
< using the following functions.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
26476c26078,26086
< Return value: the values associated with the key as a list of
---
> 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
26504d26113
< Since: 2.6
26544a26154
> Since: 2.16
26575d26184
< Since: 2.16
26581c26190,26194
< Returns: the provided user_data. The returned data belongs to
---
> 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
26594d26206
< Since: 2.18
26654,26657d26265
< <parameter name="Returns">
< <parameter_description> %TRUE, if @mutex could be locked.
< </parameter_description>
< </parameter>
26659c26267,26268
< <return></return>
---
> <return> %TRUE, if @mutex could be locked.
> </return>
26712a26322
> Since: 2.10
26737d26346
< Since: 2.10
26770a26380
> Since: 2.6
26797d26406
< Since: 2.6
26883,26884c26492,26493
< <parameter name="Returns">
< <parameter_description> the #GQuark associated with the string, or 0 if @string is
---
> </parameters>
> <return> the #GQuark associated with the string, or 0 if @string is
26886,26887c26495,26503
< </parameter_description>
< </parameter>
---
> </return>
> </function>
> 
> <function name="are">
> <description>
> information on error domains.
> 
> </description>
> <parameters>
26896a26513
> Since: 2.2
26912d26528
< Since: 2.2
26942a26559
> Since: 2.4
26961d26577
< Since: 2.4
26994c26610,26613
< Returns: %TRUE if @node is an ancestor of @descendant
---
> 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.
> 
27098c26717
< <function name="g_bookmark_file_set_modified">
---
> <function name="various">
27100,27107c26719,26744
< 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().
---
> read raw bytes from the channel.  Encoding and buffering
> issues are dealt with at a higher level.
> @io_write: writes raw bytes to the channel.  This is called from
> various functions such as g_io_channel_write_chars() to
> write raw bytes to the channel.  Encoding and buffering
> issues are dealt with at a higher level.
> @io_seek: (optional) seeks the channel.  This is called from
> g_io_channel_seek() on channels that support it.
> @io_close: closes the channel.  This is called from
> g_io_channel_close() after flushing the buffers.
> @io_create_watch: creates a watch on the channel.  This call
> corresponds directly to g_io_create_watch().
> @io_free: called from g_io_channel_unref() when the channel needs to
> be freed.  This function must free the memory associated
> with the channel, including freeing the #GIOChannel
> structure itself.  The channel buffers have been flushed
> and possibly @io_close has been called by the time this
> function is called.
> @io_set_flags: sets the #GIOFlags on the channel.  This is called
> from g_io_channel_set_flags() with all flags except
> for %G_IO_FLAG_APPEND and %G_IO_FLAG_NONBLOCK masked
> out.
> @io_get_flags: gets the #GIOFlags for the channel.  This function
> need only return the %G_IO_FLAG_APPEND and
> %G_IO_FLAG_NONBLOCK flags; g_io_channel_get_flags()
> automatically adds the others as appropriate.
27109c26746,26747
< Since: 2.12
---
> A table of functions used to handle different types of #GIOChannel
> in a generic way.
27113,27124d26750
< <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>
27190,27194d26815
< <parameter name="Returns">
< <parameter_description> the list of items whose strings begin with @prefix. This
< should not be changed.
< </parameter_description>
< </parameter>
27196c26817,26819
< <return></return>
---
> <return> the list of items whose strings begin with @prefix. This
> should not be changed.
> </return>
27223a26847
> Since: 2.12
27251d26874
< Since: 2.12
27276a26900
> Since: 2.20
27283d26906
< Since: 2.20
27341c26964,26970
< Return value: a newly-allocated %NULL-terminated array of strings. 
---
> 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
27365d26993
< Since: 2.6
27369,27387d26996
< <function name="G_STATIC_RW_LOCK_INIT">
< <description>
< A #GStaticRWLock must be initialized with this macro before it can
< be used. This macro can used be to initialize a variable, but it
< cannot be assigned to a variable. In that case you have to use
< g_static_rw_lock_init().
< 
< &lt;informalexample&gt;
< &lt;programlisting&gt;
< GStaticRWLock my_lock = G_STATIC_RW_LOCK_INIT;
< &lt;/programlisting&gt;
< &lt;/informalexample&gt;
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
27436,27439d27044
< <parameter name="Returns">
< <parameter_description> a pointer to the allocated atom.
< </parameter_description>
< </parameter>
27441c27046,27047
< <return></return>
---
> <return> a pointer to the allocated atom.
> </return>
27476a27083,27127
> <function name="point">
> <description>
> The range of possible top-level types of #GVariant instances.
> 
> Since: 2.24
> 
> </description>
> <parameters>
> <parameter name="G_VARIANT_CLASS_STRING">
> <parameter_description> The #GVariant is a normal string.
> </parameter_description>
> </parameter>
> <parameter name="G_VARIANT_CLASS_OBJECT_PATH">
> <parameter_description> The #GVariant is a DBus object path 
> string.
> </parameter_description>
> </parameter>
> <parameter name="G_VARIANT_CLASS_SIGNATURE">
> <parameter_description> The #GVariant is a DBus signature string.
> </parameter_description>
> </parameter>
> <parameter name="G_VARIANT_CLASS_VARIANT">
> <parameter_description> The #GVariant is a variant.
> </parameter_description>
> </parameter>
> <parameter name="G_VARIANT_CLASS_MAYBE">
> <parameter_description> The #GVariant is a maybe-typed value.
> </parameter_description>
> </parameter>
> <parameter name="G_VARIANT_CLASS_ARRAY">
> <parameter_description> The #GVariant is an array.
> </parameter_description>
> </parameter>
> <parameter name="G_VARIANT_CLASS_TUPLE">
> <parameter_description> The #GVariant is a tuple.
> </parameter_description>
> </parameter>
> <parameter name="G_VARIANT_CLASS_DICT_ENTRY">
> <parameter_description> The #GVariant is a dictionary entry.
> </parameter_description>
> </parameter>
> </parameters>
> <return></return>
> </function>
> 
27545,27564d27195
< <function name="GNodeForeachFunc">
< <description>
< Specifies the type of function passed to g_node_children_foreach().
< The function is called with each child node, together with the user
< data passed to g_node_children_foreach().
< 
< </description>
< <parameters>
< <parameter name="node">
< <parameter_description> a #GNode.
< </parameter_description>
< </parameter>
< <parameter name="data">
< <parameter_description> user data passed to g_node_children_foreach().
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
27595a27227
> Since: 2.22
27610d27241
< Since: 2.22
27706c27337,27344
< Return value: a string owned by GLib that must not be modified 
---
> 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;
> 
> Since: 2.6
27713d27350
< Since: 2.6
27848c27485,27487
< Returns: a string containing the complete path to @subdir inside
---
> 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().
27871,27873d27509
< 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().
28065c27701,27703
< Return value: The link at the @n'th position, or %NULL if @n is off the
---
> Returns the link at the given position
> 
> Since: 2.4
28081d27718
< Since: 2.4
28114,28117d27750
< <parameter name="Returns">
< <parameter_description> a new #GIOChannel.
< </parameter_description>
< </parameter>
28119c27752,27753
< <return></return>
---
> <return> a new #GIOChannel.
> </return>
28196,28231d27829
< <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>
< 
28255a27854
> Since: 2.8
28266d27864
< Since: 2.8
28270,28305d27867
< <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>
< 
28425,28460d27986
< <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>
< 
28616a28143
> Since: 2.4
28636d28162
< Since: 2.4
28667,28678d28192
< <function name="G_ALLOC_AND_FREE">
< <description>
< Specifies the type of a #GMemChunk. Used in g_mem_chunk_new() and
< g_mem_chunk_create() to specify that atoms will be freed
< individually.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
28685a28200
> Since: 2.6
28708d28222
< Since: 2.6
28850c28364,28367
< Returns: a pointer into @file_name after the root component.
---
> 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.
> 
28863,28872d28379
< <function name="g_cclosure_marshal_BOOL__FLAGS">
< <description>
< Another name for g_cclosure_marshal_BOOLEAN__FLAGS().
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
28875c28382,28385
< Returns: %TRUE if automatic help generation is turned on.
---
> 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
28886d28395
< Since: 2.6
29183,29187d28691
< <parameter name="Returns">
< <parameter_description> number of times @mutex has been locked by the current
< thread.
< </parameter_description>
< </parameter>
29189c28693,28695
< <return></return>
---
> <return> number of times @mutex has been locked by the current
> thread.
> </return>
29197a28704
> Since: 2.4
29208d28714
< Since: 2.4
29242a28749,28753
> 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
29252,29256d28762
< 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
29262c28768,28770
< Return value: A random number.
---
> Returns a random #gint32 equally distributed over the range
> [@begin..@end-1].
> 
29283a28792
> Since: 2.8
29294d28802
< Since: 2.8
29386a28895
> Since: 2.10
29411d28919
< Since: 2.10
29486a28995,28997
> 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.
29497,29499d29007
< 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.
29521,29524d29028
< <parameter name="Returns">
< <parameter_description> the pointer which was removed.
< </parameter_description>
< </parameter>
29526c29030,29031
< <return></return>
---
> <return> the pointer which was removed.
> </return>
29550,29568d29054
< <function name="G_STATIC_REC_MUTEX_INIT">
< <description>
< A #GStaticRecMutex must be initialized with this macro before it can
< be used. This macro can used be to initialize a variable, but it
< cannot be assigned to a variable. In that case you have to use
< g_static_rec_mutex_init().
< 
< &lt;informalexample&gt;
< &lt;programlisting&gt;
< GStaticRecMutex my_mutex = G_STATIC_REC_MUTEX_INIT;
< &lt;/programlisting&gt;
<  &lt;/informalexample&gt;
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
29669,29672d29154
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
29674c29156,29157
< <return></return>
---
> <return> the #GArray.
> </return>
29698,29702d29180
< <parameter name="Returns">
< <parameter_description> the #GQuark identifying the string, or 0 if @string is
< %NULL.
< </parameter_description>
< </parameter>
29704c29182,29184
< <return></return>
---
> <return> the #GQuark identifying the string, or 0 if @string is
> %NULL.
> </return>
29864a29345
> Since: 2.14
29875d29355
< Since: 2.14
29902a29383
> Since: 2.14
29926d29406
< Since: 2.14
29929a29410,29426
> <function name="be">
> <description>
> cannot be assigned to a variable. In that case you have to use
> g_static_rw_lock_init().
> 
> &lt;informalexample&gt;
> &lt;programlisting&gt;
> GStaticRWLock my_lock = G_STATIC_RW_LOCK_INIT;
> &lt;/programlisting&gt;
> &lt;/informalexample&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
30021c29518,29579
< Return value: %TRUE if the source has been destroyed
---
> 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
30032d29589
< Since: 2.12
30064,30099d29620
< <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>
< 
30214,30237d29734
< <function name="GEqualFunc">
< <description>
< Specifies the type of a function used to test two values for
< equality. The function should return %TRUE if both values are equal
< and %FALSE otherwise.
< 
< </description>
< <parameters>
< <parameter name="a">
< <parameter_description> a value.
< </parameter_description>
< </parameter>
< <parameter name="b">
< <parameter_description> a value to compare with.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> %TRUE if @a = @b; %FALSE otherwise.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
30314c29811,29815
< Returns: The nextmost fundamental type ID to be registered,
---
> 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.
> 
30389,30393c29890
< <parameter_description> a window handle.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> a new #GIOChannel.
---
> <parameter_description> a window handle.
30397c29894,29895
< <return></return>
---
> <return> a new #GIOChannel.
> </return>
30427a29926,29930
> 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
30437,30441d29939
< 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
30447c29945,29947
< Returns: The GTypeInterface structure of iface_type if implemented
---
> Returns the #GTypeInterface structure of an interface to which the
> passed in class conforms.
> 
30537,30540d30036
< <parameter name="Returns">
< <parameter_description> the next element, or %NULL if there are no more elements.
< </parameter_description>
< </parameter>
30542c30038,30039
< <return></return>
---
> <return> the next element, or %NULL if there are no more elements.
> </return>
30667c30164
< <function name="g_list_index">
---
> <function name="g_flags_complete_type_info">
30669,30671c30166,30168
< Gets the position of the element containing 
< the given data (starting from 0).
< 
---
> 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.
30675,30676c30172,30173
< <parameter name="list">
< <parameter_description> a #GList
---
> <parameter name="g_flags_type">
> <parameter_description> the type identifier of the type being completed
30679,30680c30176,30183
< <parameter name="data">
< <parameter_description> the data to find
---
> <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.
30684,30686c30187
< <return> the index of the element containing the data, 
< or -1 if the data is not found
< </return>
---
> <return></return>
30692c30193,30201
< Returns: paramspec to which requests on this paramspec should
---
> 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
> 
30710a30220
> Since: 2.2
30732d30241
< Since: 2.2
30742a30252,30264
> 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.
30762,30774d30283
< 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.
30803a30313
> Since: 2.6
30822d30331
< Since: 2.6
30886,30889d30394
< <parameter name="Returns">
< <parameter_description> %TRUE if the pointer was found in the array.
< </parameter_description>
< </parameter>
30891c30396,30397
< <return></return>
---
> <return> %TRUE if the pointer was found in the array.
> </return>
30925,30928d30430
< <parameter name="Returns">
< <parameter_description> %TRUE, if the #GStaticMutex could be locked.
< </parameter_description>
< </parameter>
30930c30432,30433
< <return></return>
---
> <return> %TRUE, if the #GStaticMutex could be locked.
> </return>
31020a30524,30530
> 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
31030,31036d30539
< 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
31082,31085d30584
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
31087c30586,30587
< <return></return>
---
> <return> the #GArray.
> </return>
31140a30641
> Since: 2.6
31152d30652
< Since: 2.6
31255,31258d30754
< <parameter name="Returns">
< <parameter_description> a reference to a #GVariant, or %NULL
< </parameter_description>
< </parameter>
31260c30756,30757
< <return></return>
---
> <return> a reference to a #GVariant, or %NULL
> </return>
31416c30913,30914
< Return value: A random number.
---
> Returns a random #gdouble equally distributed over the range [0..1).
> 
31424a30923,30937
> <function name="elements">
> <description>
> The &lt;structname&gt;GByteArray&lt;/structname&gt; struct allows access to the
> public fields of a &lt;structname&gt;GByteArray&lt;/structname&gt;.
> 
> </description>
> <parameters>
> <parameter name="len">
> <parameter_description> the number of elements in the #GByteArray.
> </parameter_description>
> </parameter>
> </parameters>
> <return></return>
> </function>
> 
31485c30998
< <function name="G_THREADS_IMPL_POSIX">
---
> <function name="g_variant_type_is_dict_entry">
31487c31000,31007
< This macro is defined if POSIX style threads are used.
---
> 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
31490a31011,31014
> <parameter name="type">
> <parameter_description> a #GVariantType
> </parameter_description>
> </parameter>
31492c31016,31017
< <return></return>
---
> <return> %TRUE if @type is a dictionary entry type
> </return>
31521a31047
> Since: 2.16
31541d31066
< Since: 2.16
31618a31144,31154
> <function name="structure">
> <description>
> linkend=&quot;glib-Balanced-Binary-Trees&quot;&gt;Balanced Binary Tree&lt;/link&gt;. It
> should be accessed only by using the following functions.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
31644c31180,31191
< Return value: the path to the specified special directory, or %NULL
---
> 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
31657d31203
< Since: 2.14
31665a31212,31213
> Deprecated:2.2: See g_strncasecmp() for a discussion of why this function 
> is deprecated and how to replace it.
31681,31682d31228
< Deprecated:2.2: See g_strncasecmp() for a discussion of why this function 
< is deprecated and how to replace it.
31771a31318
> Since: 2.16
31783d31329
< Since: 2.16
31789c31335,31337
< Return value: The currently firing source or %NULL.
---
> Returns the currently firing source for this thread.
> 
> Since: 2.12
31796d31343
< Since: 2.12
31863c31410,31412
< Return value: the position of @iter
---
> Returns the position of @iter
> 
> Since: 2.14
31874d31422
< Since: 2.14
31930,31942c31478
< 
< </description>
< <parameters>
< <parameter name="private_key">
< <parameter_description> a #GPrivate.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> the corresponding pointer.
< </parameter_description>
< </parameter>
< </parameters>
< <return>the pointer keyed to @private_key for the current thread. If
---
> Returns the pointer keyed to @private_key for the current thread. If
31953a31490,31498
> 
> </description>
> <parameters>
> <parameter name="private_key">
> <parameter_description> a #GPrivate.
> </parameter_description>
> </parameter>
> </parameters>
> <return> the corresponding pointer.
31975a31521
> Since: 2.14
31991d31536
< Since: 2.14
31999c31544,31552
< Return value: %TRUE if the operation succeeded, and
---
> 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().
> 
32042a31596
> Since: 2.8
32066d31619
< Since: 2.8
32072c31625,31627
< Returns: The depth of @type.
---
> 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.
> 
32089a31645
> Since: 2.14
32103d31658
< Since: 2.14
32111a31667
> Since: 2.22
32122d31677
< Since: 2.22
32265a31821
> Since: 2.12
32284d31839
< Since: 2.12
32288c31843
< <function name="g_random_boolean">
---
> <function name="linkend">
32289a31845
> only be accessed via the following functions.
32293,32296d31848
< <parameter name="Returns">
< <parameter_description> a random #gboolean.
< </parameter_description>
< </parameter>
32298,32299c31850
< <return>a random #gboolean. This corresponds to a unbiased coin toss.
< </return>
---
> <return></return>
32379a31931
> Since: 2.6
32400d31951
< Since: 2.6
32404c31955
< <function name="GVariantClass">
---
> <function name="pipes">
32406,32408c31957,31958
< The range of possible top-level types of #GVariant instances.
< 
< Since: 2.24
---
> A bitwise combination representing a condition to watch for on an
> event source.
32412,32483c31962,31963
< <parameter name="G_VARIANT_CLASS_BOOLEAN">
< <parameter_description> The #GVariant is a boolean.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_BYTE">
< <parameter_description> The #GVariant is a byte.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_INT16">
< <parameter_description> The #GVariant is a signed 16 bit integer.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_UINT16">
< <parameter_description> The #GVariant is an unsigned 16 bit integer.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_INT32">
< <parameter_description> The #GVariant is a signed 32 bit integer.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_UINT32">
< <parameter_description> The #GVariant is an unsigned 32 bit integer.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_INT64">
< <parameter_description> The #GVariant is a signed 64 bit integer.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_UINT64">
< <parameter_description> The #GVariant is an unsigned 64 bit integer.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_HANDLE">
< <parameter_description> The #GVariant is a file handle index.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_DOUBLE">
< <parameter_description> The #GVariant is a double precision floating 
< point value.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_STRING">
< <parameter_description> The #GVariant is a normal string.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_OBJECT_PATH">
< <parameter_description> The #GVariant is a DBus object path 
< string.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_SIGNATURE">
< <parameter_description> The #GVariant is a DBus signature string.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_VARIANT">
< <parameter_description> The #GVariant is a variant.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_MAYBE">
< <parameter_description> The #GVariant is a maybe-typed value.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_ARRAY">
< <parameter_description> The #GVariant is an array.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_TUPLE">
< <parameter_description> The #GVariant is a tuple.
< </parameter_description>
< </parameter>
< <parameter name="G_VARIANT_CLASS_DICT_ENTRY">
< <parameter_description> The #GVariant is a dictionary entry.
---
> <parameter name="G_IO_NVAL">
> <parameter_description> Invalid request. The file descriptor is not open.
32490c31970
< <function name="g_object_interface_list_properties">
---
> <function name="access">
32492,32495c31972,31978
< 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().
---
> &lt;example&gt;
> &lt;title&gt;A function which will not work in a threaded environment&lt;/title&gt;
> &lt;programlisting&gt;
> int
> give_me_next_number (void)
> {
> static int current_number = 0;
32497c31980,32059
< Since: 2.4
---
> /&lt;!-- --&gt;* now do a very complicated calculation to calculate the new
> * number, this might for example be a random number generator
> *&lt;!-- --&gt;/
> current_number = calc_next_number (current_number);
> 
> return current_number;
> }
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> It is easy to see that this won't work in a multi-threaded
> application. There current_number must be protected against shared
> access. A first naive implementation would be:
> 
> &lt;example&gt;
> &lt;title&gt;The wrong way to write a thread-safe function&lt;/title&gt;
> &lt;programlisting&gt;
> int
> give_me_next_number (void)
> {
> static int current_number = 0;
> int ret_val;
> static GMutex * mutex = NULL;
> 
> if (!mutex) mutex = g_mutex_new (&lt;!-- --&gt;);
> 
> g_mutex_lock (mutex);
> ret_val = current_number = calc_next_number (current_number);
> g_mutex_unlock (mutex);
> 
> return ret_val;
> }
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> This looks like it would work, but there is a race condition while
> constructing the mutex and this code cannot work reliable. Please do
> not use such constructs in your own programs! One working solution
> is:
> 
> &lt;example&gt;
> &lt;title&gt;A correct thread-safe function&lt;/title&gt;
> &lt;programlisting&gt;
> static GMutex *give_me_next_number_mutex = NULL;
> 
> /&lt;!-- --&gt;* this function must be called before any call to
> * give_me_next_number(&lt;!-- --&gt;)
> *
> * it must be called exactly once.
> *&lt;!-- --&gt;/
> void
> init_give_me_next_number (void)
> {
> g_assert (give_me_next_number_mutex == NULL);
> give_me_next_number_mutex = g_mutex_new (&lt;!-- --&gt;);
> }
> 
> int
> give_me_next_number (void)
> {
> static int current_number = 0;
> int ret_val;
> 
> g_mutex_lock (give_me_next_number_mutex);
> ret_val = current_number = calc_next_number (current_number);
> g_mutex_unlock (give_me_next_number_mutex);
> 
> return ret_val;
> }
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> #GStaticMutex provides a simpler and safer way of doing this.
> 
> If you want to use a mutex, and your code should also work without
> calling g_thread_init() first, then you can not use a #GMutex, as
> g_mutex_new() requires that the thread system be initialized. Use a
> #GStaticMutex instead.
> 
> A #GMutex should only be accessed via the following functions.
32498a32061,32063
> &lt;note&gt;&lt;para&gt;All of the &lt;function&gt;g_mutex_*&lt;/function&gt; functions are
> actually macros. Apart from taking their addresses, you can however
> use them as if they were functions.&lt;/para&gt;&lt;/note&gt;
32502,32510d32066
< <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>
32512,32516c32068
< <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>
---
> <return></return>
32558,32561d32109
< <parameter name="Returns">
< <parameter_description> the data element, or %NULL if it is not found.
< </parameter_description>
< </parameter>
32563c32111,32112
< <return></return>
---
> <return> the data element, or %NULL if it is not found.
> </return>
32622a32172
> Since: 2.16
32629d32178
< Since: 2.16
32675c32224,32226
< Returns: the number of capturing subpatterns
---
> Returns the number of capturing subpatterns in the pattern.
> 
> Since: 2.14
32686d32236
< Since: 2.14
32696a32247
> Since: 2.12
32715d32265
< Since: 2.12
32765c32315,32316
< Return value: A random number.
---
> Returns a random #gdouble equally distributed over the range [@begin..@end).
> 
32836,32860d32386
< <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>
< 
32881a32408
> Since: 2.4
32901d32427
< Since: 2.4
33014a32541
> Since: 2.22
33025d32551
< Since: 2.22
33135a32662
> Since: 2.14
33154d32680
< Since: 2.14
33209,33212d32734
< <parameter name="Returns">
< <parameter_description> the return value of the thread.
< </parameter_description>
< </parameter>
33214c32736,32737
< <return></return>
---
> <return> the return value of the thread.
> </return>
33273,33276d32795
< <parameter name="Returns">
< <parameter_description> the #GByteArray.
< </parameter_description>
< </parameter>
33278c32797,32798
< <return></return>
---
> <return> the #GByteArray.
> </return>
33306a32827,32911
> <function name="lock">
> <description>
> read from, while others also write. In such situations it is
> desirable that several readers can read at once, whereas of course
> only one writer may write at a time. Take a look at the following
> example:
> 
> &lt;example&gt;
> &lt;title&gt;An array with access functions&lt;/title&gt;
> &lt;programlisting&gt;
> GStaticRWLock rwlock = G_STATIC_RW_LOCK_INIT;
> GPtrArray *array;
> 
> gpointer
> my_array_get (guint index)
> {
> gpointer retval = NULL;
> 
> if (!array)
> return NULL;
> 
> g_static_rw_lock_reader_lock (&amp;rwlock);
> if (index &lt; array-&gt;len)
> retval = g_ptr_array_index (array, index);
> g_static_rw_lock_reader_unlock (&amp;rwlock);
> 
> return retval;
> }
> 
> void
> my_array_set (guint index, gpointer data)
> {
> g_static_rw_lock_writer_lock (&amp;rwlock);
> 
> if (!array)
> array = g_ptr_array_new (&lt;!-- --&gt;);
> 
> if (index &gt;= array-&gt;len)
> g_ptr_array_set_size (array, index+1);
> g_ptr_array_index (array, index) = data;
> 
> g_static_rw_lock_writer_unlock (&amp;rwlock);
> }
> &lt;/programlisting&gt;
> &lt;/example&gt;
> 
> This example shows an array which can be accessed by many readers
> (the &lt;function&gt;my_array_get()&lt;/function&gt; function) simultaneously,
> whereas the writers (the &lt;function&gt;my_array_set()&lt;/function&gt;
> function) will only be allowed once at a time and only if no readers
> currently access the array. This is because of the potentially
> dangerous resizing of the array. Using these functions is fully
> multi-thread safe now.
> 
> Most of the time, writers should have precedence over readers. That
> means, for this implementation, that as soon as a writer wants to
> lock the data, no other reader is allowed to lock the data, whereas,
> of course, the readers that already have locked the data are allowed
> to finish their operation. As soon as the last reader unlocks the
> data, the writer will lock it.
> 
> Even though #GStaticRWLock is not opaque, it should only be used
> with the following functions.
> 
> All of the &lt;function&gt;g_static_rw_lock_*&lt;/function&gt; functions can be
> used even if g_thread_init() has not been called. Then they do
> nothing, apart from &lt;function&gt;g_static_rw_lock_*_trylock&lt;/function&gt;,
> which does nothing but returning %TRUE.
> 
> &lt;note&gt;&lt;para&gt;A read-write lock has a higher overhead than a mutex. For
> example, both g_static_rw_lock_reader_lock() and
> g_static_rw_lock_reader_unlock() have to lock and unlock a
> #GStaticMutex, so it takes at least twice the time to lock and unlock
> a #GStaticRWLock that it does to lock and unlock a #GStaticMutex. So
> only data structures that are accessed by multiple readers, and which
> keep the lock for a considerable time justify a #GStaticRWLock. The
> above example most probably would fare better with a
> #GStaticMutex.&lt;/para&gt;&lt;/note&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
33363a32969
> Since: 2.8
33380d32985
< Since: 2.8
33434a33040
> Since: 2.18
33488d33093
< Since: 2.18
33615c33220,33228
< Returns: A newly allocated string containing the help text
---
> 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
33634d33246
< Since: 2.14
33792,33795d33403
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
33797c33405,33406
< <return></return>
---
> <return> the #GArray.
> </return>
33941c33550,33553
< Returns: %TRUE if unknown options are ignored.
---
> Returns whether unknown options are ignored or not. See
> g_option_context_set_ignore_unknown_options().
> 
> Since: 2.6
33952d33563
< Since: 2.6
34011c33622
< <function name="G_THREADS_IMPL_NONE">
---
> <function name="g_io_channel_get_encoding">
34013,34015c33624,33627
< This macro is defined if no thread implementation is used. You can,
< however, provide one to g_thread_init() to make GLib multi-thread
< safe.
---
> 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.
> 
34018a33631,33634
> <parameter name="channel">
> <parameter_description> a #GIOChannel
> </parameter_description>
> </parameter>
34020c33636,33638
< <return></return>
---
> <return> A string containing the encoding, this string is
> owned by GLib and must not be freed.
> </return>
34048a33667
> Since: 2.16
34063d33681
< Since: 2.16
34070a33689
> Since: 2.14
34085d33703
< Since: 2.14
34094a33713
> Since: 2.12
34113d33731
< Since: 2.12
34117,34162d33734
< <function name="GOnceStatus">
< <description>
< The possible statuses of a one-time initialization function
< controlled by a #GOnce struct.
< 
< Since: 2.4
< 
< </description>
< <parameters>
< <parameter name="G_ONCE_STATUS_NOTCALLED">
< <parameter_description> the function has not been called yet.
< </parameter_description>
< </parameter>
< <parameter name="G_ONCE_STATUS_PROGRESS">
< <parameter_description> the function call is currently in progress.
< </parameter_description>
< </parameter>
< <parameter name="G_ONCE_STATUS_READY">
< <parameter_description> the function has been called.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
< <function name="GArray">
< <description>
< Contains the public fields of an &lt;link
< linkend=&quot;glib-arrays&quot;&gt;Array&lt;/link&gt;.
< 
< </description>
< <parameters>
< <parameter name="data">
< <parameter_description> a pointer to the element data. The data may be moved as
< elements are added to the #GArray.
< </parameter_description>
< </parameter>
< <parameter name="len">
< <parameter_description> the number of elements in the #GArray not including the
< possible terminating zero element.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
34192c33764
< <function name="GHashTable">
---
> <function name="g_ucs4_to_utf8">
34194,34196c33766,33768
< The #GHashTable struct is an opaque data structure to represent a
< &lt;link linkend=&quot;glib-Hash-Tables&quot;&gt;Hash Table&lt;/link&gt;. It should only be
< accessed via the following functions.
---
> 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.
> 
34199a33772,33796
> <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>
34201c33798,33804
< <return></return>
---
> <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>
34243c33846,33847
< Returns: the data of the last element in the queue, or %NULL if the queue
---
> Returns the last element of the queue.
> 
34296c33900,33908
< Return value: the values associated with the key as a list of
---
> 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
34324d33935
< Since: 2.12
34329a33941,33946
> 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
34339,34344d33955
< 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
34392d34002
< Return value: %TRUE if the text was valid UTF-8
34445c34055,34063
< Return value: the value associated with the key as an integer, or
---
> 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
34469d34086
< Since: 2.6
34484a34102
> Since: 2.4
34499d34116
< Since: 2.4
34592c34209
< <function name="g_variant_type_is_dict_entry">
---
> <function name="shortage">
34594,34601c34211
< 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
---
> Possible errors of thread related functions.
34605,34608d34214
< <parameter name="type">
< <parameter_description> a #GVariantType
< </parameter_description>
< </parameter>
34610,34611c34216
< <return> %TRUE if @type is a dictionary entry type
< </return>
---
> <return></return>
34742a34348
> Since: 2.8
34754d34359
< Since: 2.8
34820a34426
> Since: 2.22
34831d34436
< Since: 2.22
35042a34648
> Since: 2.16
35053d34658
< Since: 2.16
35100a34706,34707
> Deprecated: 2.18: Pass the HMODULE of a DLL or EXE to
> g_win32_get_package_installation_directory_of_module() instead.
35118,35119d34724
< Deprecated: 2.18: Pass the HMODULE of a DLL or EXE to
< g_win32_get_package_installation_directory_of_module() instead.
35174,35177d34778
< <parameter name="Returns">
< <parameter_description> the current thread.
< </parameter_description>
< </parameter>
35179c34780,34781
< <return></return>
---
> <return> the current thread.
> </return>
35265c34867,34869
< Returns: the description
---
> Returns the description. See g_option_context_set_description().
> 
> Since: 2.12
35276d34879
< Since: 2.12
35398,35401d35000
< <parameter name="Returns">
< <parameter_description> %TRUE, if @lock could be locked for reading.
< </parameter_description>
< </parameter>
35403c35002,35003
< <return></return>
---
> <return> %TRUE, if @lock could be locked for reading.
> </return>
35463c35063
< <function name="G_ALLOC_ONLY">
---
> <function name="sockets">
35465,35467c35065,35100
< Specifies the type of a #GMemChunk. Used in g_mem_chunk_new() and
< g_mem_chunk_create() to specify that atoms will never be freed
< individually.
---
> The #GIOChannel data type aims to provide a portable method for
> using file descriptors, pipes, and sockets, and integrating them
> into the &lt;link linkend=&quot;glib-The-Main-Event-Loop&quot;&gt;main event
> loop&lt;/link&gt;. Currently full support is available on UNIX platforms,
> support for Windows is only partially complete.
> 
> To create a new #GIOChannel on UNIX systems use
> g_io_channel_unix_new(). This works for plain file descriptors,
> pipes and sockets. Alternatively, a channel can be created for a
> file in a system independent manner using g_io_channel_new_file().
> 
> Once a #GIOChannel has been created, it can be used in a generic
> manner with the functions g_io_channel_read_chars(),
> g_io_channel_write_chars(), g_io_channel_seek_position(), and
> g_io_channel_shutdown().
> 
> To add a #GIOChannel to the &lt;link
> linkend=&quot;glib-The-Main-Event-Loop&quot;&gt;main event loop&lt;/link&gt; use
> g_io_add_watch() or g_io_add_watch_full(). Here you specify which
> events you are interested in on the #GIOChannel, and provide a
> function to be called whenever these events occur.
> 
> #GIOChannel instances are created with an initial reference count of
> 1. g_io_channel_ref() and g_io_channel_unref() can be used to
> increment or decrement the reference count respectively. When the
> reference count falls to 0, the #GIOChannel is freed. (Though it
> isn't closed automatically, unless it was created using
> g_io_channel_new_from_file().) Using g_io_add_watch() or
> g_io_add_watch_full() increments a channel's reference count.
> 
> The new functions g_io_channel_read_chars(),
> g_io_channel_read_line(), g_io_channel_read_line_string(),
> g_io_channel_read_to_end(), g_io_channel_write_chars(),
> g_io_channel_seek_position(), and g_io_channel_flush() should not be
> mixed with the deprecated functions g_io_channel_read(),
> g_io_channel_write(), and g_io_channel_seek() on the same channel.
35470a35104,35113
> <parameter name="see_also">
> <parameter_description> &lt;para&gt; &lt;variablelist&gt; &lt;varlistentry&gt;
> &lt;term&gt;g_io_add_watch(), g_io_add_watch_full(),
> g_source_remove()&lt;/term&gt; &lt;listitem&gt;&lt;para&gt; Convenience
> functions for creating #GIOChannel instances and adding
> them to the &lt;link linkend=&quot;glib-The-Main-Event-Loop&quot;&gt;main
> event loop&lt;/link&gt;. &lt;/para&gt;&lt;/listitem&gt; &lt;/varlistentry&gt;
> &lt;/variablelist&gt; &lt;/para&gt;
> </parameter_description>
> </parameter>
35486a35130
> Since: 2.16
35493d35136
< Since: 2.16
35540,35609d35182
< <function name="GIOChannelError">
< <description>
< Error codes returned by #GIOChannel operations.
< 
< </description>
< <parameters>
< <parameter name="G_IO_CHANNEL_ERROR_FBIG">
< <parameter_description> File too large.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_CHANNEL_ERROR_INVAL">
< <parameter_description> Invalid argument.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_CHANNEL_ERROR_IO">
< <parameter_description> IO error.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_CHANNEL_ERROR_ISDIR">
< <parameter_description> File is a directory.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_CHANNEL_ERROR_NOSPC">
< <parameter_description> No space left on device.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_CHANNEL_ERROR_NXIO">
< <parameter_description> No such device or address.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_CHANNEL_ERROR_OVERFLOW">
< <parameter_description> Value too large for defined datatype.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_CHANNEL_ERROR_PIPE">
< <parameter_description> Broken pipe.
< </parameter_description>
< </parameter>
< <parameter name="G_IO_CHANNEL_ERROR_FAILED">
< <parameter_description> Some other error.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
< <function name="GThreadPool">
< <description>
< The #GThreadPool struct represents a thread pool. It has three
< public read-only members, but the underlying struct is bigger, so
< you must not copy this struct.
< 
< </description>
< <parameters>
< <parameter name="func">
< <parameter_description> the function to execute in the threads of this pool
< </parameter_description>
< </parameter>
< <parameter name="user_data">
< <parameter_description> the user data for the threads of this pool
< </parameter_description>
< </parameter>
< <parameter name="exclusive">
< <parameter_description> are all threads exclusive to this pool
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
35685c35258
< <function name="g_object_weak_ref">
---
> <function name="system">
35687,35691c35260,35290
< 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).
---
> &lt;/para&gt;
> 
> Sometimes you wish to asynchronously fork out the execution of work
> and continue working in your own thread. If that will happen often,
> the overhead of starting and destroying a thread each time might be
> too high. In such cases reusing already started threads seems like a
> good idea. And it indeed is, but implementing this can be tedious
> and error-prone.
> 
> Therefore GLib provides thread pools for your convenience. An added
> advantage is, that the threads can be shared between the different
> subsystems of your program, when they are using GLib.
> 
> To create a new thread pool, you use g_thread_pool_new(). It is
> destroyed by g_thread_pool_free().
> 
> If you want to execute a certain task within a thread pool, you call
> g_thread_pool_push().
> 
> To get the current number of running threads you call
> g_thread_pool_get_num_threads(). To get the number of still
> unprocessed tasks you call g_thread_pool_unprocessed(). To control
> the maximal number of threads for a thread pool, you use
> g_thread_pool_get_max_threads() and g_thread_pool_set_max_threads().
> 
> Finally you can control the number of unused threads, that are kept
> alive by GLib for future use. The current number can be fetched with
> g_thread_pool_get_num_unused_threads(). The maximal number can be
> controlled by g_thread_pool_get_max_unused_threads() and
> g_thread_pool_set_max_unused_threads(). All currently unused threads
> can be stopped by calling g_thread_pool_stop_unused_threads().
35695,35706d35293
< <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>
35716a35304
> Since: 2.16
35736d35323
< Since: 2.16
35756c35343,35347
< Return value: a newly-allocated %NULL-terminated array of strings. 
---
> 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
35771d35361
< Since: 2.6
35819c35409
< <function name="GStringChunk">
---
> <function name="g_cclosure_marshal_">
35821,35822c35411,35412
< An opaque data structure representing String Chunks. It should only
< be accessed by using the following functions.
---
> 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;.
35825a35416,35440
> <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>
35849,35861d35463
< <function name="GVariant">
< <description>
< #GVariant is an opaque data structure and can only be accessed
< using the following functions.
< 
< Since: 2.24
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
35914a35517,35534
> <function name="that">
> <description>
> and can be tricky to get exactly right, so #GTimer provides a
> portable/convenient interface.
> 
> &lt;note&gt;&lt;para&gt;
> #GTimer uses a higher-quality clock when thread support is available.
> Therefore, calling g_thread_init() while timers are running may lead to
> unreliable results. It is best to call g_thread_init() before starting any
> timers, if you are using threads at all.
> &lt;/para&gt;&lt;/note&gt;
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
35918a35539
> Since: 2.4
35933d35553
< Since: 2.4
35936a35557,35607
> <function name="pointers">
> <description>
> over the list in both directions
> 
> The #GList structure and its associated functions provide a standard
> doubly-linked list data structure.
> 
> Each element in the list contains a piece of data, together with
> pointers which link to the previous and next elements in the list.
> Using these pointers it is possible to move through the list in both
> directions (unlike the &lt;link
> linkend=&quot;glib-Singly-Linked-lists&quot;&gt;Singly-Linked Lists&lt;/link&gt; which
> only allows movement through the list in the forward direction).
> 
> The data contained in each element can be either integer values, by
> using one of the &lt;link linkend=&quot;glib-Type-Conversion-Macros&quot;&gt;Type
> Conversion Macros&lt;/link&gt;, or simply pointers to any type of data.
> 
> List elements are allocated from the &lt;link
> linkend=&quot;glib-Memory-Slices&quot;&gt;slice allocator&lt;/link&gt;, which is more
> efficient than allocating elements individually.
> 
> Note that most of the #GList functions expect to be passed a pointer
> to the first element in the list. The functions which insert
> elements return the new start of the list, which may have changed.
> 
> There is no function to create a #GList. %NULL is considered to be
> the empty list so you simply set a #GList* to %NULL.
> 
> To add elements, use g_list_append(), g_list_prepend(),
> g_list_insert() and g_list_insert_sorted().
> 
> To remove elements, use g_list_remove().
> 
> To find elements in the list use g_list_first(), g_list_last(),
> g_list_next(), g_list_previous(), g_list_nth(), g_list_nth_data(),
> g_list_find() and g_list_find_custom().
> 
> To find the index of an element use g_list_position() and
> g_list_index().
> 
> To call a function for each element in the list use g_list_foreach().
> 
> To free the entire list, use g_list_free().
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
36016a35688
> Since: 2.14
36039d35710
< Since: 2.14
36330c36001
< <function name="g_io_channel_get_encoding">
---
> <function name="g_dataset_remove_no_notify">
36332,36335c36003
< 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.
< 
---
> Removes an element, without calling its destroy notifier.
36339,36340c36007,36012
< <parameter name="channel">
< <parameter_description> a #GIOChannel
---
> <parameter name="l">
> <parameter_description> the location identifying the dataset.
> </parameter_description>
> </parameter>
> <parameter name="k">
> <parameter_description> the string identifying the data element.
36344,36346c36016
< <return> A string containing the encoding, this string is
< owned by GLib and must not be freed.
< </return>
---
> <return></return>
36373a36044
> Since: 2.12
36393d36063
< Since: 2.12
36565,36575d36234
< <function name="GAllocator">
< <description>
< The #GAllocator struct contains private data. and should only be
< accessed using the following functions.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
36619,36622d36277
< <parameter name="Returns">
< <parameter_description> a pointer to a #GCache value.
< </parameter_description>
< </parameter>
36624c36279,36280
< <return></return>
---
> <return> a pointer to a #GCache value.
> </return>
36660,36663d36315
< <parameter name="Returns">
< <parameter_description> the new #GMemChunk.
< </parameter_description>
< </parameter>
36665c36317,36318
< <return></return>
---
> <return> the new #GMemChunk.
> </return>
36681c36334
< <function name="G_ONCE_INIT">
---
> <function name="should">
36683c36336,36338
< A #GOnce must be initialized with this macro before it can be used.
---
> Specifies the type of function passed to g_io_add_watch() or
> g_io_add_watch_full(), which is called when the requested condition
> on a #GIOChannel is satisfied.
36685,36689c36340,36344
< &lt;informalexample&gt;
< &lt;programlisting&gt;
< GOnce my_once = G_ONCE_INIT;
< &lt;/programlisting&gt;
< &lt;/informalexample&gt;
---
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
36691c36346,36357
< Since: 2.4
---
> <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
36694a36361,36372
> <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>
36769,36772d36446
< <parameter name="Returns">
< <parameter_description> a new #GPrivate.
< </parameter_description>
< </parameter>
36774c36448,36449
< <return></return>
---
> <return> a new #GPrivate.
> </return>
36800,36803d36474
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
36805c36476,36477
< <return></return>
---
> <return> the #GArray.
> </return>
36832,36873d36503
< <function name="G_IO_CHANNEL_ERROR">
< <description>
< Error domain for #GIOChannel operations. Errors in this domain will
< be from the #GIOChannelError enumeration. See #GError for
< information on error domains.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
< <function name="GSequenceIterCompareFunc">
< <description>
< A #GSequenceIterCompareFunc is a function used to compare iterators.
< It must return zero if the iterators compare equal, a negative value
< if @a comes before @b, and a positive value if @b comes before @a.
< 
< </description>
< <parameters>
< <parameter name="a">
< <parameter_description> a #GSequenceIter
< </parameter_description>
< </parameter>
< <parameter name="b">
< <parameter_description> a #GSequenceIter
< </parameter_description>
< </parameter>
< <parameter name="data">
< <parameter_description> user data
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> zero if the iterators are equal, a negative value if @a
< comes before @b, and a positive value if @b comes before
< @a.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
36931a36562
> Since: 2.6
36948d36578
< Since: 2.6
36964,36967d36593
< <parameter name="Returns">
< <parameter_description> the #GMutex corresponding to @mutex.
< </parameter_description>
< </parameter>
36969c36595,36596
< <return></return>
---
> <return> the #GMutex corresponding to @mutex.
> </return>
36979a36607
> Since: 2.14
37004d36631
< Since: 2.14
37027a36655
> Since: 2.14
37046d36673
< Since: 2.14
37088,37130d36714
< <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>
< 
37162a36747
> Since: 2.4
37177d36761
< Since: 2.4
37226a36811
> Since: 2.12
37246d36830
< Since: 2.12
37252c36836,36837
< Return value: the #GMainContext of @loop
---
> Returns the #GMainContext of @loop.
> 
37265c36850
< <function name="g_io_channel_seek_position">
---
> <function name="module">
37267,37268d36851
< Replacement for g_io_channel_seek() with the new API.
< 
37272,37290d36854
< <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>
37292,37293c36856
< <return> the status of the operation.
< </return>
---
> <return></return>
37296c36859
< <function name="GHFunc">
---
> <function name="g_io_channel_seek_position">
37298,37300d36860
< Specifies the type of the function passed to g_hash_table_foreach().
< It is called with each key/value pair, together with the @user_data
< parameter which is passed to g_hash_table_foreach().
37304,37315d36863
< <parameter name="key">
< <parameter_description> a key.
< </parameter_description>
< </parameter>
< <parameter name="value">
< <parameter_description> the value corresponding to the key.
< </parameter_description>
< </parameter>
< <parameter name="user_data">
< <parameter_description> user data passed to g_hash_table_foreach().
< </parameter_description>
< </parameter>
37401a36950
> Since: 2.14
37440d36988
< Since: 2.14
37486a37035
> Since: 2.12
37506,37507c37055,37065
< Since: 2.12
< </return>
---
> </return>
> </function>
> 
> <function name="pattern">
> <description>
> directly.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
37556,37572d37113
< <function name="GCacheDestroyFunc">
< <description>
< Specifies the type of the @value_destroy_func and @key_destroy_func
< functions passed to g_cache_new(). The functions are passed a
< pointer to the #GCache key or #GCache value and should free any
< memory and other resources associated with it.
< 
< </description>
< <parameters>
< <parameter name="value">
< <parameter_description> the #GCache value to destroy.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
37575c37116,37118
< Return value: The data for the @n'th element of @queue, or %NULL if @n is
---
> Returns the @n'th element of @queue. 
> 
> Since: 2.4
37591d37133
< Since: 2.4
37635a37178
> Returns the pointer at the given index of the pointer array.
37647,37650d37189
< <parameter name="Returns">
< <parameter_description> the pointer at the given index.
< </parameter_description>
< </parameter>
37652c37191
< <return>the pointer at the given index of the pointer array.
---
> <return> the pointer at the given index.
37680a37220
> Since: 2.12
37703d37242
< Since: 2.12
37746a37286
> Since: 2.14
37771d37310
< Since: 2.14
37814c37353,37356
< Returns: new head of @list
---
> Returns the new head of the list. Contrast with 
> g_list_remove() which removes only the first node 
> matching the given data.
> 
37893a37436,37464
> <function name="allocated">
> <description>
> they are copied into the next free position in a block. When a block
> is full a new block is allocated.
> 
> When storing a large number of strings, string chunks are more
> efficient than using g_strdup() since fewer calls to malloc() are
> needed, and less memory is wasted in memory allocation overheads.
> 
> By adding strings with g_string_chunk_insert_const() it is also
> possible to remove duplicates.
> 
> To create a new #GStringChunk use g_string_chunk_new().
> 
> To add strings to a #GStringChunk use g_string_chunk_insert().
> 
> To add strings to a #GStringChunk, but without duplicating strings
> which are already in the #GStringChunk, use
> g_string_chunk_insert_const().
> 
> To free the entire #GStringChunk use g_string_chunk_free(). It is
> not possible to free individual strings.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
37903,37906d37473
< <parameter name="Returns">
< <parameter_description> a new #GMutex.
< </parameter_description>
< </parameter>
37908c37475,37476
< <return></return>
---
> <return> a new #GMutex.
> </return>
37930c37498,37500
< Return value: the data that @iter points to
---
> Returns the data that @iter points to.
> 
> Since: 2.14
37941d37510
< Since: 2.14
37962,37965d37530
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
37967c37532,37533
< <return></return>
---
> <return> the #GArray.
> </return>
37974a37541
> Since: 2.16
37989d37555
< Since: 2.16
38011a37578,37587
> <function name="controlled">
> <description>
> Since: 2.4
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
38039a37616
> Since: 2.6
38062d37638
< Since: 2.6
38124c37700
< <function name="GStaticPrivate">
---
> <function name="g_main_loop_quit">
38126,38140c37702,37703
< A #GStaticPrivate works almost like a #GPrivate, but it has one
< significant advantage. It doesn't need to be created at run-time
< like a #GPrivate, but can be defined at compile-time. This is
< similar to the difference between #GMutex and #GStaticMutex. Now
< look at our &lt;function&gt;give_me_next_number()&lt;/function&gt; example with
< #GStaticPrivate:
< 
< &lt;example&gt;
< &lt;title&gt;Using GStaticPrivate for per-thread data&lt;/title&gt;
< &lt;programlisting&gt;
< int
< give_me_next_number (&lt;!-- --&gt;)
< {
< static GStaticPrivate current_number_key = G_STATIC_PRIVATE_INIT;
< int *current_number = g_static_private_get (&amp;current_number_key);
---
> Stops a #GMainLoop from running. Any calls to g_main_loop_run()
> for the loop will return. 
38142,38147c37705,37706
< if (!current_number)
< {
< current_number = g_new (int,1);
< *current_number = 0;
< g_static_private_set (&amp;current_number_key, current_number, g_free);
< }
---
> Note that sources that have already been dispatched when 
> g_main_loop_quit() is called will still be executed.
38149c37708,37716
< *current_number = calc_next_number (*current_number);
---
> </description>
> <parameters>
> <parameter name="loop">
> <parameter_description> a #GMainLoop
> </parameter_description>
> </parameter>
> </parameters>
> <return></return>
> </function>
38151,38154c37718,37723
< return *current_number;
< }
< &lt;/programlisting&gt;
< &lt;/example&gt;
---
> <function name="value">
> <description>
> Specifies the type of a comparison function used to compare two
> values.  The function should return a negative integer if the first
> value comes before the second, 0 if they are equal, or a positive
> integer if the first value comes after the second.
38184,38215d37752
< <function name="GThreadPriority">
< <description>
< Specifies the priority of a thread.
< 
< &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="G_THREAD_PRIORITY_LOW">
< <parameter_description> a priority lower than normal
< </parameter_description>
< </parameter>
< <parameter name="G_THREAD_PRIORITY_NORMAL">
< <parameter_description> the default priority
< </parameter_description>
< </parameter>
< <parameter name="G_THREAD_PRIORITY_HIGH">
< <parameter_description> a priority higher than normal
< </parameter_description>
< </parameter>
< <parameter name="G_THREAD_PRIORITY_URGENT">
< <parameter_description> the highest priority
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
38272c37809,37813
< Return value: the global default main context.
---
> 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().
> 
38297,38316d37837
< <function name="GThreadFunc">
< <description>
< Specifies the type of the @func functions passed to
< g_thread_create() or g_thread_create_full().
< 
< </description>
< <parameters>
< <parameter name="data">
< <parameter_description> data passed to the thread.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> the return value of the thread, which will be returned by
< g_thread_join().
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
38345,38348d37865
< <parameter name="Returns">
< <parameter_description> the data element, or %NULL if it is not found.
< </parameter_description>
< </parameter>
38350c37867,37868
< <return></return>
---
> <return> the data element, or %NULL if it is not found.
> </return>
38386a37905
> Since: 2.12
38409d37927
< Since: 2.12
38443a37962
> Since: 2.12
38479d37997
< Since: 2.12
38506a38025
> Since: 2.4
38528d38046
< Since: 2.4
38561c38079,38083
< Return value: %TRUE if a key file could be loaded, %FALSE otherwise
---
> 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
38593d38114
< Since: 2.14
38599,38608c38120
< 
< </description>
< <parameters>
< <parameter name="value">
< <parameter_description> a handle #GVariant instance
< </parameter_description>
< </parameter>
< </parameters>
< <return> a #gint32
< the 32-bit signed integer value of @value.
---
> Returns the 32-bit signed integer value of @value.
38618,38624d38129
< </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).
38628,38629c38133,38134
< <parameter name="Returns">
< <parameter_description> a new #GTimer.
---
> <parameter name="value">
> <parameter_description> a handle #GVariant instance
38633c38138,38139
< <return></return>
---
> <return> a #gint32
> </return>
38636c38142
< <function name="GCacheNewFunc">
---
> <function name="g_timer_new">
38638,38640c38144,38145
< Specifies the type of the @value_new_func function passed to
< g_cache_new(). It is passed a #GCache key and should create the
< value corresponding to the key.
---
> Creates a new timer, and starts timing (i.e. g_timer_start() is
> implicitly called for you).
38644,38651d38148
< <parameter name="key">
< <parameter_description> a #GCache key.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> a new #GCache value corresponding to the key.
< </parameter_description>
< </parameter>
38653c38150,38151
< <return></return>
---
> <return> a new #GTimer.
> </return>
38677a38176
> Since: 2.8
38693d38191
< Since: 2.8
38700a38199
> Since: 2.16
38707d38205
< Since: 2.16
38798c38296,38298
< Return value: Whether @iter is the end iterator.
---
> Returns whether @iter is the end iterator
> 
> Since: 2.14
38809d38308
< Since: 2.14
38961c38460,38464
< Returns: the #GTypePlugin for the dynamic interface @interface_type
---
> 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().
> 
38981c38484,38487
< Return value: The #GSequenceIter at position @pos
---
> 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
38996d38501
< Since: 2.14
39030,39033d38534
< <parameter name="Returns">
< <parameter_description> the new #GMemChunk.
< </parameter_description>
< </parameter>
39035c38536,38537
< <return></return>
---
> <return> the new #GMemChunk.
> </return>
39275a38778
> Since: 2.16
39287d38789
< Since: 2.16
39367a38870
> Since: 2.16
39406d38908
< Since: 2.16
39433,39468d38934
< <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>
< 
39485,39520d38950
< <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>
< 
39525a38956,38958
> 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.
39536,39538d38968
< 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.
39561a38992,39057
> <function name="mutexes">
> <description>
> Threads act almost like processes, but unlike processes all threads
> of one process share the same memory. This is good, as it provides
> easy communication between the involved threads via this shared
> memory, and it is bad, because strange things (so called
> &quot;Heisenbugs&quot;) might happen if the program is not carefully designed.
> In particular, due to the concurrent nature of threads, no
> assumptions on the order of execution of code running in different
> threads can be made, unless order is explicitly forced by the
> programmer through synchronization primitives.
> 
> The aim of the thread related functions in GLib is to provide a
> portable means for writing multi-threaded software. There are
> primitives for mutexes to protect the access to portions of memory
> (#GMutex, #GStaticMutex, #G_LOCK_DEFINE, #GStaticRecMutex and
> #GStaticRWLock). There are primitives for condition variables to
> allow synchronization of threads (#GCond).  There are primitives for
> thread-private data - data that every thread has a private instance
> of (#GPrivate, #GStaticPrivate). Last but definitely not least there
> are primitives to portably create and manage threads (#GThread).
> 
> The threading system is initialized with g_thread_init(), which
> takes an optional custom thread implementation or %NULL for the
> default implementation. If you want to call g_thread_init() with a
> non-%NULL argument this must be done before executing any other GLib
> functions (except g_mem_set_vtable()). This is a requirement even if
> no threads are in fact ever created by the process.
> 
> Calling g_thread_init() with a %NULL argument is somewhat more
> relaxed. You may call any other glib functions in the main thread
> before g_thread_init() as long as g_thread_init() is not called from
> a glib callback, or with any locks held. However, many libraries
> above glib does not support late initialization of threads, so doing
> this should be avoided if possible.
> 
> Please note that since version 2.24 the GObject initialization
> function g_type_init() initializes threads (with a %NULL argument),
> so most applications, including those using Gtk+ will run with
> threads enabled. If you want a special thread implementation, make
> sure you call g_thread_init() before g_type_init() is called.
> 
> After calling g_thread_init(), GLib is completely thread safe (all
> global data is automatically locked), but individual data structure
> instances are not automatically locked for performance reasons. So,
> for example you must coordinate accesses to the same #GHashTable
> from multiple threads.  The two notable exceptions from this rule
> are #GMainLoop and #GAsyncQueue, which &lt;emphasis&gt;are&lt;/emphasis&gt;
> threadsafe and need no further application-level locking to be
> accessed from multiple threads.
> 
> To help debugging problems in multithreaded applications, GLib
> supports error-checking mutexes that will give you helpful error
> messages on common problems. To use error-checking mutexes, define
> the symbol #G_ERRORCHECK_MUTEXES when compiling the application.
> 
> </description>
> <parameters>
> <parameter name="see_also">
> <parameter_description> #GThreadPool, #GAsyncQueue
> </parameter_description>
> </parameter>
> </parameters>
> <return></return>
> </function>
> 
39663a39160
> Since: 2.20
39684d39180
< Since: 2.20
39699,39702d39194
< <parameter name="Returns">
< <parameter_description> a new #GRelation.
< </parameter_description>
< </parameter>
39704c39196,39197
< <return></return>
---
> <return> a new #GRelation.
> </return>
39710a39204
> Since: 2.14
39721d39214
< Since: 2.14
39794a39288,39300
> <function name="does">
> <description>
> available, but it does mean that the infrastructure is in place and
> that once you provide a thread implementation to g_thread_init(),
> GLib will be multi-thread safe. If #G_THREADS_ENABLED is not
> defined, then Glib is not, and cannot be, multi-thread safe.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
39797c39303,39304
< Return value: the maximal number of threads
---
> Returns the maximal number of threads for @pool.
> 
39838a39346
> Since: 2.16
39845d39352
< Since: 2.16
39875c39382
< <function name="G_LOCK_DEFINE_STATIC">
---
> <function name="g_object_interface_list_properties">
39877c39384,39390
< This works like #G_LOCK_DEFINE, but it creates a static object.
---
> 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
> 
39881,39882c39394,39400
< <parameter name="name">
< <parameter_description> the name of the lock.
---
> <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.
39886c39404,39408
< <return></return>
---
> <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>
39938,39964d39459
< <function name="GIOError">
< <description>
< #GIOError is only used by the deprecated functions
< g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().
< 
< </description>
< <parameters>
< <parameter name="G_IO_ERROR_NONE">
< <parameter_description> no error
< </parameter_description>
< </parameter>
< <parameter name="G_IO_ERROR_AGAIN">
< <parameter_description> an EAGAIN error occurred
< </parameter_description>
< </parameter>
< <parameter name="G_IO_ERROR_INVAL">
< <parameter_description> an EINVAL error occurred
< </parameter_description>
< </parameter>
< <parameter name="G_IO_ERROR_UNKNOWN">
< <parameter_description> another error occurred
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
40008a39504
> Since: 2.14
40019d39514
< Since: 2.14
40032a39528
> Since: 2.16
40039d39534
< Since: 2.16
40065,40098d39559
< <function name="GCacheDupFunc">
< <description>
< Specifies the type of the @key_dup_func function passed to
< g_cache_new(). The function is passed a key
< (&lt;emphasis&gt;not&lt;/emphasis&gt; a value as the prototype implies) and
< should return a duplicate of the key.
< 
< </description>
< <parameters>
< <parameter name="value">
< <parameter_description> the #GCache key to destroy (&lt;emphasis&gt;not&lt;/emphasis&gt; a
< #GCache value as it seems).
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> a copy of the #GCache key.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
< <function name="GData">
< <description>
< The #GData struct is an opaque data structure to represent a &lt;link
< linkend=&quot;glib-Keyed-Data-Lists&quot;&gt;Keyed Data List&lt;/link&gt;. It should
< only be accessed via the following functions.
< 
< </description>
< <parameters>
< </parameters>
< <return></return>
< </function>
< 
40105,40108d39565
< <parameter name="Returns">
< <parameter_description> the new #GPtrArray.
< </parameter_description>
< </parameter>
40110c39567,39568
< <return></return>
---
> <return> the new #GPtrArray.
> </return>
40215,40238d39672
< <function name="GDataForeachFunc">
< <description>
< Specifies the type of function passed to g_dataset_foreach(). It is
< called with each #GQuark id and associated data element, together
< with the @user_data parameter supplied to g_dataset_foreach().
< 
< </description>
< <parameters>
< <parameter name="key_id">
< <parameter_description> the #GQuark id to identifying the data element.
< </parameter_description>
< </parameter>
< <parameter name="data">
< <parameter_description> the data element.
< </parameter_description>
< </parameter>
< <parameter name="user_data">
< <parameter_description> user data passed to g_dataset_foreach().
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
40289a39724,39734
> <function name="quickly">
> <description>
> system uses such a pool to store the #GParamSpecs of the properties all object
> types.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
40308a39754
> Since: 2.2
40328d39773
< Since: 2.2
40360a39806
> Since: 2.22
40371d39816
< Since: 2.22
40426,40444d39870
< <parameter name="Returns">
< <parameter_description> the #GArray.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
< <function name="G_UNLOCK">
< <description>
< Works like g_mutex_unlock(), but for a lock defined with
< #G_LOCK_DEFINE.
< 
< </description>
< <parameters>
< <parameter name="name">
< <parameter_description> the name of the lock.
< </parameter_description>
< </parameter>
40446c39872,39873
< <return></return>
---
> <return> the #GArray.
> </return>
40486,40489c39913,39924
< <parameter name="Returns">
< <parameter_description> the #GByteArray.
< </parameter_description>
< </parameter>
---
> </parameters>
> <return> the #GByteArray.
> </return>
> </function>
> 
> <function name="function">
> <description>
> user data passed to g_node_traverse(). If the function returns
> %TRUE, then the traversal is stopped.
> 
> </description>
> <parameters>
40590c40025,40027
< Return value: the begin iterator for @seq.
---
> Returns the begin iterator for @seq.
> 
> Since: 2.14
40601d40037
< Since: 2.14
40725c40161,40166
< Return value: a #GSequenceIter which is @delta positions away from @iter.
---
> 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
40741d40181
< Since: 2.14
40797c40237,40238
< Returns: %TRUE if the queue is empty.
---
> Returns %TRUE if the queue is empty.
> 
40834a40276,40286
> <function name="functions">
> <description>
> pointer to the #GCache key or #GCache value and should free any
> memory and other resources associated with it.
> 
> </description>
> <parameters>
> </parameters>
> <return></return>
> </function>
> 
40838a40291
> Since: 2.14
40854d40306
< Since: 2.14
40858,40877d40309
< <function name="GCompletionFunc">
< <description>
< Specifies the type of the function passed to g_completion_new(). It
< should return the string corresponding to the given target item.
< This is used when you use data structures as #GCompletion items.
< 
< </description>
< <parameters>
< <parameter name="Param1">
< <parameter_description> the completion item.
< </parameter_description>
< </parameter>
< <parameter name="Returns">
< <parameter_description> the string corresponding to the item.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
41009,41026d40440
< <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>
< 
41157c40571,40573
< Returns: the length of the contents of @file.
---
> Returns the length of the contents of a #GMappedFile.
> 
> Since: 2.8
41168d40583
< Since: 2.8
41210a40626
> Since: 2.16
41225d40640
< Since: 2.16
41310a40726
> Since: 2.12
41321d40736
< Since: 2.12
41341a40757
> Since: 2.14
41365d40780
< Since: 2.14
41369,41385d40783
< <function name="GTuples">
< <description>
< The #GTuples struct is used to return records (or tuples) from the
< #GRelation by g_relation_select(). It only contains one public
< member - the number of records that matched. To access the matched
< records, you must use g_tuples_index().
< 
< </description>
< <parameters>
< <parameter name="len">
< <parameter_description> the number of records that matched.
< </parameter_description>
< </parameter>
< </parameters>
< <return></return>
< </function>
< 
