Iterates over a #GConfChangeSet by calling a #GConfChangeSetForeachFunc for each change in the set. See the description of #GConfChangeSetForeachFunc for details. You may not call gconf_change_set_remove() during the iteration, because you'll confuse the internal data structures and cause memory corruption. a #GConfChangeSet. function to call for each change in the change set. user data to pass to the #GConfChangeSetForeachFunc. Returns the user_data field of the #GConfChangeSet. a pointer to the user_data. a #GConfChangeSet. Sets the user_data and the destroy notification function fields of the #GConfChangeSet. a #GConfChangeSet. a #gpointer. a pointer to the function to be called during destroy. Creates a new #GConfClient using the default #GConfEngine. Normally this is the engine you want. If someone else is already using the default #GConfClient, this function returns the same one they're using, but with the reference count incremented. So you have to unref either way. It's important to call g_type_init() before using this GObject, to initialize the type system. a new #GConfClient. g_object_unref() when you're done. Creates a new #GConfClient with a specific #GConfEngine. Only specialized configuration-related programs should need to call this function. The returned #GConfClient should be unref'd when you're done with g_object_unref(). Remember to avoid using the #GConfEngine directly once you have a #GConfClient wrapper. a new #GConfClient. the #GConfEngine to use. Set @func as the default error handler for the #GConfClient. This handler would be called for all #GConfClient internal errors. pointer to the function to be called for error handling. Lists the subdirectories in @dir. The returned list contains allocated strings. Each string is the absolute path of a subdirectory. You should g_free() each string in the list, then g_slist_free() the list itself. Just like gconf_engine_all_dirs(), but uses #GConfClient caching and error-handling features. List of allocated subdirectory names. a #GConfClient. directory to get subdirectories from. Lists the key-value pairs in @dir. Does not list subdirectories; for that use gconf_client_all_dirs(). The returned list contains #GConfEntry objects. A #GConfEntry contains an <emphasis>absolute</emphasis> key and a value. The list is not recursive, it contains only the immediate children of @dir. To free the returned list, gconf_entry_free() each list element, then g_slist_free() the list itself. Just like gconf_engine_all_entries (), but uses #GConfClient caching and error-handling features. List of #GConfEntry. a #GConfClient. directory to list. Requests the list (%GCONF_VALUE_LIST) stored at @key. Automatically performs type-checking, so if a non-list is stored at @key, or the list does not contain elements of type @list_type, an error is returned. If no value is set or an error occurs, <symbol>NULL</symbol> is returned. Note that <symbol>NULL</symbol> is also the empty list, so if you need to distinguish the empty list from an unset value, you must use gconf_client_get () to obtain a raw #GConfValue. <emphasis>Remember that GConf lists can only store primitive types: %GCONF_VALUE_FLOAT, %GCONF_VALUE_INT, %GCONF_VALUE_BOOL, %GCONF_VALUE_STRING, %GCONF_VALUE_SCHEMA.</emphasis> Also remember that lists must be uniform, you may not mix types in the same list. The type of the list elements depends on @list_type. A #GConfValue with type %GCONF_VALUE_LIST normally stores a list of more #GConfValue objects. gconf_client_get_list() automatically converts to primitive C types. Thus, the list-&gt;data fields in the returned list contain: <informaltable pgwide="1" frame="none"> <tgroup cols="2"><colspec colwidth="2*"/><colspec colwidth="8*"/> <tbody> <row> <entry>%GCONF_VALUE_INT</entry> <entry>The integer itself, converted with GINT_TO_POINTER()</entry> </row> <row> <entry>%GCONF_VALUE_BOOL</entry> <entry>The bool itself, converted with GINT_TO_POINTER()</entry> </row> <row> <entry>%GCONF_VALUE_FLOAT</entry> <entry>A pointer to #gdouble, which should be freed with g_free()</entry> </row> <row> <entry>%GCONF_VALUE_STRING</entry> <entry>A pointer to #gchar, which should be freed with g_free()</entry> </row> <row> <entry>%GCONF_VALUE_SCHEMA</entry> <entry>A pointer to #GConfSchema, which should be freed with gconf_schema_free()</entry> </row> </tbody></tgroup></informaltable> In the %GCONF_VALUE_FLOAT and %GCONF_VALUE_STRING cases, you must g_free() each list element. In the %GCONF_VALUE_SCHEMA case you must gconf_schema_free() each element. In all cases you must free the list itself with g_slist_free(). Just like gconf_engine_get_list (), but uses #GConfClient caching and error-handling features. an allocated list, with elements as described above. a #GConfClient. key you want the value of. type of each list element. @namespace_section An opaque data type representing one or more configuration sources. Lists the subdirectories in @dir. The returned list contains allocated strings. Each string is the absolute path of a subdirectory. You should g_free() each string in the list, then g_slist_free() the list itself. List of allocated subdirectory names. a #GConfEngine. Directory to get subdirectories from. Lists the key-value pairs in @dir. Does not list subdirectories; for that use gconf_engine_all_dirs(). The returned list contains #GConfEntry objects. A #GConfEntry contains an <emphasis>absolute</emphasis> key and a value. The list is not recursive, it contains only the immediate children of @dir. To free the returned list, gconf_entry_free() each list element, then g_slist_free() the list itself. List of #GConfEntry. a #GConfEngine. Directory to list. Requests the list (%GCONF_VALUE_LIST) stored at @key. Automatically performs type-checking, so if a non-list is stored at @key, or the list does not contain elements of type @list_type, an error is returned. If no value is set or an error occurs, <symbol>NULL</symbol> is returned. Note that <symbol>NULL</symbol> is also the empty list, so if you need to distinguish the empty list from an unset value, you must use gconf_engine_get () to obtain a raw #GConfValue. <emphasis>Remember that GConf lists can only store primitive types: %GCONF_VALUE_FLOAT, %GCONF_VALUE_INT, %GCONF_VALUE_BOOL, %GCONF_VALUE_STRING, %GCONF_VALUE_SCHEMA.</emphasis> Also remember that lists must be uniform, you may not mix types in the same list. The type of the list elements depends on @list_type. A #GConfValue with type %GCONF_VALUE_LIST normally stores a list of more #GConfValue objects. gconf_engine_get_list() automatically converts to primitive C types. Thus, the list-&gt;data fields in the returned list contain: <informaltable pgwide="1" frame="none"> <tgroup cols="2"><colspec colwidth="2*"/><colspec colwidth="8*"/> <tbody> <row> <entry>%GCONF_VALUE_INT</entry> <entry>The integer itself, converted with GINT_TO_POINTER()</entry> </row> <row> <entry>%GCONF_VALUE_BOOL</entry> <entry>The bool itself, converted with GINT_TO_POINTER()</entry> </row> <row> <entry>%GCONF_VALUE_FLOAT</entry> <entry>A pointer to #gdouble, which should be freed with g_free()</entry> </row> <row> <entry>%GCONF_VALUE_STRING</entry> <entry>A pointer to #gchar, which should be freed with g_free()</entry> </row> <row> <entry>%GCONF_VALUE_SCHEMA</entry> <entry>A pointer to #GConfSchema, which should be freed with gconf_schema_free()</entry> </row> </tbody></tgroup></informaltable> In the %GCONF_VALUE_FLOAT and %GCONF_VALUE_STRING cases, you must g_free() each list element. In the %GCONF_VALUE_SCHEMA case you must gconf_schema_free() each element. In all cases you must free the list itself with g_slist_free(). an allocated list, with elements as described above. a #GConfEngine. key you want the value of. type of each list element. Requests the schema (%GCONF_VALUE_SCHEMA) stored at @key. Automatically performs type-checking, so if a non-schema is stored at @key, an error is returned. If no value is set or an error occurs, <symbol>NULL</symbol> is returned. the value of @key as an allocated #GConfSchema, or <symbol>NULL</symbol> if no value was obtained. a #GConfEngine. key you want the value of. an ID for the notification request, or 0 on error. a #GConfEngine to monitor for changes. the directory or key to watch; you will be notified of changes at or below this point. the callback to invoke when a notification is received from the server. the data to pass to the callback. Returns the default #GConfEngine. All clients should use this, unless they are special configuration-related tools. The caller of this function assumes one reference count, and must call gconf_engine_unref() at some point. It's fairly important to unref the #GConfEngine, to cleanly close the connection to <application>gconfd</application>. So if possible close the connection before exiting your application. the default #GConfEngine. The #GConfListeners structure contains nothing other than a dummy pointer. Internally the data about listeners is maintained through a listener table structure, LTable which contains data like the namespace, an array to hold the listeners, count of active listeners,value to be given to the next connection and the list of connection indices to be recycled. There is also a Listener structure maintaining data pertaining to listeners. An opaque data type representing a description of a key-value pair. Returns a #GSList containing #GConfValue objects. Each #GConfValue in the returned list will have the type returned by gconf_value_get_list_type(). Remember that the empty #GSList is equal to <symbol>NULL</symbol>. The list is not a copy; it is "owned" by the #GConfValue and will be destroyed when the #GConfValue is destroyed. a #GList. a #GConfValue. Detach from the config server and release all related resources Returns the default #GConfEngine. All clients should use this, unless they are special configuration-related tools. The caller of this function assumes one reference count, and must call gconf_engine_unref() at some point. It's fairly important to unref the #GConfEngine, to cleanly close the connection to <application>gconfd</application>. So if possible close the connection before exiting your application. the default #GConfEngine. Escape @arbitrary_text such that it's a valid key element (i.e. one part of the key path). The escaped key won't pass gconf_valid_key() because it isn't a whole key (i.e. it doesn't have a preceding slash), but prepending a slash to the escaped text should always result in a valid key. a nul-terminated valid GConf key some text in any encoding or format length of @arbitrary_text in bytes, or -1 if @arbitrary_text is nul-terminated Converts a string escaped with gconf_escape_key() back into its original form. the original string that was escaped to create @escaped_key a key created with gconf_escape_key() length of @escaped_key in bytes, or -1 if @escaped_key is nul-terminated