+Tue Sep 5 20:03:25 2000 Owen Taylor <otaylor@redhat.com>
+
+ * Moved into glib source tree, updated glib-sections.txt
+ and Makefile.am for glib-1.3.x.
+
2000-07-01 Damon Chaplin <damon@helixcode.com>
* tmpl/string_utils.sgml: updated g_strndup.
# The top-level SGML file.
DOC_MAIN_SGML_FILE=glib-docs.sgml
+# The directory containing the source code (if it contains documentation).
+DOC_SOURCE_DIR=$(top_srcdir)
TARGET_DIR=$(HTML_DIR)/$(DOC_MODULE)
+tmpl_sources = \
+ tmpl/allocators.sgml \
+ tmpl/arrays.sgml \
+ tmpl/arrays_byte.sgml \
+ tmpl/arrays_pointer.sgml \
+ tmpl/byte_order.sgml \
+ tmpl/caches.sgml \
+ tmpl/completion.sgml \
+ tmpl/datalist.sgml \
+ tmpl/datasets.sgml \
+ tmpl/date.sgml \
+ tmpl/glib-unused.sgml \
+ tmpl/hash_tables.sgml \
+ tmpl/hooks.sgml \
+ tmpl/iochannels.sgml \
+ tmpl/limits.sgml \
+ tmpl/linked_lists_double.sgml \
+ tmpl/linked_lists_single.sgml \
+ tmpl/macros.sgml \
+ tmpl/macros_misc.sgml \
+ tmpl/main.sgml \
+ tmpl/memory.sgml \
+ tmpl/memory_chunks.sgml \
+ tmpl/messages.sgml \
+ tmpl/misc_utils.sgml \
+ tmpl/modules.sgml \
+ tmpl/quarks.sgml \
+ tmpl/relations.sgml \
+ tmpl/scanner.sgml \
+ tmpl/string_chunks.sgml \
+ tmpl/string_utils.sgml \
+ tmpl/strings.sgml \
+ tmpl/threads.sgml \
+ tmpl/timers.sgml \
+ tmpl/trees-binary.sgml \
+ tmpl/trees-nary.sgml \
+ tmpl/type_conversion.sgml \
+ tmpl/types.sgml \
+ tmpl/warnings.sgml \
+ tmpl/windows.sgml
+
+glib_docdir = $(HTML_DIR)
+glib_doc_DATA = \
+ glib-decl.txt \
+ glib-sections.txt \
+ glib-overrides.txt
+
+EXTRA_DIST = \
+ $(glib_doc_DATA)
+
+html/book1.html: sgml/glib-doc.bottom
+ $(MAKE) html
+
+sgml/glib-doc.bottom: $(tmpl_sources)
+ $(MAKE) sgml
+
scan:
- gtkdoc-scan --module=$(DOC_MODULE) `glib-config --prefix`/include/glib.h `glib-config --prefix`/include/gmodule.h `glib-config --prefix`/lib/glib/include/glibconfig.h
+ -(cd $(srcdir) \
+ && gtkdoc-scan --module=$(DOC_MODULE) --source-dir=$(DOC_SOURCE_DIR) --ignore-headers="config.h gmoduleconf.h gunidecomp.h gunichartables.h glibconfig-sysdefs.h" )
templates: scan
- gtkdoc-mktmpl --module=$(DOC_MODULE)
+ cd $(srcdir) && gtkdoc-mktmpl --module=$(DOC_MODULE)
sgml:
- gtkdoc-mkdb --module=$(DOC_MODULE)
+ cd $(srcdir) \
+ && gtkdoc-mkdb --module=$(DOC_MODULE) --source-dir=$(DOC_SOURCE_DIR)
html:
- if ! test -d html ; then mkdir html ; fi
- -cd html && gtkdoc-mkhtml $(DOC_MODULE) ../$(DOC_MAIN_SGML_FILE)
+ test -d $(srcdir)/html || mkdir $(srcdir)/html
+ -cd $(srcdir)/html && gtkdoc-mkhtml $(DOC_MODULE) ../$(DOC_MAIN_SGML_FILE)
clean-local:
- rm -f *~ *.bak *.hierarchy *.signals *.args *-unused.txt
+ rm -f *~ *.bak *.signals *-unused.txt
maintainer-clean-local: clean
- rm -rf sgml html $(DOC_MODULE)-decl-list.txt $(DOC_MODULE)-decl.txt
+ cd $(srcdir) && rm -rf sgml html $(DOC_MODULE)-decl-list.txt $(DOC_MODULE)-decl.txt
install-data-local:
- install -d -m 0755 $(TARGET_DIR)
- install -m 0644 html/*.html $(TARGET_DIR)
- install -m 0644 html/index.sgml $(TARGET_DIR)
- gtkdoc-fixxref --module=$(DOC_MODULE) --html-dir=$(HTML_DIR)
-
-EXTRA_DIST = \
- $(DOC_MAIN_SGML_FILE) \
- $(DOC_MODULE)-sections.txt \
- glib-decl.txt \
- glib-overrides.txt
+ $(mkinstalldirs) $(DESTDIR)$(TARGET_DIR)
+ (installfiles=`echo $(srcdir)/html/*.html`; \
+ if test "$$installfiles" = '$(srcdir)/html/*.html'; \
+ then echo '-- Nothing to install' ; \
+ else \
+ for i in $$installfiles; do \
+ echo '-- Installing '$$i ; \
+ $(INSTALL_DATA) $$i $(DESTDIR)$(TARGET_DIR); \
+ done; \
+ echo '-- Installing $(srcdir)/html/index.sgml' ; \
+ $(INSTALL_DATA) $(srcdir)/html/index.sgml $(DESTDIR)$(TARGET_DIR); \
+ echo '-- Fixing Crossreferences' ; \
+ gtkdoc-fixxref --module=$(DOC_MODULE) --html-dir=$(HTML_DIR)|| true; \
+ fi)
dist-hook:
+ mkdir $(distdir)/html
+ mkdir $(distdir)/sgml
mkdir $(distdir)/tmpl
- cp -p tmpl/*.sgml $(distdir)/tmpl
+ -cp $(srcdir)/html/*.html $(srcdir)/html/*.css $(distdir)/html
+ -cp $(srcdir)/tmpl/*.sgml $(distdir)/tmpl
+ -cp $(srcdir)/sgml/*.sgml $(distdir)/sgml
+ -cp $(srcdir)/sgml/*.bottom $(srcdir)/sgml/*.top $(distdir)/sgml
.PHONY : html sgml templates scan
+++ /dev/null
-#!/bin/sh
-# Run this to generate all the initial makefiles, etc.
-
-srcdir=`dirname $0`
-test -z "$srcdir" && srcdir=.
-
-ORIGDIR=`pwd`
-cd $srcdir
-PROJECT=GLib-Reference
-TEST_TYPE=-f
-FILE=glib-sections.txt
-
-DIE=0
-
-(autoconf --version) < /dev/null > /dev/null 2>&1 || {
- echo
- echo "You must have autoconf installed to compile $PROJECT."
- echo "Download the appropriate package for your distribution,"
- echo "or get the source tarball at ftp://ftp.gnu.org/pub/gnu/"
- DIE=1
-}
-
-(automake --version) < /dev/null > /dev/null 2>&1 || {
- echo
- echo "You must have automake installed to compile $PROJECT."
- echo "Get ftp://sourceware.cygnus.com/pub/automake/automake-1.4.tar.gz"
- echo "(or a newer version if it is available)"
- DIE=1
-}
-
-if test "$DIE" -eq 1; then
- exit 1
-fi
-
-test $TEST_TYPE $FILE || {
- echo "You must run this script in the top-level $PROJECT directory"
- exit 1
-}
-
-if test -z "$*"; then
- echo "I am going to run ./configure with no arguments - if you wish "
- echo "to pass any to it, please specify them on the $0 command line."
-fi
-
-aclocal $ACLOCAL_FLAGS
-automake -a $am_opt
-autoconf
-cd $ORIGDIR
-
-$srcdir/configure --enable-maintainer-mode "$@"
-
-echo
-echo "Now type 'make' to compile $PROJECT."
+++ /dev/null
-dnl Process this file with autoconf to produce a configure script.
-
-AC_INIT(glib-sections.txt)
-
-AM_INIT_AUTOMAKE(glib-reference, 1.1.3)
-
-AC_ARG_WITH(html-dir, [ --with-html-dir=PATH path to installed docs ])
-
-AC_ISC_POSIX
-AC_PROG_CC
-
-if test "x$with_html_dir" = "x" ; then
- HTML_DIR='${datadir}/gtk-doc/html'
-else
- HTML_DIR=$with_html_dir
-fi
-
-AC_SUBST(HTML_DIR)
-
-AC_OUTPUT([Makefile])
-
+<STRUCT>
+<NAME>GError</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GError</NAME>
+struct GError
+{
+ GQuark domain;
+ gint code;
+ gchar *message;
+};
+</STRUCT>
+<FUNCTION>
+<NAME>g_error_new</NAME>
+<RETURNS>GError *</RETURNS>
+GQuark domain,gint code,const gchar *format,...
+</FUNCTION>
+<FUNCTION>
+<NAME>g_error_new_literal</NAME>
+<RETURNS>GError *</RETURNS>
+GQuark domain,gint code,const gchar *message
+</FUNCTION>
+<FUNCTION>
+<NAME>g_error_free</NAME>
+<RETURNS>void </RETURNS>
+GError *error
+</FUNCTION>
+<FUNCTION>
+<NAME>g_error_copy</NAME>
+<RETURNS>GError *</RETURNS>
+const GError *error
+</FUNCTION>
+<FUNCTION>
+<NAME>g_error_matches</NAME>
+<RETURNS>gboolean </RETURNS>
+const GError *error,GQuark domain,gint code
+</FUNCTION>
+<FUNCTION>
+<NAME>g_set_error</NAME>
+<RETURNS>void </RETURNS>
+GError **err,GQuark domain,gint code,const gchar *format,...
+</FUNCTION>
+<FUNCTION>
+<NAME>g_propagate_error</NAME>
+<RETURNS>void </RETURNS>
+GError **dest,GError *src
+</FUNCTION>
+<FUNCTION>
+<NAME>g_clear_error</NAME>
+<RETURNS>void </RETURNS>
+GError **err
+</FUNCTION>
+<MACRO>
+<NAME>G_GNUC_EXTENSION</NAME>
+# define G_GNUC_EXTENSION __extension__
+</MACRO>
+<MACRO>
+<NAME>G_GNUC_EXTENSION</NAME>
+# define G_GNUC_EXTENSION
+</MACRO>
+<MACRO>
+<NAME>G_E</NAME>
+#define G_E 2.7182818284590452354E0
+</MACRO>
+<MACRO>
+<NAME>G_LN2</NAME>
+#define G_LN2 6.9314718055994530942E-1
+</MACRO>
+<MACRO>
+<NAME>G_LN10</NAME>
+#define G_LN10 2.3025850929940456840E0
+</MACRO>
+<MACRO>
+<NAME>G_PI</NAME>
+#define G_PI 3.14159265358979323846E0
+</MACRO>
+<MACRO>
+<NAME>G_PI_2</NAME>
+#define G_PI_2 1.57079632679489661923E0
+</MACRO>
+<MACRO>
+<NAME>G_PI_4</NAME>
+#define G_PI_4 0.78539816339744830962E0
+</MACRO>
+<MACRO>
+<NAME>G_SQRT2</NAME>
+#define G_SQRT2 1.4142135623730950488E0
+</MACRO>
<MACRO>
<NAME>G_DIR_SEPARATOR</NAME>
#define G_DIR_SEPARATOR '\\'
</MACRO>
<MACRO>
<NAME>NULL</NAME>
-#define NULL ((void*) 0)
+# define NULL (0L)
+</MACRO>
+<MACRO>
+<NAME>NULL</NAME>
+# define NULL ((void*) 0)
</MACRO>
<MACRO>
<NAME>FALSE</NAME>
#define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
</MACRO>
<MACRO>
+<NAME>G_STRINGIFY</NAME>
+#define G_STRINGIFY(macro_or_string) G_STRINGIFY_ARG (macro_or_string)
+</MACRO>
+<MACRO>
+<NAME>G_STRINGIFY_ARG</NAME>
+#define G_STRINGIFY_ARG(contents) #contents
+</MACRO>
+<MACRO>
+<NAME>G_STRLOC</NAME>
+# define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) ":" __PRETTY_FUNCTION__ "()"
+</MACRO>
+<MACRO>
+<NAME>G_STRLOC</NAME>
+# define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__)
+</MACRO>
+<MACRO>
+<NAME>G_N_ELEMENTS</NAME>
+#define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0]))
+</MACRO>
+<MACRO>
<NAME>G_VA_COPY</NAME>
# define G_VA_COPY(ap1, ap2) (*(ap1) = *(ap2))
</MACRO>
<MACRO>
<NAME>G_STRUCT_OFFSET</NAME>
#define G_STRUCT_OFFSET(struct_type, member) \
- ((gulong) ((gchar*) &((struct_type*) 0)->member))
+ ((glong) ((guint8*) &((struct_type*) 0)->member))
</MACRO>
<MACRO>
<NAME>G_STRUCT_MEMBER_P</NAME>
#define G_STRUCT_MEMBER_P(struct_p, struct_offset) \
- ((gpointer) ((gchar*) (struct_p) + (gulong) (struct_offset)))
+ ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset)))
</MACRO>
<MACRO>
<NAME>G_STRUCT_MEMBER</NAME>
} G_STMT_END
</MACRO>
<MACRO>
-<NAME>g_string</NAME>
-#define g_string(x) #x
-</MACRO>
-<MACRO>
<NAME>g_assert</NAME>
#define g_assert(expr)
</MACRO>
#define g_return_val_if_fail(expr,val)
</MACRO>
<MACRO>
+<NAME>g_return_if_reached</NAME>
+#define g_return_if_reached() return
+</MACRO>
+<MACRO>
+<NAME>g_return_val_if_reached</NAME>
+#define g_return_val_if_reached(val) return (val)
+</MACRO>
+<MACRO>
<NAME>g_return_if_fail</NAME>
#define g_return_if_fail(expr) G_STMT_START{ \
if (!(expr)) \
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
- "file %s: line %d (%s): assertion `%s' failed.", \
+ "file %s: line %d (%s): assertion `%s' failed", \
__FILE__, \
__LINE__, \
__PRETTY_FUNCTION__, \
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
- "file %s: line %d (%s): assertion `%s' failed.", \
+ "file %s: line %d (%s): assertion `%s' failed", \
__FILE__, \
__LINE__, \
__PRETTY_FUNCTION__, \
#expr); \
- return val; \
+ return (val); \
}; }G_STMT_END
</MACRO>
<MACRO>
+<NAME>g_return_if_reached</NAME>
+#define g_return_if_reached() G_STMT_START{ \
+ g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ "file %s: line %d (%s): should not be reached", \
+ __FILE__, \
+ __LINE__, \
+ __PRETTY_FUNCTION__); \
+ return; }G_STMT_END
+</MACRO>
+<MACRO>
+<NAME>g_return_val_if_reached</NAME>
+#define g_return_val_if_reached(val) G_STMT_START{ \
+ g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ "file %s: line %d (%s): should not be reached", \
+ __FILE__, \
+ __LINE__, \
+ __PRETTY_FUNCTION__); \
+ return (val); }G_STMT_END
+</MACRO>
+<MACRO>
<NAME>g_return_if_fail</NAME>
#define g_return_if_fail(expr) G_STMT_START{ \
if (!(expr)) \
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
- "file %s: line %d: assertion `%s' failed.", \
+ "file %s: line %d: assertion `%s' failed", \
__FILE__, \
__LINE__, \
#expr); \
{ \
g_log (G_LOG_DOMAIN, \
G_LOG_LEVEL_CRITICAL, \
- "file %s: line %d: assertion `%s' failed.", \
+ "file %s: line %d: assertion `%s' failed", \
__FILE__, \
__LINE__, \
#expr); \
- return val; \
+ return (val); \
}; }G_STMT_END
</MACRO>
+<MACRO>
+<NAME>g_return_if_reached</NAME>
+#define g_return_if_reached() G_STMT_START{ \
+ g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ "file %s: line %d: should not be reached", \
+ __FILE__, \
+ __LINE__); \
+ return; }G_STMT_END
+</MACRO>
+<MACRO>
+<NAME>g_return_val_if_reached</NAME>
+#define g_return_val_if_reached(val) G_STMT_START{ \
+ g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ "file %s: line %d: should not be reached", \
+ __FILE__, \
+ __LINE__); \
+ return (val); }G_STMT_END
+</MACRO>
<TYPEDEF>
<NAME>gchar</NAME>
typedef char gchar;
typedef gint gboolean;
</TYPEDEF>
<TYPEDEF>
+<NAME>gstring</NAME>
+typedef gchar* gstring;
+</TYPEDEF>
+<TYPEDEF>
<NAME>guchar</NAME>
typedef unsigned char guchar;
</TYPEDEF>
<NAME>guint</NAME>
typedef unsigned int guint;
</TYPEDEF>
+<MACRO>
+<NAME>G_GSHORT_FORMAT</NAME>
+#define G_GSHORT_FORMAT "hi"
+</MACRO>
+<MACRO>
+<NAME>G_GUSHORT_FORMAT</NAME>
+#define G_GUSHORT_FORMAT "hu"
+</MACRO>
+<MACRO>
+<NAME>G_GINT_FORMAT</NAME>
+#define G_GINT_FORMAT "i"
+</MACRO>
+<MACRO>
+<NAME>G_GUINT_FORMAT</NAME>
+#define G_GUINT_FORMAT "u"
+</MACRO>
+<MACRO>
+<NAME>G_GLONG_FORMAT</NAME>
+#define G_GLONG_FORMAT "li"
+</MACRO>
+<MACRO>
+<NAME>G_GULONG_FORMAT</NAME>
+#define G_GULONG_FORMAT "lu"
+</MACRO>
<TYPEDEF>
<NAME>gfloat</NAME>
typedef float gfloat;
typedef const void *gconstpointer;
</TYPEDEF>
<TYPEDEF>
-<NAME>gssize</NAME>
-typedef gint32 gssize;
-</TYPEDEF>
-<TYPEDEF>
-<NAME>gsize</NAME>
-typedef guint32 gsize;
-</TYPEDEF>
-<TYPEDEF>
<NAME>GQuark</NAME>
typedef guint32 GQuark;
</TYPEDEF>
#define g_htons(val) (GUINT16_TO_BE (val))
</MACRO>
<MACRO>
-<NAME>GUTILS_C_VAR</NAME>
-# define GUTILS_C_VAR __declspec(dllexport)
+<NAME>GLIB_VAR</NAME>
+# define GLIB_VAR __declspec(dllexport)
</MACRO>
<MACRO>
-<NAME>GUTILS_C_VAR</NAME>
-# define GUTILS_C_VAR extern __declspec(dllimport)
+<NAME>GLIB_VAR</NAME>
+# define GLIB_VAR extern __declspec(dllimport)
</MACRO>
<MACRO>
-<NAME>GUTILS_C_VAR</NAME>
-# define GUTILS_C_VAR extern
+<NAME>GLIB_VAR</NAME>
+# define GLIB_VAR extern
</MACRO>
<MACRO>
<NAME>GLIB_CHECK_VERSION</NAME>
<NAME>GPtrArray</NAME>
</STRUCT>
<STRUCT>
+<NAME>GQueue</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GRand</NAME>
+</STRUCT>
+<STRUCT>
<NAME>GRelation</NAME>
</STRUCT>
<STRUCT>
<NAME>GTimer</NAME>
</STRUCT>
<STRUCT>
+<NAME>GTrashStack</NAME>
+</STRUCT>
+<STRUCT>
<NAME>GTree</NAME>
</STRUCT>
<STRUCT>
gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
-<NAME>GSearchFunc</NAME>
-<RETURNS>gint </RETURNS>
-gpointer key,
- gpointer data
-</USER_FUNCTION>
-<USER_FUNCTION>
<NAME>GScannerMsgFunc</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,
void
</USER_FUNCTION>
<STRUCT>
+<NAME>GArray</NAME>
+struct GArray
+{
+ gchar *data;
+ guint len;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GByteArray</NAME>
+struct GByteArray
+{
+ guint8 *data;
+ guint len;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GDebugKey</NAME>
+struct GDebugKey
+{
+ gchar *key;
+ guint value;
+};
+</STRUCT>
+<STRUCT>
<NAME>GList</NAME>
struct GList
{
};
</STRUCT>
<STRUCT>
+<NAME>GPtrArray</NAME>
+struct GPtrArray
+{
+ gpointer *pdata;
+ guint len;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GQueue</NAME>
+struct GQueue
+{
+ GList *head;
+ GList *tail;
+ guint length;
+};
+</STRUCT>
+<STRUCT>
<NAME>GSList</NAME>
struct GSList
{
};
</STRUCT>
<STRUCT>
-<NAME>GArray</NAME>
-struct GArray
+<NAME>GTrashStack</NAME>
+struct GTrashStack
{
- gchar *data;
- guint len;
+ GTrashStack *next;
};
</STRUCT>
<STRUCT>
-<NAME>GByteArray</NAME>
-struct GByteArray
+<NAME>GTuples</NAME>
+struct GTuples
{
- guint8 *data;
- guint len;
+ guint len;
};
</STRUCT>
-<STRUCT>
-<NAME>GPtrArray</NAME>
-struct GPtrArray
+<MACRO>
+<NAME>G_IEEE754_FLOAT_BIAS</NAME>
+#define G_IEEE754_FLOAT_BIAS (127)
+</MACRO>
+<MACRO>
+<NAME>G_IEEE754_DOUBLE_BIAS</NAME>
+#define G_IEEE754_DOUBLE_BIAS (1023)
+</MACRO>
+<MACRO>
+<NAME>G_LOG_2_BASE_10</NAME>
+#define G_LOG_2_BASE_10 (0.30102999566398119521)
+</MACRO>
+<UNION>
+<NAME>GFloatIEEE754</NAME>
+union GFloatIEEE754
{
- gpointer *pdata;
- guint len;
+ gfloat v_float;
+ struct {
+ guint mantissa : 23;
+ guint biased_exponent : 8;
+ guint sign : 1;
+ } mpn;
};
-</STRUCT>
-<STRUCT>
-<NAME>GTuples</NAME>
-struct GTuples
+</UNION>
+<UNION>
+<NAME>GDoubleIEEE754</NAME>
+union GDoubleIEEE754
{
- guint len;
+ gdouble v_double;
+ struct {
+ guint mantissa_low : 32;
+ guint mantissa_high : 20;
+ guint biased_exponent : 11;
+ guint sign : 1;
+ } mpn;
};
-</STRUCT>
-<STRUCT>
-<NAME>GDebugKey</NAME>
-struct GDebugKey
+</UNION>
+<UNION>
+<NAME>GFloatIEEE754</NAME>
+union GFloatIEEE754
{
- gchar *key;
- guint value;
+ gfloat v_float;
+ struct {
+ guint sign : 1;
+ guint biased_exponent : 8;
+ guint mantissa : 23;
+ } mpn;
};
-</STRUCT>
+</UNION>
+<UNION>
+<NAME>GDoubleIEEE754</NAME>
+union GDoubleIEEE754
+{
+ gdouble v_double;
+ struct {
+ guint sign : 1;
+ guint biased_exponent : 11;
+ guint mantissa_high : 20;
+ guint mantissa_low : 32;
+ } mpn;
+};
+</UNION>
<FUNCTION>
<NAME>g_list_push_allocator</NAME>
<RETURNS>void </RETURNS>
<FUNCTION>
<NAME>g_list_remove</NAME>
<RETURNS>GList *</RETURNS>
-GList *list,gpointer data
+GList *list,gconstpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_list_remove_link</NAME>
GList *list,GList *llink
</FUNCTION>
<FUNCTION>
+<NAME>g_list_delete_link</NAME>
+<RETURNS>GList *</RETURNS>
+GList *list,GList *link
+</FUNCTION>
+<FUNCTION>
<NAME>g_list_reverse</NAME>
<RETURNS>GList *</RETURNS>
GList *list
<FUNCTION>
<NAME>g_list_find</NAME>
<RETURNS>GList *</RETURNS>
-GList *list,gpointer data
+GList *list,gconstpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_list_find_custom</NAME>
<RETURNS>GList *</RETURNS>
-GList *list,gpointer data,GCompareFunc func
+GList *list,gconstpointer data,GCompareFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_list_position</NAME>
<FUNCTION>
<NAME>g_list_index</NAME>
<RETURNS>gint </RETURNS>
-GList *list,gpointer data
+GList *list,gconstpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_list_last</NAME>
GSList *list,gpointer data,GCompareFunc func
</FUNCTION>
<FUNCTION>
+<NAME>g_slist_insert_before</NAME>
+<RETURNS>GSList *</RETURNS>
+GSList *slist,GSList *sibling,gpointer data
+</FUNCTION>
+<FUNCTION>
<NAME>g_slist_concat</NAME>
<RETURNS>GSList *</RETURNS>
GSList *list1,GSList *list2
<FUNCTION>
<NAME>g_slist_remove</NAME>
<RETURNS>GSList *</RETURNS>
-GSList *list,gpointer data
+GSList *list,gconstpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_slist_remove_link</NAME>
<RETURNS>GSList *</RETURNS>
-GSList *list,GSList *llink
+GSList *list,GSList *link
+</FUNCTION>
+<FUNCTION>
+<NAME>g_slist_delete_link</NAME>
+<RETURNS>GSList *</RETURNS>
+GSList *list,GSList *link
</FUNCTION>
<FUNCTION>
<NAME>g_slist_reverse</NAME>
<FUNCTION>
<NAME>g_slist_find</NAME>
<RETURNS>GSList *</RETURNS>
-GSList *list,gpointer data
+GSList *list,gconstpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_slist_find_custom</NAME>
<RETURNS>GSList *</RETURNS>
-GSList *list,gpointer data,GCompareFunc func
+GSList *list,gconstpointer data,GCompareFunc func
</FUNCTION>
<FUNCTION>
<NAME>g_slist_position</NAME>
<FUNCTION>
<NAME>g_slist_index</NAME>
<RETURNS>gint </RETURNS>
-GSList *list,gpointer data
+GSList *list,gconstpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_slist_last</NAME>
</FUNCTION>
<MACRO>
<NAME>g_slist_next</NAME>
-#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL)
+#define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL)
</MACRO>
<FUNCTION>
+<NAME>g_queue_new</NAME>
+<RETURNS>GQueue *</RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_free</NAME>
+<RETURNS>void </RETURNS>
+GQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_push_head</NAME>
+<RETURNS>void </RETURNS>
+GQueue *queue,gpointer data
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_push_tail</NAME>
+<RETURNS>void </RETURNS>
+GQueue *queue,gpointer data
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_pop_head</NAME>
+<RETURNS>gpointer </RETURNS>
+GQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_pop_tail</NAME>
+<RETURNS>gpointer </RETURNS>
+GQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_is_empty</NAME>
+<RETURNS>gboolean </RETURNS>
+GQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_peek_head</NAME>
+<RETURNS>gpointer </RETURNS>
+GQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_peek_tail</NAME>
+<RETURNS>gpointer </RETURNS>
+GQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_push_head_link</NAME>
+<RETURNS>void </RETURNS>
+GQueue *queue,GList *link
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_push_tail_link</NAME>
+<RETURNS>void </RETURNS>
+GQueue *queue,GList *link
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_pop_head_link</NAME>
+<RETURNS>GList *</RETURNS>
+GQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_queue_pop_tail_link</NAME>
+<RETURNS>GList *</RETURNS>
+GQueue *queue
+</FUNCTION>
+<FUNCTION>
<NAME>g_hash_table_new</NAME>
<RETURNS>GHashTable *</RETURNS>
GHashFunc hash_func,GCompareFunc key_compare_func
GHashTable *hash_table,gconstpointer lookup_key,gpointer *orig_key,gpointer *value
</FUNCTION>
<FUNCTION>
-<NAME>g_hash_table_freeze</NAME>
+<NAME>g_hash_table_foreach</NAME>
<RETURNS>void </RETURNS>
-GHashTable *hash_table
-</FUNCTION>
-<FUNCTION>
-<NAME>g_hash_table_thaw</NAME>
-<RETURNS>void </RETURNS>
-GHashTable *hash_table
-</FUNCTION>
-<FUNCTION>
-<NAME>g_hash_table_foreach</NAME>
-<RETURNS>void </RETURNS>
-GHashTable *hash_table,GHFunc func,gpointer user_data
+GHashTable *hash_table,GHFunc func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_foreach_remove</NAME>
GHashTable *hash_table
</FUNCTION>
<FUNCTION>
+<NAME>g_hash_table_freeze</NAME>
+<RETURNS>void </RETURNS>
+GHashTable *hash_table
+</FUNCTION>
+<FUNCTION>
+<NAME>g_hash_table_thaw</NAME>
+<RETURNS>void </RETURNS>
+GHashTable *hash_table
+</FUNCTION>
+<FUNCTION>
<NAME>g_cache_new</NAME>
<RETURNS>GCache *</RETURNS>
GCacheNewFunc value_new_func,GCacheDestroyFunc value_destroy_func,GCacheDupFunc key_dup_func,GCacheDestroyFunc key_destroy_func,GHashFunc hash_key_func,GHashFunc hash_value_func,GCompareFunc key_compare_func
<FUNCTION>
<NAME>g_cache_remove</NAME>
<RETURNS>void </RETURNS>
-GCache *cache,gpointer value
+GCache *cache,gconstpointer value
</FUNCTION>
<FUNCTION>
<NAME>g_cache_key_foreach</NAME>
<FUNCTION>
<NAME>g_tree_remove</NAME>
<RETURNS>void </RETURNS>
-GTree *tree,gpointer key
+GTree *tree,gconstpointer key
</FUNCTION>
<FUNCTION>
<NAME>g_tree_lookup</NAME>
<RETURNS>gpointer </RETURNS>
-GTree *tree,gpointer key
+GTree *tree,gconstpointer key
</FUNCTION>
<FUNCTION>
<NAME>g_tree_traverse</NAME>
<FUNCTION>
<NAME>g_tree_search</NAME>
<RETURNS>gpointer </RETURNS>
-GTree *tree,GSearchFunc search_func,gpointer data
+GTree *tree,GCompareFunc search_func,gconstpointer data
</FUNCTION>
<FUNCTION>
<NAME>g_tree_height</NAME>
GNode *node
</FUNCTION>
<FUNCTION>
+<NAME>g_node_copy</NAME>
+<RETURNS>GNode *</RETURNS>
+GNode *node
+</FUNCTION>
+<FUNCTION>
<NAME>g_node_insert</NAME>
<RETURNS>GNode *</RETURNS>
GNode *parent,gint position,GNode *node
</MACRO>
<MACRO>
<NAME>g_error</NAME>
-#define g_error(format, args...) g_log (G_LOG_DOMAIN, \
- G_LOG_LEVEL_ERROR, \
- format, ##args)
+#define g_error(...) g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_ERROR, \
+ __VA_ARGS__)
+</MACRO>
+<MACRO>
+<NAME>g_message</NAME>
+#define g_message(...) g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_MESSAGE, \
+ __VA_ARGS__)
+</MACRO>
+<MACRO>
+<NAME>g_critical</NAME>
+#define g_critical(...) g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ __VA_ARGS__)
+</MACRO>
+<MACRO>
+<NAME>g_warning</NAME>
+#define g_warning(...) g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_WARNING, \
+ __VA_ARGS__)
+</MACRO>
+<MACRO>
+<NAME>g_error</NAME>
+#define g_error(format...) g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_ERROR, \
+ format)
</MACRO>
<MACRO>
<NAME>g_message</NAME>
-#define g_message(format, args...) g_log (G_LOG_DOMAIN, \
- G_LOG_LEVEL_MESSAGE, \
- format, ##args)
+#define g_message(format...) g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_MESSAGE, \
+ format)
+</MACRO>
+<MACRO>
+<NAME>g_critical</NAME>
+#define g_critical(format...) g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_CRITICAL, \
+ format)
</MACRO>
<MACRO>
<NAME>g_warning</NAME>
-#define g_warning(format, args...) g_log (G_LOG_DOMAIN, \
- G_LOG_LEVEL_WARNING, \
- format, ##args)
+#define g_warning(format...) g_log (G_LOG_DOMAIN, \
+ G_LOG_LEVEL_WARNING, \
+ format)
</MACRO>
<USER_FUNCTION>
<NAME>GPrintFunc</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
+<MACRO>
+<NAME>G_MICROSEC</NAME>
+#define G_MICROSEC 1000000
+</MACRO>
<FUNCTION>
<NAME>g_timer_new</NAME>
<RETURNS>GTimer *</RETURNS>
<RETURNS>gdouble </RETURNS>
GTimer *timer,gulong *microseconds
</FUNCTION>
+<FUNCTION>
+<NAME>g_usleep</NAME>
+<RETURNS>void </RETURNS>
+gulong microseconds
+</FUNCTION>
<MACRO>
<NAME>G_STR_DELIMITERS</NAME>
#define G_STR_DELIMITERS "_-|> <."
gchar *string,const gchar *delimiters,gchar new_delimiter
</FUNCTION>
<FUNCTION>
+<NAME>g_strcanon</NAME>
+<RETURNS>gchar *</RETURNS>
+gchar *string,const gchar *valid_chars,gchar subsitutor
+</FUNCTION>
+<FUNCTION>
<NAME>g_strtod</NAME>
<RETURNS>gdouble </RETURNS>
const gchar *nptr,gchar **endptr
</FUNCTION>
<FUNCTION>
<NAME>g_strdown</NAME>
-<RETURNS>void </RETURNS>
+<RETURNS>gchar *</RETURNS>
gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_strup</NAME>
-<RETURNS>void </RETURNS>
+<RETURNS>gchar *</RETURNS>
gchar *string
</FUNCTION>
<FUNCTION>
<NAME>g_strreverse</NAME>
-<RETURNS>void </RETURNS>
+<RETURNS>gchar *</RETURNS>
gchar *string
</FUNCTION>
<FUNCTION>
+<NAME>g_strlcpy</NAME>
+<RETURNS>gsize </RETURNS>
+gchar *dest,const gchar *src,gsize dest_size
+</FUNCTION>
+<FUNCTION>
+<NAME>g_strlcat</NAME>
+<RETURNS>gsize </RETURNS>
+gchar *dest,const gchar *src,gsize dest_size
+</FUNCTION>
+<FUNCTION>
<NAME>g_strchug</NAME>
<RETURNS>gchar *</RETURNS>
gchar *string
const gchar *separator,...
</FUNCTION>
<FUNCTION>
+<NAME>g_strcompress</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *source
+</FUNCTION>
+<FUNCTION>
+<NAME>g_filename_to_utf8</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *opsysstring
+</FUNCTION>
+<FUNCTION>
+<NAME>g_filename_from_utf8</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *utf8string
+</FUNCTION>
+<FUNCTION>
<NAME>g_strescape</NAME>
<RETURNS>gchar *</RETURNS>
-gchar *string
+const gchar *source,const gchar *exceptions
</FUNCTION>
<FUNCTION>
<NAME>g_memdup</NAME>
gchar *string,gulong n,gchar const *format,va_list args
</FUNCTION>
<FUNCTION>
-<NAME>g_basename</NAME>
-<RETURNS>gchar *</RETURNS>
-const gchar *file_name
-</FUNCTION>
-<FUNCTION>
<NAME>g_path_is_absolute</NAME>
<RETURNS>gboolean </RETURNS>
const gchar *file_name
gchar *file_name
</FUNCTION>
<FUNCTION>
+<NAME>g_basename</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *file_name
+</FUNCTION>
+<FUNCTION>
<NAME>g_dirname</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *file_name
void
</FUNCTION>
<FUNCTION>
+<NAME>g_path_get_basename</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *file_name
+</FUNCTION>
+<FUNCTION>
+<NAME>g_path_get_dirname</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *file_name
+</FUNCTION>
+<FUNCTION>
<NAME>g_getenv</NAME>
<RETURNS>gchar *</RETURNS>
const gchar *variable
guint number
</FUNCTION>
<FUNCTION>
+<NAME>g_trash_stack_push</NAME>
+<RETURNS>void </RETURNS>
+GTrashStack **stack_p,gpointer data_p
+</FUNCTION>
+<FUNCTION>
+<NAME>g_trash_stack_pop</NAME>
+<RETURNS>gpointer </RETURNS>
+GTrashStack **stack_p
+</FUNCTION>
+<FUNCTION>
+<NAME>g_trash_stack_peek</NAME>
+<RETURNS>gpointer </RETURNS>
+GTrashStack **stack_p
+</FUNCTION>
+<FUNCTION>
+<NAME>g_trash_stack_height</NAME>
+<RETURNS>guint </RETURNS>
+GTrashStack **stack_p
+</FUNCTION>
+<FUNCTION>
<NAME>g_string_chunk_new</NAME>
<RETURNS>GStringChunk *</RETURNS>
gint size
<FUNCTION>
<NAME>g_string_new</NAME>
<RETURNS>GString *</RETURNS>
-const gchar *init
+const gchar *init
</FUNCTION>
<FUNCTION>
<NAME>g_string_sized_new</NAME>
<RETURNS>GString *</RETURNS>
-guint dfl_size
+guint dfl_size
</FUNCTION>
<FUNCTION>
<NAME>g_string_free</NAME>
-<RETURNS>void </RETURNS>
-GString *string,gint free_segment
+<RETURNS>gchar *</RETURNS>
+GString *string,gboolean free_segment
+</FUNCTION>
+<FUNCTION>
+<NAME>g_string_equal</NAME>
+<RETURNS>gboolean </RETURNS>
+const GString *v,const GString *v2
+</FUNCTION>
+<FUNCTION>
+<NAME>g_string_hash</NAME>
+<RETURNS>guint </RETURNS>
+const GString *str
</FUNCTION>
<FUNCTION>
<NAME>g_string_assign</NAME>
<RETURNS>GString *</RETURNS>
-GString *lval,const gchar *rval
+GString *string,const gchar *rval
</FUNCTION>
<FUNCTION>
<NAME>g_string_truncate</NAME>
<RETURNS>GString *</RETURNS>
-GString *string,gint len
+GString *string,guint len
+</FUNCTION>
+<FUNCTION>
+<NAME>g_string_insert_len</NAME>
+<RETURNS>GString *</RETURNS>
+GString *string,gint pos,const gchar *val,gint len
</FUNCTION>
<FUNCTION>
<NAME>g_string_append</NAME>
<RETURNS>GString *</RETURNS>
-GString *string,const gchar *val
+GString *string,const gchar *val
+</FUNCTION>
+<FUNCTION>
+<NAME>g_string_append_len</NAME>
+<RETURNS>GString *</RETURNS>
+GString *string,const gchar *val,gint len
</FUNCTION>
<FUNCTION>
<NAME>g_string_append_c</NAME>
<RETURNS>GString *</RETURNS>
-GString *string,gchar c
+GString *string,gchar c
</FUNCTION>
<FUNCTION>
<NAME>g_string_prepend</NAME>
<RETURNS>GString *</RETURNS>
-GString *string,const gchar *val
+GString *string,const gchar *val
</FUNCTION>
<FUNCTION>
<NAME>g_string_prepend_c</NAME>
<RETURNS>GString *</RETURNS>
-GString *string,gchar c
+GString *string,gchar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_string_prepend_len</NAME>
+<RETURNS>GString *</RETURNS>
+GString *string,const gchar *val,gint len
</FUNCTION>
<FUNCTION>
<NAME>g_string_insert</NAME>
<RETURNS>GString *</RETURNS>
-GString *string,gint pos,const gchar *val
+GString *string,gint pos,const gchar *val
</FUNCTION>
<FUNCTION>
<NAME>g_string_insert_c</NAME>
<RETURNS>GString *</RETURNS>
-GString *string,gint pos,gchar c
+GString *string,gint pos,gchar c
</FUNCTION>
<FUNCTION>
<NAME>g_string_erase</NAME>
<RETURNS>GString *</RETURNS>
-GString *string,gint pos,gint len
+GString *string,gint pos,gint len
</FUNCTION>
<FUNCTION>
<NAME>g_string_down</NAME>
</FUNCTION>
<FUNCTION>
<NAME>g_string_sprintf</NAME>
-<RETURNS>void </RETURNS>
-GString *string,const gchar *format,...
+<RETURNS>void </RETURNS>
+GString *string,const gchar *format,...
</FUNCTION>
<FUNCTION>
<NAME>g_string_sprintfa</NAME>
-<RETURNS>void </RETURNS>
-GString *string,const gchar *format,...
+<RETURNS>void </RETURNS>
+GString *string,const gchar *format,...
</FUNCTION>
<MACRO>
<NAME>g_array_append_val</NAME>
gboolean zero_terminated,gboolean clear,guint element_size
</FUNCTION>
<FUNCTION>
+<NAME>g_array_sized_new</NAME>
+<RETURNS>GArray *</RETURNS>
+gboolean zero_terminated,gboolean clear,guint element_size,guint reserved_size
+</FUNCTION>
+<FUNCTION>
<NAME>g_array_free</NAME>
-<RETURNS>void </RETURNS>
+<RETURNS>gchar *</RETURNS>
GArray *array,gboolean free_segment
</FUNCTION>
<FUNCTION>
void
</FUNCTION>
<FUNCTION>
+<NAME>g_ptr_array_sized_new</NAME>
+<RETURNS>GPtrArray *</RETURNS>
+guint reserved_size
+</FUNCTION>
+<FUNCTION>
<NAME>g_ptr_array_free</NAME>
-<RETURNS>void </RETURNS>
+<RETURNS>gpointer *</RETURNS>
GPtrArray *array,gboolean free_seg
</FUNCTION>
<FUNCTION>
void
</FUNCTION>
<FUNCTION>
+<NAME>g_byte_array_sized_new</NAME>
+<RETURNS>GByteArray *</RETURNS>
+guint reserved_size
+</FUNCTION>
+<FUNCTION>
<NAME>g_byte_array_free</NAME>
-<RETURNS>void </RETURNS>
+<RETURNS>guint8 *</RETURNS>
GByteArray *array,gboolean free_segment
</FUNCTION>
<FUNCTION>
</FUNCTION>
<FUNCTION>
<NAME>g_str_equal</NAME>
-<RETURNS>gint </RETURNS>
+<RETURNS>gboolean </RETURNS>
gconstpointer v,gconstpointer v2
</FUNCTION>
<FUNCTION>
<NAME>g_str_hash</NAME>
-<RETURNS>guint </RETURNS>
+<RETURNS>guint </RETURNS>
gconstpointer v
</FUNCTION>
<FUNCTION>
<NAME>g_int_equal</NAME>
-<RETURNS>gint </RETURNS>
+<RETURNS>gint </RETURNS>
gconstpointer v,gconstpointer v2
</FUNCTION>
<FUNCTION>
<NAME>g_int_hash</NAME>
-<RETURNS>guint </RETURNS>
+<RETURNS>guint </RETURNS>
gconstpointer v
</FUNCTION>
<FUNCTION>
</FUNCTION>
<FUNCTION>
<NAME>g_datalist_id_remove_no_notify</NAME>
-<RETURNS>void </RETURNS>
+<RETURNS>gpointer </RETURNS>
GData **datalist,GQuark key_id
</FUNCTION>
<FUNCTION>
</FUNCTION>
<FUNCTION>
<NAME>g_dataset_id_remove_no_notify</NAME>
-<RETURNS>void </RETURNS>
+<RETURNS>gpointer </RETURNS>
gconstpointer dataset_location,GQuark key_id
</FUNCTION>
<FUNCTION>
#define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz"
</MACRO>
<MACRO>
+<NAME>G_CSET_DIGITS</NAME>
+#define G_CSET_DIGITS "0123456789"
+</MACRO>
+<MACRO>
<NAME>G_CSET_LATINC</NAME>
#define G_CSET_LATINC "\300\301\302\303\304\305\306"\
"\307\310\311\312\313\314\315\316\317\320"\
GScanner *scanner,const gchar *symbol
</FUNCTION>
<FUNCTION>
-<NAME>g_scanner_freeze_symbol_table</NAME>
-<RETURNS>void </RETURNS>
-GScanner *scanner
-</FUNCTION>
-<FUNCTION>
-<NAME>g_scanner_thaw_symbol_table</NAME>
-<RETURNS>void </RETURNS>
-GScanner *scanner
-</FUNCTION>
-<FUNCTION>
<NAME>g_scanner_unexp_token</NAME>
<RETURNS>void </RETURNS>
GScanner *scanner,GTokenType expected_token,const gchar *identifier_spec,const gchar *symbol_spec,const gchar *symbol_name,const gchar *message,gint is_error
g_scanner_scope_foreach_symbol ((scanner), 0, (func), (data)); \
} G_STMT_END
</MACRO>
+<FUNCTION>
+<NAME>g_scanner_freeze_symbol_table</NAME>
+<RETURNS>void </RETURNS>
+GScanner *scanner
+</FUNCTION>
+<FUNCTION>
+<NAME>g_scanner_thaw_symbol_table</NAME>
+<RETURNS>void </RETURNS>
+GScanner *scanner
+</FUNCTION>
<STRUCT>
<NAME>GCompletion</NAME>
struct GCompletion
GTuples *tuples,gint index,gint field
</FUNCTION>
<FUNCTION>
+<NAME>g_rand_new_with_seed</NAME>
+<RETURNS>GRand *</RETURNS>
+guint32 seed
+</FUNCTION>
+<FUNCTION>
+<NAME>g_rand_new</NAME>
+<RETURNS>GRand *</RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_rand_free</NAME>
+<RETURNS>void </RETURNS>
+GRand *rand
+</FUNCTION>
+<FUNCTION>
+<NAME>g_rand_set_seed</NAME>
+<RETURNS>void </RETURNS>
+GRand *rand,guint32 seed
+</FUNCTION>
+<FUNCTION>
+<NAME>g_rand_int</NAME>
+<RETURNS>guint32 </RETURNS>
+GRand *rand
+</FUNCTION>
+<FUNCTION>
+<NAME>g_rand_int_range</NAME>
+<RETURNS>gint32 </RETURNS>
+GRand *rand,gint32 min,gint32 max
+</FUNCTION>
+<FUNCTION>
+<NAME>g_rand_double</NAME>
+<RETURNS>gdouble </RETURNS>
+GRand *rand
+</FUNCTION>
+<FUNCTION>
+<NAME>g_rand_double_range</NAME>
+<RETURNS>gdouble </RETURNS>
+GRand *rand,gdouble min,gdouble max
+</FUNCTION>
+<FUNCTION>
+<NAME>g_random_set_seed</NAME>
+<RETURNS>void </RETURNS>
+guint32 seed
+</FUNCTION>
+<FUNCTION>
+<NAME>g_random_int</NAME>
+<RETURNS>guint32 </RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_random_int_range</NAME>
+<RETURNS>gint32 </RETURNS>
+gint32 min,gint32 max
+</FUNCTION>
+<FUNCTION>
+<NAME>g_random_double</NAME>
+<RETURNS>gdouble </RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_random_double_range</NAME>
+<RETURNS>gdouble </RETURNS>
+gdouble min,gdouble max
+</FUNCTION>
+<FUNCTION>
<NAME>g_spaced_primes_closest</NAME>
<RETURNS>guint </RETURNS>
guint num
GTimeVal *current_time,
gpointer user_data);
gboolean (*dispatch) (gpointer source_data,
- GTimeVal *current_time,
+ GTimeVal *dispatch_time,
gpointer user_data);
GDestroyNotify destroy;
};
<FUNCTION>
<NAME>g_get_current_time</NAME>
<RETURNS>void </RETURNS>
-GTimeVal *result
+GTimeVal *result
</FUNCTION>
<FUNCTION>
<NAME>g_main_new</NAME>
GPollFunc func
</FUNCTION>
<FUNCTION>
+<NAME>g_main_win32_get_poll_func</NAME>
+<RETURNS>GPollFunc </RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
<NAME>g_io_channel_unix_new</NAME>
<RETURNS>GIOChannel *</RETURNS>
int fd
#define G_WIN32_MSG_HANDLE 19981206
</MACRO>
<FUNCTION>
-<NAME>g_main_poll_win32_msg_add</NAME>
+<NAME>g_io_channel_win32_make_pollfd</NAME>
<RETURNS>void </RETURNS>
-gint priority,GPollFD *fd,guint hwnd
+GIOChannel *channel,GIOCondition condition,GPollFD *fd
</FUNCTION>
<FUNCTION>
-<NAME>g_io_channel_win32_new_messages</NAME>
-<RETURNS>GIOChannel *</RETURNS>
-guint hwnd
+<NAME>g_io_channel_win32_poll</NAME>
+<RETURNS>gint </RETURNS>
+GPollFD *fds,gint n_fds,gint timeout
</FUNCTION>
<FUNCTION>
-<NAME>g_io_channel_win32_new_pipe</NAME>
-<RETURNS>GIOChannel *</RETURNS>
-int fd
+<NAME>g_main_poll_win32_msg_add</NAME>
+<RETURNS>void </RETURNS>
+gint priority,GPollFD *fd,guint hwnd
</FUNCTION>
<FUNCTION>
-<NAME>g_io_channel_win32_new_pipe_with_wakeups</NAME>
+<NAME>g_io_channel_win32_new_messages</NAME>
<RETURNS>GIOChannel *</RETURNS>
-int fd,guint peer,int peer_fd
-</FUNCTION>
-<FUNCTION>
-<NAME>g_io_channel_win32_pipe_request_wakeups</NAME>
-<RETURNS>void </RETURNS>
-GIOChannel *channel,guint peer,int peer_fd
+guint hwnd
</FUNCTION>
<FUNCTION>
-<NAME>g_io_channel_win32_pipe_readable</NAME>
-<RETURNS>void </RETURNS>
-int fd,guint offset
+<NAME>g_io_channel_win32_new_fd</NAME>
+<RETURNS>GIOChannel *</RETURNS>
+int fd
</FUNCTION>
<FUNCTION>
<NAME>g_io_channel_win32_get_fd</NAME>
typedef int pid_t;
</TYPEDEF>
<MACRO>
-<NAME>getcwd</NAME>
-# define getcwd _getcwd
-</MACRO>
-<MACRO>
-<NAME>getpid</NAME>
-# define getpid _getpid
-</MACRO>
-<MACRO>
-<NAME>access</NAME>
-# define access _access
-</MACRO>
-<MACRO>
-<NAME>open</NAME>
-# define open _open
-</MACRO>
-<MACRO>
-<NAME>read</NAME>
-# define read _read
-</MACRO>
-<MACRO>
-<NAME>write</NAME>
-# define write _write
-</MACRO>
-<MACRO>
-<NAME>lseek</NAME>
-# define lseek _lseek
-</MACRO>
-<MACRO>
-<NAME>close</NAME>
-# define close _close
-</MACRO>
-<MACRO>
<NAME>pipe</NAME>
-# define pipe(phandles) _pipe (phandles, 4096, _O_BINARY)
-</MACRO>
-<MACRO>
-<NAME>popen</NAME>
-# define popen _popen
-</MACRO>
-<MACRO>
-<NAME>pclose</NAME>
-# define pclose _pclose
-</MACRO>
-<MACRO>
-<NAME>fdopen</NAME>
-# define fdopen _fdopen
+#define pipe(phandles) _pipe (phandles, 4096, _O_BINARY)
</MACRO>
<MACRO>
<NAME>ftruncate</NAME>
-# define ftruncate(fd, size) gwin_ftruncate (fd, size)
+# define ftruncate(fd, size) g_win32_ftruncate (fd, size)
</MACRO>
<MACRO>
<NAME>opendir</NAME>
-# define opendir gwin_opendir
+# define opendir g_win32_opendir
</MACRO>
<MACRO>
<NAME>readdir</NAME>
-# define readdir gwin_readdir
+# define readdir g_win32_readdir
</MACRO>
<MACRO>
<NAME>rewinddir</NAME>
-# define rewinddir gwin_rewinddir
+# define rewinddir g_win32_rewinddir
</MACRO>
<MACRO>
<NAME>closedir</NAME>
-# define closedir gwin_closedir
+# define closedir g_win32_closedir
</MACRO>
<MACRO>
<NAME>NAME_MAX</NAME>
# define NAME_MAX 255
</MACRO>
<FUNCTION>
-<NAME>gwin_ftruncate</NAME>
+<NAME>g_win32_ftruncate</NAME>
<RETURNS>int </RETURNS>
gint f,guint size
</FUNCTION>
<FUNCTION>
-<NAME>gwin_opendir</NAME>
+<NAME>g_win32_opendir</NAME>
<RETURNS>DIR *</RETURNS>
const gchar *dirname
</FUNCTION>
<FUNCTION>
-<NAME>gwin_rewinddir</NAME>
+<NAME>g_win32_rewinddir</NAME>
<RETURNS>void </RETURNS>
DIR *dir
</FUNCTION>
<FUNCTION>
-<NAME>gwin_closedir</NAME>
+<NAME>g_win32_closedir</NAME>
<RETURNS>gint </RETURNS>
DIR *dir
</FUNCTION>
-<STRUCT>
-<NAME>GMutex</NAME>
-</STRUCT>
-<STRUCT>
-<NAME>GCond</NAME>
-</STRUCT>
-<STRUCT>
-<NAME>GPrivate</NAME>
-</STRUCT>
-<STRUCT>
-<NAME>GStaticPrivate</NAME>
-</STRUCT>
-<STRUCT>
-<NAME>GThreadFunctions</NAME>
-</STRUCT>
-<STRUCT>
+<FUNCTION>
+<NAME>g_win32_getlocale</NAME>
+<RETURNS>gchar *</RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_win32_error_message</NAME>
+<RETURNS>gchar *</RETURNS>
+gint error
+</FUNCTION>
+<FUNCTION>
+<NAME>g_thread_error_quark</NAME>
+<RETURNS>GQuark </RETURNS>
+
+</FUNCTION>
+<MACRO>
+<NAME>G_THREAD_ERROR</NAME>
+#define G_THREAD_ERROR g_thread_error_quark()
+</MACRO>
+<ENUM>
+<NAME>GThreadError</NAME>
+typedef enum
+{
+ G_THREAD_ERROR_AGAIN /* Resource temporarily unavailable */
+} GThreadError;
+</ENUM>
+<USER_FUNCTION>
+<NAME>GThreadFunc</NAME>
+<RETURNS>void </RETURNS>
+gpointer value
+</USER_FUNCTION>
+<ENUM>
+<NAME>GThreadPriority</NAME>
+typedef enum
+{
+ G_THREAD_PRIORITY_LOW,
+ G_THREAD_PRIORITY_NORMAL,
+ G_THREAD_PRIORITY_HIGH,
+ G_THREAD_PRIORITY_URGENT
+} GThreadPriority;
+</ENUM>
+<STRUCT>
+<NAME>GThread</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GThread</NAME>
+struct GThread
+{
+ GThreadPriority priority;
+ gboolean bound;
+ gboolean joinable;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GMutex</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GCond</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GPrivate</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GStaticPrivate</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GAsyncQueue</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GThreadPool</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GThreadFunctions</NAME>
+</STRUCT>
+<STRUCT>
<NAME>GThreadFunctions</NAME>
struct GThreadFunctions
{
- GMutex* (*mutex_new) (void);
- void (*mutex_lock) (GMutex *mutex);
- gboolean (*mutex_trylock) (GMutex *mutex);
- void (*mutex_unlock) (GMutex *mutex);
- void (*mutex_free) (GMutex *mutex);
- GCond* (*cond_new) (void);
- void (*cond_signal) (GCond *cond);
- void (*cond_broadcast) (GCond *cond);
- void (*cond_wait) (GCond *cond,
- GMutex *mutex);
- gboolean (*cond_timed_wait) (GCond *cond,
- GMutex *mutex,
- GTimeVal *end_time);
- void (*cond_free) (GCond *cond);
- GPrivate* (*private_new) (GDestroyNotify destructor);
- gpointer (*private_get) (GPrivate *private_key);
- void (*private_set) (GPrivate *private_key,
- gpointer data);
+ GMutex* (*mutex_new) (void);
+ void (*mutex_lock) (GMutex *mutex);
+ gboolean (*mutex_trylock) (GMutex *mutex);
+ void (*mutex_unlock) (GMutex *mutex);
+ void (*mutex_free) (GMutex *mutex);
+ GCond* (*cond_new) (void);
+ void (*cond_signal) (GCond *cond);
+ void (*cond_broadcast) (GCond *cond);
+ void (*cond_wait) (GCond *cond,
+ GMutex *mutex);
+ gboolean (*cond_timed_wait) (GCond *cond,
+ GMutex *mutex,
+ GTimeVal *end_time);
+ void (*cond_free) (GCond *cond);
+ GPrivate* (*private_new) (GDestroyNotify destructor);
+ gpointer (*private_get) (GPrivate *private_key);
+ void (*private_set) (GPrivate *private_key,
+ gpointer data);
+ void (*thread_create) (GThreadFunc thread_func,
+ gpointer arg,
+ gulong stack_size,
+ gboolean joinable,
+ gboolean bound,
+ GThreadPriority priority,
+ gpointer thread,
+ GError **error);
+ void (*thread_yield) (void);
+ void (*thread_join) (gpointer thread);
+ void (*thread_exit) (void);
+ void (*thread_set_priority)(gpointer thread,
+ GThreadPriority priority);
+ void (*thread_self) (gpointer thread);
};
</STRUCT>
<FUNCTION>
(private_key, value))
</MACRO>
<MACRO>
+<NAME>g_thread_yield</NAME>
+#define g_thread_yield() G_THREAD_CF (thread_yield, (void)0, ())
+</MACRO>
+<MACRO>
+<NAME>g_thread_exit</NAME>
+#define g_thread_exit() G_THREAD_CF (thread_exit, (void)0, ())
+</MACRO>
+<FUNCTION>
+<NAME>g_thread_create</NAME>
+<RETURNS>GThread *</RETURNS>
+GThreadFunc thread_func,gpointer arg,gulong stack_size,gboolean joinable,gboolean bound,GThreadPriority priority,GError **error
+</FUNCTION>
+<FUNCTION>
+<NAME>g_thread_self</NAME>
+<RETURNS>GThread *</RETURNS>
+
+</FUNCTION>
+<FUNCTION>
+<NAME>g_thread_join</NAME>
+<RETURNS>void </RETURNS>
+GThread *thread
+</FUNCTION>
+<FUNCTION>
+<NAME>g_thread_set_priority</NAME>
+<RETURNS>void </RETURNS>
+GThread *thread,GThreadPriority priority
+</FUNCTION>
+<MACRO>
<NAME>g_static_mutex_lock</NAME>
#define g_static_mutex_lock(mutex) \
g_mutex_lock (g_static_mutex_get_mutex (mutex))
GStaticPrivate *private_key,gpointer data,GDestroyNotify notify
</FUNCTION>
<FUNCTION>
+<NAME>g_static_private_get_for_thread</NAME>
+<RETURNS>gpointer </RETURNS>
+GStaticPrivate *private_key,GThread *thread
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_private_set_for_thread</NAME>
+<RETURNS>void </RETURNS>
+GStaticPrivate *private_key,GThread *thread,gpointer data,GDestroyNotify notify
+</FUNCTION>
+<STRUCT>
+<NAME>GStaticRecMutex</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GStaticRecMutex</NAME>
+struct GStaticRecMutex
+{
+ GStaticMutex mutex;
+ unsigned int depth;
+ GSystemThread owner;
+};
+</STRUCT>
+<MACRO>
+<NAME>G_STATIC_REC_MUTEX_INIT</NAME>
+#define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT }
+</MACRO>
+<FUNCTION>
+<NAME>g_static_rec_mutex_lock</NAME>
+<RETURNS>void </RETURNS>
+GStaticRecMutex *mutex
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rec_mutex_trylock</NAME>
+<RETURNS>gboolean </RETURNS>
+GStaticRecMutex *mutex
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rec_mutex_unlock</NAME>
+<RETURNS>void </RETURNS>
+GStaticRecMutex *mutex
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rec_mutex_lock_full</NAME>
+<RETURNS>void </RETURNS>
+GStaticRecMutex *mutex,guint depth
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rec_mutex_unlock_full</NAME>
+<RETURNS>guint </RETURNS>
+GStaticRecMutex *mutex
+</FUNCTION>
+<STRUCT>
+<NAME>GStaticRWLock</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GStaticRWLock</NAME>
+struct GStaticRWLock
+{
+ GStaticMutex mutex;
+ GCond *read_cond;
+ GCond *write_cond;
+ guint read_counter;
+ gboolean write;
+ guint want_to_write;
+};
+</STRUCT>
+<MACRO>
+<NAME>G_STATIC_RW_LOCK_INIT</NAME>
+#define G_STATIC_RW_LOCK_INIT { G_STATIC_MUTEX_INIT, NULL, NULL, 0, FALSE, FALSE }
+</MACRO>
+<FUNCTION>
+<NAME>g_static_rw_lock_reader_lock</NAME>
+<RETURNS>void </RETURNS>
+GStaticRWLock* lock
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rw_lock_reader_trylock</NAME>
+<RETURNS>gboolean </RETURNS>
+GStaticRWLock* lock
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rw_lock_reader_unlock</NAME>
+<RETURNS>void </RETURNS>
+GStaticRWLock* lock
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rw_lock_writer_lock</NAME>
+<RETURNS>void </RETURNS>
+GStaticRWLock* lock
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rw_lock_writer_trylock</NAME>
+<RETURNS>gboolean </RETURNS>
+GStaticRWLock* lock
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rw_lock_writer_unlock</NAME>
+<RETURNS>void </RETURNS>
+GStaticRWLock* lock
+</FUNCTION>
+<FUNCTION>
+<NAME>g_static_rw_lock_free</NAME>
+<RETURNS>void </RETURNS>
+GStaticRWLock* lock
+</FUNCTION>
+<FUNCTION>
<NAME>glib_dummy_decl</NAME>
<RETURNS>void </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>G_LOCK_NAME</NAME>
-#define G_LOCK_NAME(name) (g__ ## name ## _lock)
+#define G_LOCK_NAME(name) g__ ## name ## _lock
</MACRO>
<MACRO>
<NAME>G_LOCK_DEFINE_STATIC</NAME>
</MACRO>
<MACRO>
<NAME>G_TRYLOCK</NAME>
-# define G_TRYLOCK(name) G_STMT_START{ \
- g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
+# define G_TRYLOCK(name) \
+ (g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
"file %s: line %d (%s): try locking: %s ", \
__FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
- #name); \
- }G_STMT_END, g_static_mutex_trylock (&G_LOCK_NAME (name))
+ #name), g_static_mutex_trylock (&G_LOCK_NAME (name)))
</MACRO>
<MACRO>
<NAME>G_LOCK</NAME>
</MACRO>
<MACRO>
<NAME>G_TRYLOCK</NAME>
-# define G_TRYLOCK(name) (FALSE)
-</MACRO>
-<VARIABLE>
-<NAME>g_log_domain_gmodule</NAME>
-extern const char *g_log_domain_gmodule;
-</VARIABLE>
-<MACRO>
-<NAME>G_MODULE_IMPORT</NAME>
-#define G_MODULE_IMPORT extern
-</MACRO>
-<MACRO>
-<NAME>G_MODULE_EXPORT</NAME>
-# define G_MODULE_EXPORT __declspec(dllexport)
-</MACRO>
-<MACRO>
-<NAME>G_MODULE_EXPORT</NAME>
-# define G_MODULE_EXPORT
+# define G_TRYLOCK(name) (TRUE)
</MACRO>
-<ENUM>
-<NAME>GModuleFlags</NAME>
-typedef enum
-{
- G_MODULE_BIND_LAZY = 1 << 0,
- G_MODULE_BIND_MASK = 0x01
-} GModuleFlags;
-</ENUM>
+<FUNCTION>
+<NAME>g_async_queue_new</NAME>
+<RETURNS>GAsyncQueue *</RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_lock</NAME>
+<RETURNS>void </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_unlock</NAME>
+<RETURNS>void </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_ref</NAME>
+<RETURNS>void </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_ref_unlocked</NAME>
+<RETURNS>void </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_unref</NAME>
+<RETURNS>void </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_unref_and_unlock</NAME>
+<RETURNS>void </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_push</NAME>
+<RETURNS>void </RETURNS>
+GAsyncQueue *queue,gpointer data
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_push_unlocked</NAME>
+<RETURNS>void </RETURNS>
+GAsyncQueue *queue,gpointer data
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_pop</NAME>
+<RETURNS>gpointer </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_pop_unlocked</NAME>
+<RETURNS>gpointer </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_try_pop</NAME>
+<RETURNS>gpointer </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_try_pop_unlocked</NAME>
+<RETURNS>gpointer </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_timed_pop</NAME>
+<RETURNS>gpointer </RETURNS>
+GAsyncQueue *queue,GTimeVal *end_time
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_timed_pop_unlocked</NAME>
+<RETURNS>gpointer </RETURNS>
+GAsyncQueue *queue,GTimeVal *end_time
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_length</NAME>
+<RETURNS>gint </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
+<FUNCTION>
+<NAME>g_async_queue_length_unlocked</NAME>
+<RETURNS>gint </RETURNS>
+GAsyncQueue *queue
+</FUNCTION>
<STRUCT>
-<NAME>GModule</NAME>
+<NAME>GThreadPool</NAME>
+struct GThreadPool
+{
+ GFunc thread_func;
+ gulong stack_size;
+ gboolean bound;
+ GThreadPriority priority;
+ gboolean exclusive;
+ gpointer user_data;
+};
</STRUCT>
-<USER_FUNCTION>
-<NAME>GModuleCheckInit</NAME>
-<RETURNS>const gchar *</RETURNS>
-GModule *module
-</USER_FUNCTION>
-<USER_FUNCTION>
-<NAME>GModuleUnload</NAME>
-<RETURNS>void </RETURNS>
-GModule *module
-</USER_FUNCTION>
<FUNCTION>
-<NAME>g_module_supported</NAME>
-<RETURNS>gboolean </RETURNS>
-void
+<NAME>g_thread_pool_new</NAME>
+<RETURNS>GThreadPool *</RETURNS>
+GFunc thread_func,gint max_threads,gulong stack_size,gboolean bound,GThreadPriority priority,gboolean exclusive,gpointer user_data,GError **error
</FUNCTION>
<FUNCTION>
-<NAME>g_module_open</NAME>
-<RETURNS>GModule *</RETURNS>
-const gchar *file_name,GModuleFlags flags
+<NAME>g_thread_pool_push</NAME>
+<RETURNS>void </RETURNS>
+GThreadPool *pool,gpointer data,GError **error
</FUNCTION>
<FUNCTION>
-<NAME>g_module_close</NAME>
-<RETURNS>gboolean </RETURNS>
-GModule *module
+<NAME>g_thread_pool_set_max_threads</NAME>
+<RETURNS>void </RETURNS>
+GThreadPool *pool,gint max_threads,GError **error
</FUNCTION>
<FUNCTION>
-<NAME>g_module_make_resident</NAME>
-<RETURNS>void </RETURNS>
-GModule *module
+<NAME>g_thread_pool_get_max_threads</NAME>
+<RETURNS>gint </RETURNS>
+GThreadPool *pool
</FUNCTION>
<FUNCTION>
-<NAME>g_module_error</NAME>
-<RETURNS>gchar *</RETURNS>
-void
+<NAME>g_thread_pool_get_num_threads</NAME>
+<RETURNS>guint </RETURNS>
+GThreadPool *pool
</FUNCTION>
<FUNCTION>
-<NAME>g_module_symbol</NAME>
-<RETURNS>gboolean </RETURNS>
-GModule *module,const gchar *symbol_name,gpointer *symbol
+<NAME>g_thread_pool_unprocessed</NAME>
+<RETURNS>guint </RETURNS>
+GThreadPool *pool
</FUNCTION>
<FUNCTION>
-<NAME>g_module_name</NAME>
-<RETURNS>gchar *</RETURNS>
-GModule *module
+<NAME>g_thread_pool_free</NAME>
+<RETURNS>void </RETURNS>
+GThreadPool *pool,gboolean immediate,gboolean wait
</FUNCTION>
<FUNCTION>
-<NAME>g_module_build_path</NAME>
-<RETURNS>gchar *</RETURNS>
-const gchar *directory,const gchar *module_name
+<NAME>g_thread_pool_set_max_unused_threads</NAME>
+<RETURNS>void </RETURNS>
+gint max_threads
</FUNCTION>
-<MACRO>
-<NAME>GLIB_HAVE_SYS_POLL_H</NAME>
-#define GLIB_HAVE_SYS_POLL_H
-</MACRO>
-<MACRO>
-<NAME>G_MINFLOAT</NAME>
-#define G_MINFLOAT FLT_MIN
-</MACRO>
-<MACRO>
-<NAME>G_MAXFLOAT</NAME>
-#define G_MAXFLOAT FLT_MAX
-</MACRO>
-<MACRO>
-<NAME>G_MINDOUBLE</NAME>
+<FUNCTION>
+<NAME>g_thread_pool_get_max_unused_threads</NAME>
+<RETURNS>gint </RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_thread_pool_get_num_unused_threads</NAME>
+<RETURNS>guint </RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_thread_pool_stop_unused_threads</NAME>
+<RETURNS>void </RETURNS>
+void
+</FUNCTION>
+<TYPEDEF>
+<NAME>gunichar</NAME>
+typedef guint32 gunichar;
+</TYPEDEF>
+<TYPEDEF>
+<NAME>gunichar2</NAME>
+typedef guint16 gunichar2;
+</TYPEDEF>
+<ENUM>
+<NAME>GUnicodeType</NAME>
+typedef enum {
+ G_UNICODE_CONTROL,
+ G_UNICODE_FORMAT,
+ G_UNICODE_UNASSIGNED,
+ G_UNICODE_PRIVATE_USE,
+ G_UNICODE_SURROGATE,
+ G_UNICODE_LOWERCASE_LETTER,
+ G_UNICODE_MODIFIER_LETTER,
+ G_UNICODE_OTHER_LETTER,
+ G_UNICODE_TITLECASE_LETTER,
+ G_UNICODE_UPPERCASE_LETTER,
+ G_UNICODE_COMBINING_MARK,
+ G_UNICODE_ENCLOSING_MARK,
+ G_UNICODE_NON_SPACING_MARK,
+ G_UNICODE_DECIMAL_NUMBER,
+ G_UNICODE_LETTER_NUMBER,
+ G_UNICODE_OTHER_NUMBER,
+ G_UNICODE_CONNECT_PUNCTUATION,
+ G_UNICODE_DASH_PUNCTUATION,
+ G_UNICODE_CLOSE_PUNCTUATION,
+ G_UNICODE_FINAL_PUNCTUATION,
+ G_UNICODE_INITIAL_PUNCTUATION,
+ G_UNICODE_OTHER_PUNCTUATION,
+ G_UNICODE_OPEN_PUNCTUATION,
+ G_UNICODE_CURRENCY_SYMBOL,
+ G_UNICODE_MODIFIER_SYMBOL,
+ G_UNICODE_MATH_SYMBOL,
+ G_UNICODE_OTHER_SYMBOL,
+ G_UNICODE_LINE_SEPARATOR,
+ G_UNICODE_PARAGRAPH_SEPARATOR,
+ G_UNICODE_SPACE_SEPARATOR
+} GUnicodeType;
+</ENUM>
+<FUNCTION>
+<NAME>g_get_charset</NAME>
+<RETURNS>gboolean </RETURNS>
+char **charset
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_isalnum</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_isalpha</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_iscntrl</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_isdigit</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_isgraph</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_islower</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_isprint</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_ispunct</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_isspace</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_isupper</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_isxdigit</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_istitle</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_isdefined</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_iswide</NAME>
+<RETURNS>gboolean </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_toupper</NAME>
+<RETURNS>gunichar </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_tolower</NAME>
+<RETURNS>gunichar </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_totitle</NAME>
+<RETURNS>gunichar </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_digit_value</NAME>
+<RETURNS>gint </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_xdigit_value</NAME>
+<RETURNS>gint </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_type</NAME>
+<RETURNS>GUnicodeType </RETURNS>
+gunichar c
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unicode_canonical_ordering</NAME>
+<RETURNS>void </RETURNS>
+gunichar *string,size_t len
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unicode_canonical_decomposition</NAME>
+<RETURNS>gunichar *</RETURNS>
+gunichar ch,size_t *result_len
+</FUNCTION>
+<MACRO>
+<NAME>GLIB_VAR</NAME>
+# define GLIB_VAR __declspec(dllexport)
+</MACRO>
+<MACRO>
+<NAME>GLIB_VAR</NAME>
+# define GLIB_VAR extern __declspec(dllimport)
+</MACRO>
+<MACRO>
+<NAME>GLIB_VAR</NAME>
+# define GLIB_VAR extern
+</MACRO>
+<MACRO>
+<NAME>g_utf8_next_char</NAME>
+#define g_utf8_next_char(p) (char *)((p) + g_utf8_skip[*(guchar *)(p)])
+</MACRO>
+<FUNCTION>
+<NAME>g_utf8_get_char</NAME>
+<RETURNS>gunichar </RETURNS>
+const gchar *p
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_offset_to_pointer</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *str,gint offset
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_pointer_to_offset</NAME>
+<RETURNS>gint </RETURNS>
+const gchar *str,const gchar *pos
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_prev_char</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *p
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_find_next_char</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *p,const gchar *bound
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_find_prev_char</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *str,const gchar *p
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_strlen</NAME>
+<RETURNS>gint </RETURNS>
+const gchar *p,gint max
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_strncpy</NAME>
+<RETURNS>gchar *</RETURNS>
+gchar *dest,const gchar *src,size_t n
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_strchr</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *p,gunichar ch
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_strrchr</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *p,gunichar ch
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_to_utf16</NAME>
+<RETURNS>gunichar2 *</RETURNS>
+const gchar *str,gint len
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf8_to_ucs4</NAME>
+<RETURNS>gunichar *</RETURNS>
+const gchar *str,gint len
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf16_to_ucs4</NAME>
+<RETURNS>gunichar *</RETURNS>
+const gunichar2 *str,gint len
+</FUNCTION>
+<FUNCTION>
+<NAME>g_utf16_to_utf8</NAME>
+<RETURNS>gchar *</RETURNS>
+const gunichar2 *str,gint len
+</FUNCTION>
+<FUNCTION>
+<NAME>g_ucs4_to_utf16</NAME>
+<RETURNS>gunichar *</RETURNS>
+const gunichar *str,gint len
+</FUNCTION>
+<FUNCTION>
+<NAME>g_ucs4_to_utf8</NAME>
+<RETURNS>gchar *</RETURNS>
+const gunichar *str,gint len
+</FUNCTION>
+<FUNCTION>
+<NAME>g_unichar_to_utf8</NAME>
+<RETURNS>gint </RETURNS>
+gunichar c,char *outbuf
+</FUNCTION>
+<MACRO>
+<NAME>GLIB_HAVE_SYS_POLL_H</NAME>
+#define GLIB_HAVE_SYS_POLL_H
+</MACRO>
+<MACRO>
+<NAME>G_MINFLOAT</NAME>
+#define G_MINFLOAT FLT_MIN
+</MACRO>
+<MACRO>
+<NAME>G_MAXFLOAT</NAME>
+#define G_MAXFLOAT FLT_MAX
+</MACRO>
+<MACRO>
+<NAME>G_MINDOUBLE</NAME>
#define G_MINDOUBLE DBL_MIN
</MACRO>
<MACRO>
#define G_MAXSHORT SHRT_MAX
</MACRO>
<MACRO>
+<NAME>G_MAXUSHORT</NAME>
+#define G_MAXUSHORT USHRT_MAX
+</MACRO>
+<MACRO>
<NAME>G_MININT</NAME>
#define G_MININT INT_MIN
</MACRO>
#define G_MAXINT INT_MAX
</MACRO>
<MACRO>
+<NAME>G_MAXUINT</NAME>
+#define G_MAXUINT UINT_MAX
+</MACRO>
+<MACRO>
<NAME>G_MINLONG</NAME>
#define G_MINLONG LONG_MIN
</MACRO>
<NAME>G_MAXLONG</NAME>
#define G_MAXLONG LONG_MAX
</MACRO>
+<MACRO>
+<NAME>G_MAXULONG</NAME>
+#define G_MAXULONG ULONG_MAX
+</MACRO>
<TYPEDEF>
<NAME>gint8</NAME>
typedef signed char gint8;
<NAME>guint16</NAME>
typedef unsigned short guint16;
</TYPEDEF>
+<MACRO>
+<NAME>G_GINT16_FORMAT</NAME>
+#define G_GINT16_FORMAT "hi"
+</MACRO>
+<MACRO>
+<NAME>G_GUINT16_FORMAT</NAME>
+#define G_GUINT16_FORMAT "hu"
+</MACRO>
<TYPEDEF>
<NAME>gint32</NAME>
typedef signed int gint32;
typedef unsigned int guint32;
</TYPEDEF>
<MACRO>
-<NAME>G_GNUC_EXTENSION</NAME>
-# define G_GNUC_EXTENSION __extension__
+<NAME>G_GINT32_FORMAT</NAME>
+#define G_GINT32_FORMAT "i"
</MACRO>
<MACRO>
-<NAME>G_GNUC_EXTENSION</NAME>
-# define G_GNUC_EXTENSION
+<NAME>G_GUINT32_FORMAT</NAME>
+#define G_GUINT32_FORMAT "u"
</MACRO>
<MACRO>
<NAME>G_HAVE_GINT64</NAME>
G_GNUC_EXTENSION typedef unsigned long long guint64;
</TYPEDEF>
<MACRO>
+<NAME>G_GINT64_FORMAT</NAME>
+#define G_GINT64_FORMAT "lli"
+</MACRO>
+<MACRO>
+<NAME>G_GUINT64_FORMAT</NAME>
+#define G_GUINT64_FORMAT "llu"
+</MACRO>
+<MACRO>
<NAME>G_GINT64_CONSTANT</NAME>
#define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val##LL))
</MACRO>
+<TYPEDEF>
+<NAME>gssize</NAME>
+typedef gint32 gssize;
+</TYPEDEF>
+<TYPEDEF>
+<NAME>gsize</NAME>
+typedef guint32 gsize;
+</TYPEDEF>
<MACRO>
<NAME>GPOINTER_TO_INT</NAME>
#define GPOINTER_TO_INT(p) ((gint) (p))
</MACRO>
<MACRO>
<NAME>GLIB_MINOR_VERSION</NAME>
-#define GLIB_MINOR_VERSION 2
+#define GLIB_MINOR_VERSION 3
</MACRO>
<MACRO>
<NAME>GLIB_MICRO_VERSION</NAME>
-#define GLIB_MICRO_VERSION 3
+#define GLIB_MICRO_VERSION 1
+</MACRO>
+<MACRO>
+<NAME>G_OS_UNIX</NAME>
+#define G_OS_UNIX
+</MACRO>
+<MACRO>
+<NAME>G_VA_COPY</NAME>
+#define G_VA_COPY __va_copy
</MACRO>
<MACRO>
<NAME>G_HAVE_INLINE</NAME>
<NAME>g_static_mutex_get_mutex</NAME>
#define g_static_mutex_get_mutex(mutex) (g_thread_use_default_impl ? ((GMutex*) &((mutex)->aligned_pad_u)) : g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
</MACRO>
+<UNION>
+<NAME>GSystemThread</NAME>
+union GSystemThread
+{
+ char data[4];
+ double dummy_double;
+ void *dummy_pointer;
+ long dummy_long;
+};
+</UNION>
<MACRO>
<NAME>GINT16_TO_LE</NAME>
#define GINT16_TO_LE(val) ((gint16) (val))
<NAME>GLIB_SYSDEF_POLLNVAL</NAME>
#define GLIB_SYSDEF_POLLNVAL =32
</MACRO>
+<VARIABLE>
+<NAME>g_log_domain_gmodule</NAME>
+extern const char *g_log_domain_gmodule;
+</VARIABLE>
+<MACRO>
+<NAME>G_MODULE_IMPORT</NAME>
+#define G_MODULE_IMPORT extern
+</MACRO>
+<MACRO>
+<NAME>G_MODULE_EXPORT</NAME>
+# define G_MODULE_EXPORT __declspec(dllexport)
+</MACRO>
+<MACRO>
+<NAME>G_MODULE_EXPORT</NAME>
+# define G_MODULE_EXPORT
+</MACRO>
+<ENUM>
+<NAME>GModuleFlags</NAME>
+typedef enum
+{
+ G_MODULE_BIND_LAZY = 1 << 0,
+ G_MODULE_BIND_MASK = 0x01
+} GModuleFlags;
+</ENUM>
+<STRUCT>
+<NAME>GModule</NAME>
+</STRUCT>
+<USER_FUNCTION>
+<NAME>GModuleCheckInit</NAME>
+<RETURNS>const gchar *</RETURNS>
+GModule *module
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GModuleUnload</NAME>
+<RETURNS>void </RETURNS>
+GModule *module
+</USER_FUNCTION>
+<FUNCTION>
+<NAME>g_module_supported</NAME>
+<RETURNS>gboolean </RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_module_open</NAME>
+<RETURNS>GModule *</RETURNS>
+const gchar *file_name,GModuleFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_module_close</NAME>
+<RETURNS>gboolean </RETURNS>
+GModule *module
+</FUNCTION>
+<FUNCTION>
+<NAME>g_module_make_resident</NAME>
+<RETURNS>void </RETURNS>
+GModule *module
+</FUNCTION>
+<FUNCTION>
+<NAME>g_module_error</NAME>
+<RETURNS>gchar *</RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_module_symbol</NAME>
+<RETURNS>gboolean </RETURNS>
+GModule *module,const gchar *symbol_name,gpointer *symbol
+</FUNCTION>
+<FUNCTION>
+<NAME>g_module_name</NAME>
+<RETURNS>gchar *</RETURNS>
+GModule *module
+</FUNCTION>
+<FUNCTION>
+<NAME>g_module_build_path</NAME>
+<RETURNS>gchar *</RETURNS>
+const gchar *directory,const gchar *module_name
+</FUNCTION>
+<MACRO>
+<NAME>G_TYPE_IS_ENUM</NAME>
+#define G_TYPE_IS_ENUM(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_ENUM)
+</MACRO>
+<MACRO>
+<NAME>G_ENUM_CLASS</NAME>
+#define G_ENUM_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_ENUM, GEnumClass))
+</MACRO>
<MACRO>
-<NAME>G_HAVE_WCHAR_H</NAME>
-#define G_HAVE_WCHAR_H 1
+<NAME>G_IS_ENUM_CLASS</NAME>
+#define G_IS_ENUM_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_ENUM))
</MACRO>
<MACRO>
-<NAME>G_HAVE_WCTYPE_H</NAME>
-#define G_HAVE_WCTYPE_H 1
+<NAME>G_ENUM_CLASS_TYPE</NAME>
+#define G_ENUM_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class))
</MACRO>
+<MACRO>
+<NAME>G_ENUM_CLASS_TYPE_NAME</NAME>
+#define G_ENUM_CLASS_TYPE_NAME(class) (g_type_name (G_ENUM_TYPE (class)))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_IS_FLAGS</NAME>
+#define G_TYPE_IS_FLAGS(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_FLAGS)
+</MACRO>
+<MACRO>
+<NAME>G_FLAGS_CLASS</NAME>
+#define G_FLAGS_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_FLAGS, GFlagsClass))
+</MACRO>
+<MACRO>
+<NAME>G_IS_FLAGS_CLASS</NAME>
+#define G_IS_FLAGS_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_FLAGS))
+</MACRO>
+<MACRO>
+<NAME>G_FLAGS_CLASS_TYPE</NAME>
+#define G_FLAGS_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class))
+</MACRO>
+<MACRO>
+<NAME>G_FLAGS_CLASS_TYPE_NAME</NAME>
+#define G_FLAGS_CLASS_TYPE_NAME(class) (g_type_name (G_FLAGS_TYPE (class)))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_ENUM</NAME>
+#define G_IS_VALUE_ENUM(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_ENUM))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_FLAGS</NAME>
+#define G_IS_VALUE_FLAGS(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_FLAGS))
+</MACRO>
+<STRUCT>
+<NAME>GEnumClass</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GFlagsClass</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GEnumValue</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GFlagsValue</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GEnumValue</NAME>
+struct GEnumValue
+{
+ gint value;
+ gchar *value_name;
+ gchar *value_nick;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GFlagsValue</NAME>
+struct GFlagsValue
+{
+ guint value;
+ gchar *value_name;
+ gchar *value_nick;
+};
+</STRUCT>
+<FUNCTION>
+<NAME>g_enum_get_value</NAME>
+<RETURNS>GEnumValue *</RETURNS>
+GEnumClass *enum_class,gint value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_enum_get_value_by_name</NAME>
+<RETURNS>GEnumValue *</RETURNS>
+GEnumClass *enum_class,const gchar *name
+</FUNCTION>
+<FUNCTION>
+<NAME>g_enum_get_value_by_nick</NAME>
+<RETURNS>GEnumValue *</RETURNS>
+GEnumClass *enum_class,const gchar *nick
+</FUNCTION>
+<FUNCTION>
+<NAME>g_flags_get_first_value</NAME>
+<RETURNS>GFlagsValue *</RETURNS>
+GFlagsClass *flags_class,guint value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_flags_get_value_by_name</NAME>
+<RETURNS>GFlagsValue *</RETURNS>
+GFlagsClass *flags_class,const gchar *name
+</FUNCTION>
+<FUNCTION>
+<NAME>g_flags_get_value_by_nick</NAME>
+<RETURNS>GFlagsValue *</RETURNS>
+GFlagsClass *flags_class,const gchar *nick
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_enum</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,gint v_enum
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_enum</NAME>
+<RETURNS>gint </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_flags</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,guint v_flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_flags</NAME>
+<RETURNS>guint </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_enum_register_static</NAME>
+<RETURNS>GType </RETURNS>
+const gchar *name,const GEnumValue *const_static_values
+</FUNCTION>
+<FUNCTION>
+<NAME>g_flags_register_static</NAME>
+<RETURNS>GType </RETURNS>
+const gchar *name,const GFlagsValue *const_static_values
+</FUNCTION>
+<FUNCTION>
+<NAME>g_enum_complete_type_info</NAME>
+<RETURNS>void </RETURNS>
+GType g_enum_type,GTypeInfo *info,const GEnumValue *const_values
+</FUNCTION>
+<FUNCTION>
+<NAME>g_flags_complete_type_info</NAME>
+<RETURNS>void </RETURNS>
+GType g_flags_type,GTypeInfo *info,const GFlagsValue *const_values
+</FUNCTION>
+<MACRO>
+<NAME>G_TYPE_IS_OBJECT</NAME>
+#define G_TYPE_IS_OBJECT(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_OBJECT)
+</MACRO>
+<MACRO>
+<NAME>G_OBJECT</NAME>
+#define G_OBJECT(object) (G_IS_OBJECT (object) ? ((GObject*) (object)) : \
+ G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject))
+</MACRO>
+<MACRO>
+<NAME>G_OBJECT_CLASS</NAME>
+#define G_OBJECT_CLASS(class) (G_IS_OBJECT_CLASS (class) ? ((GObjectClass*) (class)) : \
+ G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass))
+</MACRO>
+<MACRO>
+<NAME>G_IS_OBJECT</NAME>
+#define G_IS_OBJECT(object) (((GObject*) (object)) != NULL && \
+ G_IS_OBJECT_CLASS (((GTypeInstance*) (object))->g_class))
+</MACRO>
+<MACRO>
+<NAME>G_IS_OBJECT_CLASS</NAME>
+#define G_IS_OBJECT_CLASS(class) (((GTypeClass*) (class)) != NULL && \
+ G_TYPE_IS_OBJECT (((GTypeClass*) (class))->g_type))
+</MACRO>
+<MACRO>
+<NAME>G_OBJECT_GET_CLASS</NAME>
+#define G_OBJECT_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_OBJECT, GObjectClass))
+</MACRO>
+<MACRO>
+<NAME>G_OBJECT_TYPE</NAME>
+#define G_OBJECT_TYPE(object) (G_TYPE_FROM_INSTANCE (object))
+</MACRO>
+<MACRO>
+<NAME>G_OBJECT_TYPE_NAME</NAME>
+#define G_OBJECT_TYPE_NAME(object) (g_type_name (G_OBJECT_TYPE (object)))
+</MACRO>
+<MACRO>
+<NAME>G_OBJECT_CLASS_TYPE</NAME>
+#define G_OBJECT_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class))
+</MACRO>
+<MACRO>
+<NAME>G_OBJECT_CLASS_NAME</NAME>
+#define G_OBJECT_CLASS_NAME(class) (g_type_name (G_OBJECT_CLASS_TYPE (class)))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_OBJECT</NAME>
+#define G_IS_VALUE_OBJECT(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_OBJECT))
+</MACRO>
+<MACRO>
+<NAME>G_NOTIFY_PRIORITY</NAME>
+#define G_NOTIFY_PRIORITY (G_PRIORITY_HIGH_IDLE + 20)
+</MACRO>
+<STRUCT>
+<NAME>GObject</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GObjectClass</NAME>
+</STRUCT>
+<USER_FUNCTION>
+<NAME>GObjectGetParamFunc</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec,
+ const gchar *trailer
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GObjectSetParamFunc</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec,
+ const gchar *trailer
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GObjectFinalizeFunc</NAME>
+<RETURNS>void </RETURNS>
+GObject *object
+</USER_FUNCTION>
+<STRUCT>
+<NAME>GObject</NAME>
+struct GObject
+{
+ GTypeInstance g_type_instance;
+
+ /*< private >*/
+ guint ref_count;
+ GData *qdata;
+};
+</STRUCT>
+<FUNCTION>
+<NAME>g_object_class_install_param</NAME>
+<RETURNS>void </RETURNS>
+GObjectClass *oclass,guint param_id,GParamSpec *pspec
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_class_find_param_spec</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+GObjectClass *oclass,const gchar *param_name
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_new</NAME>
+<RETURNS>gpointer </RETURNS>
+GType object_type,const gchar *first_param_name,...
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_new_valist</NAME>
+<RETURNS>gpointer </RETURNS>
+GType object_type,const gchar *first_param_name,va_list var_args
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_set</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,const gchar *first_param_name,...
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_get</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,const gchar *first_param_name,...
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_set_valist</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,const gchar *first_param_name,va_list var_args
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_get_valist</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,const gchar *first_param_name,va_list var_args
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_set_param</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,const gchar *param_name,const GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_get_param</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,const gchar *param_name,GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_queue_param_changed</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,const gchar *param_name
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_ref</NAME>
+<RETURNS>GObject *</RETURNS>
+GObject *object
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_unref</NAME>
+<RETURNS>void </RETURNS>
+GObject *object
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_get_qdata</NAME>
+<RETURNS>gpointer </RETURNS>
+GObject *object,GQuark quark
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_set_qdata</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,GQuark quark,gpointer data
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_set_qdata_full</NAME>
+<RETURNS>void </RETURNS>
+GObject *object,GQuark quark,gpointer data,GDestroyNotify destroy
+</FUNCTION>
+<FUNCTION>
+<NAME>g_object_steal_qdata</NAME>
+<RETURNS>gpointer </RETURNS>
+GObject *object,GQuark quark
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_object</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,GObject *v_object
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_object</NAME>
+<RETURNS>GObject *</RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_dup_object</NAME>
+<RETURNS>GObject *</RETURNS>
+GValue *value
+</FUNCTION>
+<MACRO>
+<NAME>G_WARN_INVALID_PARAM_ID</NAME>
+#define G_WARN_INVALID_PARAM_ID(object, param_id, pspec) \
+G_STMT_START { \
+ GObject *_object = (GObject*) (object); \
+ GParamSpec *_pspec = (GParamSpec*) (pspec); \
+ guint _param_id = (param_id); \
+ g_warning ("%s: invalid parameter id %u for \"%s\" of type `%s' in `%s'", \
+ G_STRLOC, \
+ _param_id, \
+ _pspec->name, \
+ g_type_name (G_PARAM_SPEC_TYPE (_pspec)), \
+ BSE_OBJECT_TYPE_NAME (_object)); \
+} G_STMT_END
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_IS_PARAM</NAME>
+#define G_TYPE_IS_PARAM(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_PARAM)
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_TYPE</NAME>
+#define G_PARAM_SPEC_TYPE(pspec) (G_TYPE_FROM_INSTANCE (pspec))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_TYPE_NAME</NAME>
+#define G_PARAM_SPEC_TYPE_NAME(pspec) (g_type_name (G_PARAM_SPEC_TYPE (pspec)))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC</NAME>
+#define G_PARAM_SPEC(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM, GParamSpec))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC</NAME>
+#define G_IS_PARAM_SPEC(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_GET_CLASS</NAME>
+#define G_PARAM_SPEC_GET_CLASS(pspec) (G_TYPE_INSTANCE_GET_CLASS ((pspec), G_TYPE_PARAM, GParamSpecClass))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_VALUE</NAME>
+#define G_IS_PARAM_VALUE(pspec, value) (g_type_is_a (G_VALUE_TYPE (value), G_PARAM_SPEC_VALUE_TYPE (pspec))) /* FIXME */
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_VALUE_TYPE</NAME>
+#define G_PARAM_SPEC_VALUE_TYPE(pspec) (G_PARAM_SPEC_GET_CLASS (pspec)->value_type)
+</MACRO>
+<ENUM>
+<NAME>GParamFlags</NAME>
+typedef enum
+{
+ G_PARAM_READABLE = 1 << 0,
+ G_PARAM_WRITABLE = 1 << 1,
+ G_PARAM_MASK = 0x000f,
+ /* bits in the range 0xfff0 are reserved for 3rd party usage */
+ G_PARAM_USER_MASK = 0xfff0
+} GParamFlags;
+</ENUM>
+<STRUCT>
+<NAME>GParamSpecClass</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpec</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpec</NAME>
+struct GParamSpec
+{
+ GTypeInstance g_instance;
+
+ gchar *name;
+ gchar *nick;
+ gchar *blurb;
+ GParamFlags flags;
+
+ /*< private >*/
+ GType owner_type;
+ GData *qdata;
+ guint ref_count;
+};
+</STRUCT>
+<FUNCTION>
+<NAME>g_param_spec_ref</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+GParamSpec *pspec
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_unref</NAME>
+<RETURNS>void </RETURNS>
+GParamSpec *pspec
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_get_qdata</NAME>
+<RETURNS>gpointer </RETURNS>
+GParamSpec *pspec,GQuark quark
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_set_qdata</NAME>
+<RETURNS>void </RETURNS>
+GParamSpec *pspec,GQuark quark,gpointer data
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_set_qdata_full</NAME>
+<RETURNS>void </RETURNS>
+GParamSpec *pspec,GQuark quark,gpointer data,GDestroyNotify destroy
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_steal_qdata</NAME>
+<RETURNS>gpointer </RETURNS>
+GParamSpec *pspec,GQuark quark
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_value_set_default</NAME>
+<RETURNS>void </RETURNS>
+GParamSpec *pspec,GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_value_defaults</NAME>
+<RETURNS>gboolean </RETURNS>
+GParamSpec *pspec,GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_value_validate</NAME>
+<RETURNS>gboolean </RETURNS>
+GParamSpec *pspec,GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_values_cmp</NAME>
+<RETURNS>gint </RETURNS>
+GParamSpec *pspec,const GValue *value1,const GValue *value2
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_internal</NAME>
+<RETURNS>gpointer </RETURNS>
+GType param_type,const gchar *name,const gchar *nick,const gchar *blurb,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_hash_table_new</NAME>
+<RETURNS>GHashTable *</RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_hash_table_insert</NAME>
+<RETURNS>void </RETURNS>
+GHashTable *hash_table,GParamSpec *pspec,GType owner_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_hash_table_remove</NAME>
+<RETURNS>void </RETURNS>
+GHashTable *hash_table,GParamSpec *pspec
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_hash_table_lookup</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+GHashTable *hash_table,const gchar *param_name,GType owner_type,gboolean try_ancestors,const gchar **trailer
+</FUNCTION>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_CHAR</NAME>
+#define G_IS_PARAM_SPEC_CHAR(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_CHAR))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_CHAR</NAME>
+#define G_PARAM_SPEC_CHAR(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_CHAR, GParamSpecChar))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_UCHAR</NAME>
+#define G_IS_PARAM_SPEC_UCHAR(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UCHAR))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_UCHAR</NAME>
+#define G_PARAM_SPEC_UCHAR(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UCHAR, GParamSpecUChar))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_BOOLEAN</NAME>
+#define G_IS_PARAM_SPEC_BOOLEAN(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_BOOLEAN))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_BOOLEAN</NAME>
+#define G_PARAM_SPEC_BOOLEAN(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_BOOLEAN, GParamSpecBoolean))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_INT</NAME>
+#define G_IS_PARAM_SPEC_INT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_INT))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_INT</NAME>
+#define G_PARAM_SPEC_INT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_INT, GParamSpecInt))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_UINT</NAME>
+#define G_IS_PARAM_SPEC_UINT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UINT))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_UINT</NAME>
+#define G_PARAM_SPEC_UINT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UINT, GParamSpecUInt))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_LONG</NAME>
+#define G_IS_PARAM_SPEC_LONG(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_LONG))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_LONG</NAME>
+#define G_PARAM_SPEC_LONG(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_LONG, GParamSpecLong))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_ULONG</NAME>
+#define G_IS_PARAM_SPEC_ULONG(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ULONG))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_ULONG</NAME>
+#define G_PARAM_SPEC_ULONG(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ULONG, GParamSpecULong))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_ENUM</NAME>
+#define G_IS_PARAM_SPEC_ENUM(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ENUM))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_ENUM</NAME>
+#define G_PARAM_SPEC_ENUM(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ENUM, GParamSpecEnum))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_FLAGS</NAME>
+#define G_IS_PARAM_SPEC_FLAGS(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_FLAGS))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_FLAGS</NAME>
+#define G_PARAM_SPEC_FLAGS(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_FLAGS, GParamSpecFlags))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_FLOAT</NAME>
+#define G_IS_PARAM_SPEC_FLOAT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_FLOAT))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_FLOAT</NAME>
+#define G_PARAM_SPEC_FLOAT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_FLOAT, GParamSpecFloat))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_DOUBLE</NAME>
+#define G_IS_PARAM_SPEC_DOUBLE(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_DOUBLE))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_DOUBLE</NAME>
+#define G_PARAM_SPEC_DOUBLE(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_DOUBLE, GParamSpecDouble))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_STRING</NAME>
+#define G_IS_PARAM_SPEC_STRING(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_STRING))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_STRING</NAME>
+#define G_PARAM_SPEC_STRING(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_STRING, GParamSpecString))
+</MACRO>
+<MACRO>
+<NAME>G_IS_PARAM_SPEC_OBJECT</NAME>
+#define G_IS_PARAM_SPEC_OBJECT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_OBJECT))
+</MACRO>
+<MACRO>
+<NAME>G_PARAM_SPEC_OBJECT</NAME>
+#define G_PARAM_SPEC_OBJECT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_OBJECT, GParamSpecObject))
+</MACRO>
+<STRUCT>
+<NAME>GParamSpecChar</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecUChar</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecBoolean</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecInt</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecUInt</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecLong</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecULong</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecEnum</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecFlags</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecFloat</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecDouble</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecString</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecObject</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecChar</NAME>
+struct GParamSpecChar
+{
+ GParamSpec parent_instance;
+
+ gint8 minimum;
+ gint8 maximum;
+ gint8 default_value;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecUChar</NAME>
+struct GParamSpecUChar
+{
+ GParamSpec parent_instance;
+
+ guint8 minimum;
+ guint8 maximum;
+ guint8 default_value;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecBoolean</NAME>
+struct GParamSpecBoolean
+{
+ GParamSpec parent_instance;
+
+ gboolean default_value;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecInt</NAME>
+struct GParamSpecInt
+{
+ GParamSpec parent_instance;
+
+ gint minimum;
+ gint maximum;
+ gint default_value;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecUInt</NAME>
+struct GParamSpecUInt
+{
+ GParamSpec parent_instance;
+
+ guint minimum;
+ guint maximum;
+ guint default_value;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecLong</NAME>
+struct GParamSpecLong
+{
+ GParamSpec parent_instance;
+
+ glong minimum;
+ glong maximum;
+ glong default_value;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecULong</NAME>
+struct GParamSpecULong
+{
+ GParamSpec parent_instance;
+
+ gulong minimum;
+ gulong maximum;
+ gulong default_value;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecEnum</NAME>
+struct GParamSpecEnum
+{
+ GParamSpec parent_instance;
+
+ GEnumClass *enum_class;
+ glong default_value;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecFlags</NAME>
+struct GParamSpecFlags
+{
+ GParamSpec parent_instance;
+
+ GFlagsClass *flags_class;
+ gulong default_value;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecFloat</NAME>
+struct GParamSpecFloat
+{
+ GParamSpec parent_instance;
+
+ gfloat minimum;
+ gfloat maximum;
+ gfloat default_value;
+ gfloat epsilon;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecDouble</NAME>
+struct GParamSpecDouble
+{
+ GParamSpec parent_instance;
+
+ gdouble minimum;
+ gdouble maximum;
+ gdouble default_value;
+ gdouble epsilon;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecString</NAME>
+struct GParamSpecString
+{
+ GParamSpec parent_instance;
+
+ gchar *default_value;
+ gchar *cset_first;
+ gchar *cset_nth;
+ gchar substitutor;
+ guint null_fold_if_empty : 1;
+ guint ensure_non_null : 1;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GParamSpecObject</NAME>
+struct GParamSpecObject
+{
+ GParamSpec parent_instance;
+
+ GType object_type;
+};
+</STRUCT>
+<FUNCTION>
+<NAME>g_param_spec_char</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,gint8 minimum,gint8 maximum,gint8 default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_uchar</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,guint8 minimum,guint8 maximum,guint8 default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_boolean</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,gboolean default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_int</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,gint minimum,gint maximum,gint default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_uint</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,guint minimum,guint maximum,guint default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_long</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,glong minimum,glong maximum,glong default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_ulong</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,gulong minimum,gulong maximum,gulong default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_enum</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,GType enum_type,gint default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_flags</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,GType flags_type,guint default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_float</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,gfloat minimum,gfloat maximum,gfloat default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_double</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,gdouble minimum,gdouble maximum,gdouble default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_string</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,const gchar *default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_string_c</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,const gchar *default_value,GParamFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_param_spec_object</NAME>
+<RETURNS>GParamSpec *</RETURNS>
+const gchar *name,const gchar *nick,const gchar *blurb,GType object_type,GParamFlags flags
+</FUNCTION>
+<VARIABLE>
+<NAME>g_log_domain_gobject</NAME>
+extern const char *g_log_domain_gobject;
+</VARIABLE>
+<MACRO>
+<NAME>G_TYPE_FUNDAMENTAL</NAME>
+#define G_TYPE_FUNDAMENTAL(type) ((type) & 0xff)
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_FUNDAMENTAL_MAX</NAME>
+#define G_TYPE_FUNDAMENTAL_MAX (0xff)
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_DERIVE_ID</NAME>
+#define G_TYPE_DERIVE_ID(ptype, branch_seqno) (G_TYPE_FUNDAMENTAL (ptype) | ((branch_seqno) << 8))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_BRANCH_SEQNO</NAME>
+#define G_TYPE_BRANCH_SEQNO(type) ((type) >> 8)
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_FUNDAMENTAL_LAST</NAME>
+#define G_TYPE_FUNDAMENTAL_LAST ((GType) g_type_fundamental_last ())
+</MACRO>
+<ENUM>
+<NAME>GTypeFundamentals</NAME>
+typedef enum /*< skip >*/
+{
+ /* standard types, introduced by g_type_init() */
+ G_TYPE_INVALID,
+ G_TYPE_NONE,
+ G_TYPE_INTERFACE,
+
+ /* GLib type ids */
+ G_TYPE_CHAR,
+ G_TYPE_UCHAR,
+ G_TYPE_BOOLEAN,
+ G_TYPE_INT,
+ G_TYPE_UINT,
+ G_TYPE_LONG,
+ G_TYPE_ULONG,
+ G_TYPE_ENUM,
+ G_TYPE_FLAGS,
+ G_TYPE_FLOAT,
+ G_TYPE_DOUBLE,
+ G_TYPE_STRING,
+ G_TYPE_PARAM,
+ G_TYPE_OBJECT,
+
+ /* the following reserved ids should vanish soon */
+ G_TYPE_GTK_BOXED,
+ G_TYPE_GTK_POINTER,
+ G_TYPE_GTK_SIGNAL,
+
+ /* reserved fundamental type ids,
+ * mail gtk-devel-list@redhat.com for reservations
+ */
+ G_TYPE_BSE_PROCEDURE,
+ G_TYPE_BSE_TIME,
+ G_TYPE_BSE_NOTE,
+ G_TYPE_BSE_DOTS,
+ G_TYPE_GLE_GOBJECT,
+
+ G_TYPE_LAST_RESERVED_FUNDAMENTAL,
+
+ /* derived type ids */
+ /* FIXME: G_TYPE_PARAM_INTERFACE */
+ G_TYPE_PARAM_CHAR = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 1),
+ G_TYPE_PARAM_UCHAR = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 2),
+ G_TYPE_PARAM_BOOLEAN = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 3),
+ G_TYPE_PARAM_INT = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 4),
+ G_TYPE_PARAM_UINT = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 5),
+ G_TYPE_PARAM_LONG = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 6),
+ G_TYPE_PARAM_ULONG = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 7),
+ G_TYPE_PARAM_ENUM = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 8),
+ G_TYPE_PARAM_FLAGS = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 9),
+ G_TYPE_PARAM_FLOAT = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 10),
+ G_TYPE_PARAM_DOUBLE = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 11),
+ G_TYPE_PARAM_STRING = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 12),
+ /* FIXME: G_TYPE_PARAM_PARAM */
+ G_TYPE_PARAM_OBJECT = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 13)
+} GTypeFundamentals;
+</ENUM>
+<MACRO>
+<NAME>G_TYPE_IS_INTERFACE</NAME>
+#define G_TYPE_IS_INTERFACE(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE)
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_IS_CLASSED</NAME>
+#define G_TYPE_IS_CLASSED(type) (g_type_check_flags ((type), G_TYPE_FLAG_CLASSED))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_IS_INSTANTIATABLE</NAME>
+#define G_TYPE_IS_INSTANTIATABLE(type) (g_type_check_flags ((type), G_TYPE_FLAG_INSTANTIATABLE))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_IS_DERIVABLE</NAME>
+#define G_TYPE_IS_DERIVABLE(type) (g_type_check_flags ((type), G_TYPE_FLAG_DERIVABLE))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_IS_DEEP_DERIVABLE</NAME>
+#define G_TYPE_IS_DEEP_DERIVABLE(type) (g_type_check_flags ((type), G_TYPE_FLAG_DEEP_DERIVABLE))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_IS_PARAM</NAME>
+#define G_TYPE_IS_PARAM(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_PARAM)
+</MACRO>
+<TYPEDEF>
+<NAME>GType</NAME>
+typedef guint32 GType;
+</TYPEDEF>
+<STRUCT>
+<NAME>GValue</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GTypePlugin</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GTypePluginVTable</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GTypeClass</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GTypeInterface</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GTypeInstance</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GTypeInfo</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GTypeFundamentalInfo</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GInterfaceInfo</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GTypeValueTable</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GTypeInstance</NAME>
+struct GTypeInstance
+{
+ /*< private >*/
+ GTypeClass *g_class;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GTypeInterface</NAME>
+struct GTypeInterface
+{
+ /*< private >*/
+ GType g_type; /* iface type */
+ GType g_instance_type;
+};
+</STRUCT>
+<MACRO>
+<NAME>G_TYPE_CHECK_INSTANCE_CAST</NAME>
+#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_CHECK_CLASS_CAST</NAME>
+#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_CHECK_INSTANCE_TYPE</NAME>
+#define G_TYPE_CHECK_INSTANCE_TYPE(instance, g_type) (_G_TYPE_CIT ((instance), (g_type)))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_CHECK_CLASS_TYPE</NAME>
+#define G_TYPE_CHECK_CLASS_TYPE(g_class, g_type) (_G_TYPE_CCT ((g_class), (g_type)))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_INSTANCE_GET_CLASS</NAME>
+#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), c_type))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_FROM_INSTANCE</NAME>
+#define G_TYPE_FROM_INSTANCE(instance) (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class))
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_FROM_CLASS</NAME>
+#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type)
+</MACRO>
+<MACRO>
+<NAME>G_TYPE_FROM_INTERFACE</NAME>
+#define G_TYPE_FROM_INTERFACE(g_iface) (((GTypeInterface*) (g_iface))->g_type)
+</MACRO>
+<FUNCTION>
+<NAME>g_type_init</NAME>
+<RETURNS>void </RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_name</NAME>
+<RETURNS>gchar *</RETURNS>
+GType type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_qname</NAME>
+<RETURNS>GQuark </RETURNS>
+GType type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_from_name</NAME>
+<RETURNS>GType </RETURNS>
+const gchar *name
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_parent</NAME>
+<RETURNS>GType </RETURNS>
+GType type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_next_base</NAME>
+<RETURNS>GType </RETURNS>
+GType type,GType base_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_is_a</NAME>
+<RETURNS>gboolean </RETURNS>
+GType type,GType is_a_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_conforms_to</NAME>
+<RETURNS>gboolean </RETURNS>
+GType type,GType iface_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_fundamental_branch_last</NAME>
+<RETURNS>guint </RETURNS>
+GType type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_class_ref</NAME>
+<RETURNS>gpointer </RETURNS>
+GType type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_class_peek</NAME>
+<RETURNS>gpointer </RETURNS>
+GType type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_class_unref</NAME>
+<RETURNS>void </RETURNS>
+gpointer g_class
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_class_peek_parent</NAME>
+<RETURNS>gpointer </RETURNS>
+gpointer g_class
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_interface_peek</NAME>
+<RETURNS>gpointer </RETURNS>
+gpointer instance_class,GType iface_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_children</NAME>
+<RETURNS>GType *</RETURNS>
+GType type,guint *n_children
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_interfaces</NAME>
+<RETURNS>GType *</RETURNS>
+GType type,guint *n_interfaces
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_set_qdata</NAME>
+<RETURNS>void </RETURNS>
+GType type,GQuark quark,gpointer data
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_get_qdata</NAME>
+<RETURNS>gpointer </RETURNS>
+GType type,GQuark quark
+</FUNCTION>
+<USER_FUNCTION>
+<NAME>GBaseInitFunc</NAME>
+<RETURNS>void </RETURNS>
+gpointer g_class
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GBaseFinalizeFunc</NAME>
+<RETURNS>void </RETURNS>
+gpointer g_class
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GClassInitFunc</NAME>
+<RETURNS>void </RETURNS>
+gpointer g_class,
+ gpointer class_data
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GClassFinalizeFunc</NAME>
+<RETURNS>void </RETURNS>
+gpointer g_class,
+ gpointer class_data
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GInstanceInitFunc</NAME>
+<RETURNS>void </RETURNS>
+GTypeInstance *instance,
+ gpointer g_class
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GInterfaceInitFunc</NAME>
+<RETURNS>void </RETURNS>
+gpointer g_iface,
+ gpointer iface_data
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GInterfaceFinalizeFunc</NAME>
+<RETURNS>void </RETURNS>
+gpointer g_iface,
+ gpointer iface_data
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GTypePluginRef</NAME>
+<RETURNS>void </RETURNS>
+GTypePlugin *plugin
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GTypePluginUnRef</NAME>
+<RETURNS>void </RETURNS>
+GTypePlugin *plugin
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GTypePluginFillTypeInfo</NAME>
+<RETURNS>void </RETURNS>
+GTypePlugin *plugin,
+ GType g_type,
+ GTypeInfo *info,
+ GTypeValueTable *value_table
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GTypePluginFillInterfaceInfo</NAME>
+<RETURNS>void </RETURNS>
+GTypePlugin *plugin,
+ GType interface_type,
+ GType instance_type,
+ GInterfaceInfo *info
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GTypeClassCacheFunc</NAME>
+<RETURNS>gboolean </RETURNS>
+gpointer cache_data,
+ GTypeClass *g_class
+</USER_FUNCTION>
+<STRUCT>
+<NAME>GTypePlugin</NAME>
+struct GTypePlugin
+{
+ GTypePluginVTable *vtable;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GTypePluginVTable</NAME>
+struct GTypePluginVTable
+{
+ GTypePluginRef plugin_ref;
+ GTypePluginUnRef plugin_unref;
+ GTypePluginFillTypeInfo complete_type_info;
+ GTypePluginFillInterfaceInfo complete_interface_info;
+};
+</STRUCT>
+<ENUM>
+<NAME>GTypeFlags</NAME>
+typedef enum /*< skip >*/
+{
+ G_TYPE_FLAG_CLASSED = (1 << 0),
+ G_TYPE_FLAG_INSTANTIATABLE = (1 << 1),
+ G_TYPE_FLAG_DERIVABLE = (1 << 2),
+ G_TYPE_FLAG_DEEP_DERIVABLE = (1 << 3)
+} GTypeFlags;
+</ENUM>
+<STRUCT>
+<NAME>GTypeInfo</NAME>
+struct GTypeInfo
+{
+ /* interface types, classed types, instantiated types */
+ guint16 class_size;
+
+ GBaseInitFunc base_init;
+ GBaseFinalizeFunc base_finalize;
+
+ /* classed types, instantiated types */
+ GClassInitFunc class_init;
+ GClassFinalizeFunc class_finalize;
+ gconstpointer class_data;
+
+ /* instantiated types */
+ guint16 instance_size;
+ guint16 n_preallocs;
+ GInstanceInitFunc instance_init;
+
+ /* value handling */
+ const GTypeValueTable *value_table;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GTypeFundamentalInfo</NAME>
+struct GTypeFundamentalInfo
+{
+ GTypeFlags type_flags;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GInterfaceInfo</NAME>
+struct GInterfaceInfo
+{
+ GInterfaceInitFunc interface_init;
+ GInterfaceFinalizeFunc interface_finalize;
+ gpointer interface_data;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GTypeValueTable</NAME>
+struct GTypeValueTable
+{
+ void (*value_init) (GValue *value);
+ void (*value_free) (GValue *value);
+ void (*value_copy) (const GValue *src_value,
+ GValue *dest_value);
+ /* varargs functionality (optional) */
+ guint collect_type;
+ gchar* (*collect_value) (GValue *value,
+ guint nth_value,
+ GType *collect_type,
+ GTypeCValue *collect_value);
+ guint lcopy_type;
+ gchar* (*lcopy_value) (const GValue *value,
+ guint nth_value,
+ GType *collect_type,
+ GTypeCValue *collect_value);
+};
+</STRUCT>
+<FUNCTION>
+<NAME>g_type_register_static</NAME>
+<RETURNS>GType </RETURNS>
+GType parent_type,const gchar *type_name,const GTypeInfo *info
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_register_dynamic</NAME>
+<RETURNS>GType </RETURNS>
+GType parent_type,const gchar *type_name,GTypePlugin *plugin
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_register_fundamental</NAME>
+<RETURNS>GType </RETURNS>
+GType type_id,const gchar *type_name,const GTypeInfo *info,const GTypeFundamentalInfo *finfo
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_add_interface_static</NAME>
+<RETURNS>void </RETURNS>
+GType instance_type,GType interface_type,GInterfaceInfo *info
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_add_interface_dynamic</NAME>
+<RETURNS>void </RETURNS>
+GType instance_type,GType interface_type,GTypePlugin *plugin
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_class_is_a</NAME>
+<RETURNS>gboolean </RETURNS>
+GTypeClass *g_class,GType is_a_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_check_class_cast</NAME>
+<RETURNS>GTypeClass *</RETURNS>
+GTypeClass *g_class,GType is_a_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_check_instance_cast</NAME>
+<RETURNS>GTypeInstance *</RETURNS>
+GTypeInstance *instance,GType iface_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_instance_conforms_to</NAME>
+<RETURNS>gboolean </RETURNS>
+GTypeInstance *instance,GType iface_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_check_flags</NAME>
+<RETURNS>gboolean </RETURNS>
+GType type,GTypeFlags flags
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_create_instance</NAME>
+<RETURNS>GTypeInstance *</RETURNS>
+GType type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_free_instance</NAME>
+<RETURNS>void </RETURNS>
+GTypeInstance *instance
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_value_table_peek</NAME>
+<RETURNS>GTypeValueTable *</RETURNS>
+GType type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_add_class_cache_func</NAME>
+<RETURNS>void </RETURNS>
+gpointer cache_data,GTypeClassCacheFunc cache_func
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_remove_class_cache_func</NAME>
+<RETURNS>void </RETURNS>
+gpointer cache_data,GTypeClassCacheFunc cache_func
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_class_unref_uncached</NAME>
+<RETURNS>void </RETURNS>
+gpointer g_class
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_get_plugin</NAME>
+<RETURNS>GTypePlugin *</RETURNS>
+GType type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_type_fundamental_last</NAME>
+<RETURNS>GType </RETURNS>
+void
+</FUNCTION>
+<MACRO>
+<NAME>G_TYPE_IS_VALUE</NAME>
+#define G_TYPE_IS_VALUE(type) (g_type_value_table_peek (type) != NULL)
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE</NAME>
+#define G_IS_VALUE(value) (G_TYPE_IS_VALUE (G_VALUE_TYPE (value))) /* FIXME */
+</MACRO>
+<MACRO>
+<NAME>G_VALUE_TYPE</NAME>
+#define G_VALUE_TYPE(value) (G_TYPE_FROM_CLASS (value))
+</MACRO>
+<MACRO>
+<NAME>G_VALUE_TYPE_NAME</NAME>
+#define G_VALUE_TYPE_NAME(value) (g_type_name (G_VALUE_TYPE (value)))
+</MACRO>
+<USER_FUNCTION>
+<NAME>GValueExchange</NAME>
+<RETURNS>void </RETURNS>
+GValue *value1,
+ GValue *value2
+</USER_FUNCTION>
+<STRUCT>
+<NAME>GValue</NAME>
+struct GValue
+{
+ /*< private >*/
+ GType g_type;
+
+ /* public for GTypeValueTable methods */
+ union {
+ gint v_int;
+ guint v_uint;
+ glong v_long;
+ gulong v_ulong;
+ gfloat v_float;
+ gdouble v_double;
+ gpointer v_pointer;
+ } data[4];
+};
+</STRUCT>
+<FUNCTION>
+<NAME>g_value_init</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,GType g_type
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_copy</NAME>
+<RETURNS>void </RETURNS>
+const GValue *src_value,GValue *dest_value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_convert</NAME>
+<RETURNS>gboolean </RETURNS>
+const GValue *src_value,GValue *dest_value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_reset</NAME>
+<RETURNS>void </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_unset</NAME>
+<RETURNS>void </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_values_exchange</NAME>
+<RETURNS>gboolean </RETURNS>
+GValue *value1,GValue *value2
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_types_exchangable</NAME>
+<RETURNS>gboolean </RETURNS>
+GType value_type1,GType value_type2
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_register_exchange_func</NAME>
+<RETURNS>void </RETURNS>
+GType value_type1,GType value_type2,GValueExchange func
+</FUNCTION>
+<UNION>
+<NAME>GTypeCValue</NAME>
+union GTypeCValue
+{
+ gint v_int;
+ glong v_long;
+ gdouble v_double;
+ gpointer v_pointer;
+};
+</UNION>
+<MACRO>
+<NAME>G_VALUE_COLLECT</NAME>
+#define G_VALUE_COLLECT(value, var_args, __error) \
+G_STMT_START { \
+ GValue *_value = (value); \
+ GTypeValueTable *_vtable = g_type_value_table_peek (G_VALUE_TYPE (_value)); \
+ gchar *_error_msg = NULL; \
+ guint _collect_type = _vtable->collect_type; \
+ guint _nth_value = 0; \
+ \
+ g_value_reset (_value); \
+ while (_collect_type && !_error_msg) \
+ { \
+ GTypeCValue _cvalue; \
+ \
+ memset (&_cvalue, 0, sizeof (_cvalue)); \
+ switch (_collect_type) \
+ { \
+ case G_VALUE_COLLECT_INT: \
+ _cvalue.v_int = va_arg ((var_args), gint); \
+ break; \
+ case G_VALUE_COLLECT_LONG: \
+ _cvalue.v_long = va_arg ((var_args), glong); \
+ break; \
+ case G_VALUE_COLLECT_DOUBLE: \
+ _cvalue.v_double = va_arg ((var_args), gdouble); \
+ break; \
+ case G_VALUE_COLLECT_POINTER: \
+ _cvalue.v_pointer = va_arg ((var_args), gpointer); \
+ break; \
+ default: \
+ _error_msg = g_strdup_printf ("%s: invalid collect type (%d) used for %s", \
+ G_STRLOC, \
+ _collect_type, \
+ "G_VALUE_COLLECT()"); \
+ continue; \
+ } \
+ _error_msg = _vtable->collect_value (_value, \
+ _nth_value++, \
+ &_collect_type, \
+ &_cvalue); \
+ } \
+ *(__error) = _error_msg; \
+} G_STMT_END
+</MACRO>
+<MACRO>
+<NAME>G_VALUE_LCOPY</NAME>
+#define G_VALUE_LCOPY(value, var_args, __error) \
+G_STMT_START { \
+ GValue *_value = (value); \
+ GTypeValueTable *_vtable = g_type_value_table_peek (G_VALUE_TYPE (_value)); \
+ gchar *_error_msg = NULL; \
+ guint _lcopy_type = _vtable->lcopy_type; \
+ guint _nth_value = 0; \
+ \
+ while (_lcopy_type && !_error_msg) \
+ { \
+ GTypeCValue _cvalue; \
+ \
+ memset (&_cvalue, 0, sizeof (_cvalue)); \
+ switch (_lcopy_type) \
+ { \
+ case G_VALUE_COLLECT_INT: \
+ _cvalue.v_int = va_arg ((var_args), gint); \
+ break; \
+ case G_VALUE_COLLECT_LONG: \
+ _cvalue.v_long = va_arg ((var_args), glong); \
+ break; \
+ case G_VALUE_COLLECT_DOUBLE: \
+ _cvalue.v_double = va_arg ((var_args), gdouble); \
+ break; \
+ case G_VALUE_COLLECT_POINTER: \
+ _cvalue.v_pointer = va_arg ((var_args), gpointer); \
+ break; \
+ default: \
+ _error_msg = g_strdup_printf ("%s: invalid collect type (%d) used for %s", \
+ G_STRLOC, \
+ _lcopy_type, \
+ "G_VALUE_LCOPY()"); \
+ continue; \
+ } \
+ _error_msg = _vtable->lcopy_value (_value, \
+ _nth_value++, \
+ &_lcopy_type, \
+ &_cvalue); \
+ } \
+ *(__error) = _error_msg; \
+} G_STMT_END
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_CHAR</NAME>
+#define G_IS_VALUE_CHAR(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_CHAR))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_UCHAR</NAME>
+#define G_IS_VALUE_UCHAR(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_UCHAR))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_BOOLEAN</NAME>
+#define G_IS_VALUE_BOOLEAN(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_BOOLEAN))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_INT</NAME>
+#define G_IS_VALUE_INT(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_INT))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_UINT</NAME>
+#define G_IS_VALUE_UINT(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_UINT))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_LONG</NAME>
+#define G_IS_VALUE_LONG(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_LONG))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_ULONG</NAME>
+#define G_IS_VALUE_ULONG(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_ULONG))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_FLOAT</NAME>
+#define G_IS_VALUE_FLOAT(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_FLOAT))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_DOUBLE</NAME>
+#define G_IS_VALUE_DOUBLE(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_DOUBLE))
+</MACRO>
+<MACRO>
+<NAME>G_IS_VALUE_STRING</NAME>
+#define G_IS_VALUE_STRING(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_STRING))
+</MACRO>
+<FUNCTION>
+<NAME>g_value_set_char</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,gint8 v_char
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_char</NAME>
+<RETURNS>gint8 </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_uchar</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,guint8 v_uchar
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_uchar</NAME>
+<RETURNS>guint8 </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_boolean</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,gboolean v_boolean
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_boolean</NAME>
+<RETURNS>gboolean </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_int</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,gint v_int
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_int</NAME>
+<RETURNS>gint </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_uint</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,guint v_uint
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_uint</NAME>
+<RETURNS>guint </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_long</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,glong v_long
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_long</NAME>
+<RETURNS>glong </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_ulong</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,gulong v_ulong
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_ulong</NAME>
+<RETURNS>gulong </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_float</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,gfloat v_float
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_float</NAME>
+<RETURNS>gfloat </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_double</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,gdouble v_double
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_double</NAME>
+<RETURNS>gdouble </RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_set_string</NAME>
+<RETURNS>void </RETURNS>
+GValue *value,const gchar *v_string
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_get_string</NAME>
+<RETURNS>gchar *</RETURNS>
+GValue *value
+</FUNCTION>
+<FUNCTION>
+<NAME>g_value_dup_string</NAME>
+<RETURNS>gchar *</RETURNS>
+GValue *value
+</FUNCTION>
#define G_STATIC_PRIVATE_INIT
</MACRO>
+# Definitions for different operating systems
+<MACRO>
+<NAME>G_OS_UNIX</NAME>
+#define G_OS_UNIX
+</MACRO>
+<MACRO>
+<NAME>G_OS_WIN32</NAME>
+#define G_OS_WIN32
+</MACRO>
+
+<MACRO>
+<NAME>G_OS_BEOS</NAME>
+#define G_OS_BEOS
+</MACRO>
-
<INCLUDE>glib.h</INCLUDE>
<SECTION>
gsize
gssize
+<SUBSECTION>
+gstring
+
<SUBSECTION Private>
gldouble
-
-# I don't really know where to put these.
-G_HAVE_WCHAR_H
-G_HAVE_WCTYPE_H
-GUTILS_C_VAR
</SECTION>
<SECTION>
<FILE>limits</FILE>
G_MININT
G_MAXINT
+G_MAXUINT
<SUBSECTION>
G_MINSHORT
G_MAXSHORT
+G_MAXUSHORT
<SUBSECTION>
G_MINLONG
G_MAXLONG
+G_MAXULONG
<SUBSECTION>
G_MINFLOAT
GLIB_MINOR_VERSION
GLIB_MICRO_VERSION
+<SUBSECTION>
+G_OS_WIN32
+G_OS_BEOS
+G_OS_UNIX
+
<SUBSECTION>
GLIB_CHECK_VERSION
GUINT64_SWAP_LE_BE_X86
</SECTION>
+<SECTION>
+<TITLE>Numerical Definitions</TITLE>
+<FILE>numerical</FILE>
+G_IEEE754_FLOAT_BIAS
+G_IEEE754_DOUBLE_BIAS
+GFloatIEEE754
+GDoubleIEEE754
+
+<SUBSECTION>
+<SUBSECTION>
+G_E
+G_LN2
+G_LN10
+G_PI
+G_PI_2
+G_PI_4
+G_SQRT2
+G_LOG_2_BASE_10
+</SECTION>
+
<SECTION>
<TITLE>Miscellaneous Macros</TITLE>
<FILE>macros_misc</FILE>
G_STMT_START
G_STMT_END
+<SUBSECTION>
+G_N_ELEMENTS
+
<SUBSECTION>
G_VA_COPY
+<SUBSECTION>
+G_STRINGIFY
+
<SUBSECTION>
G_GNUC_EXTENSION
G_GNUC_CONST
G_GNUC_PRETTY_FUNCTION
<SUBSECTION>
-g_string
+G_STRLOC
+
+<SUBSECTION>
+G_GSHORT_FORMAT
+G_GUSHORT_FORMAT
+G_GINT_FORMAT
+G_GUINT_FORMAT
+G_GLONG_FORMAT
+G_GULONG_FORMAT
+G_GINT16_FORMAT
+G_GUINT16_FORMAT
+G_GINT32_FORMAT
+G_GUINT32_FORMAT
+G_GINT64_FORMAT
+G_GUINT64_FORMAT
<SUBSECTION Private>
+GLIB_VAR
+G_STRINGIFY_ARG
G_HAVE_INLINE
G_CAN_INLINE
inline
G_HAVE___INLINE__
</SECTION>
+<SECTION>
+<TITLE>Error Reporting</TITLE>
+<FILE>error_reporting</FILE>
+GError
+g_error_new
+g_error_new_literal
+g_error_free
+g_error_copy
+g_error_matches
+g_set_error
+g_propagate_error
+g_clear_error
+</SECTION>
+
<SECTION>
<TITLE>The Main Event Loop</TITLE>
<FILE>main</FILE>
<SUBSECTION>
g_main_set_poll_func
+g_main_win32_get_poll_func
GPollFunc
<SUBSECTION>
G_THREADS_IMPL_SOLARIS
G_THREADS_IMPL_NONE
+<SUBSECTION>
+G_THREAD_ERROR
+GThreadError
+
<SUBSECTION>
GThreadFunctions
g_thread_init
g_thread_supported
+<SUBSECTION>
+GThreadFunc
+GThreadPriority
+GThread
+g_thread_create
+g_thread_self
+g_thread_join
+g_thread_set_priority
+g_thread_yield
+g_thread_exit
+
<SUBSECTION>
GMutex
g_mutex_new
G_TRYLOCK
G_UNLOCK
+<SUBSECTION>
+GStaticRecMutex
+G_STATIC_REC_MUTEX_INIT
+g_static_rec_mutex_lock
+g_static_rec_mutex_trylock
+g_static_rec_mutex_unlock
+g_static_rec_mutex_lock_full
+g_static_rec_mutex_unlock_full
+
+<SUBSECTION>
+GStaticRWLock
+G_STATIC_RW_LOCK_INIT
+g_static_rw_lock_reader_lock
+g_static_rw_lock_reader_trylock
+g_static_rw_lock_reader_unlock
+g_static_rw_lock_writer_lock
+g_static_rw_lock_writer_trylock
+g_static_rw_lock_writer_unlock
+g_static_rw_lock_free
+
<SUBSECTION>
GCond
g_cond_new
GStaticPrivate
G_STATIC_PRIVATE_INIT
g_static_private_get
+g_static_private_get_for_thread
g_static_private_set
+g_static_private_set_for_thread
<SUBSECTION Private>
G_THREAD_CF
g_static_mutex_get_mutex_impl
G_LOCK_NAME
glib_dummy_decl
+GSystemThread
+g_thread_error_quark
+</SECTION>
+
+<SECTION>
+<TITLE>Thread Pools</TITLE>
+<FILE>thread_pools</FILE>
+GThreadPool
+g_thread_pool_new
+g_thread_pool_push
+g_thread_pool_set_max_threads
+g_thread_pool_get_max_threads
+g_thread_pool_get_num_threads
+g_thread_pool_unprocessed
+g_thread_pool_free
+g_thread_pool_set_max_unused_threads
+g_thread_pool_get_max_unused_threads
+g_thread_pool_get_num_unused_threads
+g_thread_pool_stop_unused_threads
+</SECTION>
+
+<SECTION>
+<TITLE>Asynchronous Queues</TITLE>
+<FILE>async_queues</FILE>
+GAsyncQueue
+g_async_queue_new
+g_async_queue_lock
+g_async_queue_unlock
+g_async_queue_ref
+g_async_queue_ref_unlocked
+g_async_queue_unref
+g_async_queue_unref_and_unlock
+g_async_queue_push
+g_async_queue_push_unlocked
+g_async_queue_pop
+g_async_queue_pop_unlocked
+g_async_queue_try_pop
+g_async_queue_try_pop_unlocked
+g_async_queue_timed_pop
+g_async_queue_timed_pop_unlocked
+g_async_queue_length
+g_async_queue_length_unlocked
</SECTION>
<SECTION>
GIOFuncs
<SUBSECTION Private>
+g_io_channel_win32_new_fd
g_io_channel_win32_new_messages
-g_io_channel_win32_new_pipe
-g_io_channel_win32_new_pipe_with_wakeups
g_io_channel_win32_new_stream_socket
-
+g_io_channel_win32_poll
+g_io_channel_win32_make_pollfd
g_io_channel_win32_get_fd
-g_io_channel_win32_pipe_readable
-g_io_channel_win32_pipe_request_wakeups
</SECTION>
<SECTION>
<SUBSECTION>
g_return_if_fail
g_return_val_if_fail
+g_return_if_reached
+g_return_val_if_reached
<SUBSECTION>
g_assert
g_logv
g_message
g_warning
+g_critical
g_error
<SUBSECTION>
g_strndup
g_strnfill
+<SUBSECTION>
+g_strlcpy
+g_strlcat
+
<SUBSECTION>
g_strdup_printf
g_strdup_vprintf
g_strdelimit
G_STR_DELIMITERS
g_strescape
+g_strcompress
+g_strcanon
g_strsplit
g_strfreev
g_strconcat
<SECTION>
<TITLE>Date and Time Functions</TITLE>
<FILE>date</FILE>
+G_MICROSEC
GTimeVal
g_get_current_time
+g_usleep
<SUBSECTION>
GDate
g_dirname
g_path_is_absolute
g_path_skip_root
+g_path_get_dirname
+g_path_get_basename
+g_filename_to_utf8
+g_filename_from_utf8
<SUBSECTION>
g_bit_nth_lsf
GErrorType
G_CSET_a_2_z
G_CSET_A_2_Z
+G_CSET_DIGITS
G_CSET_LATINC
G_CSET_LATINS
<FILE>windows</FILE>
MAXPATHLEN
NAME_MAX
-getcwd
-getpid
pid_t
-access
-open
-read
-write
-lseek
-close
pipe
-popen
-pclose
-fdopen
ftruncate
opendir
readdir
rewinddir
closedir
+g_win32_error_message
+g_win32_getlocale
+
<SUBSECTION Private>
-gwin_ftruncate
-gwin_closedir
-gwin_opendir
-gwin_rewinddir
+g_win32_ftruncate
+g_win32_closedir
+g_win32_opendir
+g_win32_rewinddir
</SECTION>
g_list_insert_sorted
g_list_remove
g_list_remove_link
+g_list_delete_link
g_list_free
<SUBSECTION>
g_slist_append
g_slist_prepend
g_slist_insert
+g_slist_insert_before
g_slist_insert_sorted
g_slist_remove
g_slist_remove_link
+g_slist_delete_link
g_slist_free
g_slist_free_1
g_slist_pop_allocator
</SECTION>
+<SECTION>
+<TITLE>Doubly-ended Queues</TITLE>
+<FILE>queue</FILE>
+
+GQueue
+g_queue_new
+g_queue_free
+g_queue_push_head
+g_queue_push_tail
+g_queue_pop_head
+g_queue_pop_tail
+g_queue_is_empty
+g_queue_peek_head
+g_queue_peek_tail
+g_queue_push_head_link
+g_queue_push_tail_link
+g_queue_pop_head_link
+g_queue_pop_tail_link
+</SECTION>
+
+<SECTION>
+<TITLE>Trash Stacks</TITLE>
+<FILE>trash_stack</FILE>
+GTrashStack
+
+g_trash_stack_push
+g_trash_stack_pop
+g_trash_stack_peek
+g_trash_stack_height
+</SECTION>
+
<SECTION>
<TITLE>Hash Tables</TITLE>
<FILE>hash_tables</FILE>
g_string_sprintfa
g_string_append
g_string_append_c
+g_string_append_len
g_string_prepend
g_string_prepend_c
+g_string_prepend_len
g_string_insert
g_string_insert_c
+g_string_insert_len
g_string_erase
g_string_truncate
g_string_free
g_string_up
g_string_down
+<SUBSECTION>
+g_string_hash
+g_string_equal
+
</SECTION>
<SECTION>
<FILE>arrays</FILE>
GArray
g_array_new
+g_array_sized_new
g_array_append_val
g_array_append_vals
g_array_prepend_val
<FILE>arrays_pointer</FILE>
GPtrArray
g_ptr_array_new
+g_ptr_array_sized_new
g_ptr_array_add
g_ptr_array_remove
g_ptr_array_remove_index
<FILE>arrays_byte</FILE>
GByteArray
g_byte_array_new
+g_byte_array_sized_new
g_byte_array_append
g_byte_array_prepend
g_byte_array_remove_index
g_tree_height
g_tree_lookup
g_tree_search
-GSearchFunc
g_tree_traverse
GTraverseFunc
GTraverseType
<FILE>trees-nary</FILE>
GNode
g_node_new
+g_node_copy
<SUBSECTION>
g_node_insert
G_ALLOCATOR_NODE
G_ALLOCATOR_SLIST
</SECTION>
+
+<SECTION>
+<TITLE>Random Numbers</TITLE>
+<FILE>random_numbers</FILE>
+GRand
+g_rand_new_with_seed
+g_rand_new
+g_rand_free
+g_rand_set_seed
+g_rand_int
+g_rand_int_range
+g_rand_double
+g_rand_double_range
+g_random_set_seed
+g_random_int
+g_random_int_range
+g_random_double
+g_random_double_range
+</SECTION>
+
+<SECTION>
+<TITLE>Unicode Manipulation</TITLE>
+<FILE>unicode</FILE>
+
+<SECTION>
+<FILE>gunicode</FILE>
+gunichar
+gunichar2
+
+<SUBSECTION>
+g_get_charset
+
+<SUBSECTION>
+g_unichar_isalnum
+g_unichar_isalpha
+g_unichar_iscntrl
+g_unichar_isdigit
+g_unichar_isgraph
+g_unichar_islower
+g_unichar_isprint
+g_unichar_ispunct
+g_unichar_isspace
+g_unichar_isupper
+g_unichar_isxdigit
+g_unichar_istitle
+g_unichar_isdefined
+g_unichar_iswide
+g_unichar_toupper
+g_unichar_tolower
+g_unichar_totitle
+g_unichar_digit_value
+g_unichar_xdigit_value
+GUnicodeType
+g_unichar_type
+g_unicode_canonical_ordering
+g_unicode_canonical_decomposition
+
+<SUBSECTION>
+g_utf8_next_char
+g_utf8_get_char
+g_utf8_offset_to_pointer
+g_utf8_pointer_to_offset
+g_utf8_prev_char
+g_utf8_find_next_char
+g_utf8_find_prev_char
+g_utf8_strlen
+g_utf8_strncpy
+g_utf8_strchr
+g_utf8_strrchr
+
+<SUBSECTION>
+g_utf8_to_utf16
+g_utf8_to_ucs4
+g_utf16_to_ucs4
+g_utf16_to_utf8
+g_ucs4_to_utf16
+g_ucs4_to_utf8
+g_unichar_to_utf8
+</SECTION>
+
+<SECTION>
+<TITLE>Type Information</TITLE>
+<FILE>types</FILE>
+GType
+G_TYPE_FUNDAMENTAL
+G_TYPE_FUNDAMENTAL_MAX
+G_TYPE_DERIVE_ID
+G_TYPE_BRANCH_SEQNO
+G_TYPE_FUNDAMENTAL_LAST
+GTypeFundamentals
+G_TYPE_IS_CLASSED
+G_TYPE_IS_INSTANTIATABLE
+G_TYPE_IS_DERIVABLE
+G_TYPE_IS_DEEP_DERIVABLE
+G_TYPE_IS_PARAM
+G_TYPE_IS_INTERFACE
+GTypePlugin
+GTypePluginVTable
+GTypeInterface
+GTypeInstance
+GTypeInfo
+GTypeFundamentalInfo
+GInterfaceInfo
+GTypeValueTable
+<TITLE>GType</TITLE>
+G_TYPE_CHECK_INSTANCE_CAST
+G_TYPE_CHECK_CLASS_CAST
+G_TYPE_CHECK_INSTANCE_TYPE
+G_TYPE_CHECK_CLASS_TYPE
+G_TYPE_INSTANCE_GET_CLASS
+G_TYPE_FROM_INSTANCE
+G_TYPE_FROM_CLASS
+G_TYPE_FROM_INTERFACE
+g_type_init
+g_type_name
+g_type_qname
+g_type_from_name
+g_type_parent
+g_type_next_base
+g_type_is_a
+g_type_conforms_to
+g_type_fundamental_branch_last
+g_type_class_ref
+g_type_class_peek
+g_type_class_unref
+g_type_class_peek_parent
+g_type_interface_peek
+g_type_children
+g_type_interfaces
+g_type_set_qdata
+g_type_get_qdata
+GBaseInitFunc
+GBaseFinalizeFunc
+GClassInitFunc
+GClassFinalizeFunc
+GInstanceInitFunc
+GInterfaceInitFunc
+GInterfaceFinalizeFunc
+GTypePluginRef
+GTypePluginUnRef
+GTypePluginFillTypeInfo
+GTypePluginFillInterfaceInfo
+GTypeClassCacheFunc
+GTypeFlags
+g_type_register_static
+g_type_register_dynamic
+g_type_register_fundamental
+g_type_add_interface_static
+g_type_add_interface_dynamic
+g_type_class_is_a
+g_type_check_class_cast
+g_type_check_instance_cast
+g_type_instance_conforms_to
+g_type_check_flags
+g_type_create_instance
+g_type_free_instance
+g_type_value_table_peek
+g_type_add_class_cache_func
+g_type_remove_class_cache_func
+g_type_class_unref_uncached
+g_type_get_plugin
+g_type_fundamental_last
+
+<SUBSECTION Private>
+g_log_domain_gobject
+</SECTION>
+
+<SECTION>
+<TITLE>The Base Object Type</TITLE>
+<FILE>objects</FILE>
+GObject
+GObjectClass
+G_OBJECT
+G_OBJECT_GET_CLASS
+G_OBJECT_TYPE
+G_OBJECT_TYPE_NAME
+G_OBJECT_CLASS_TYPE
+G_OBJECT_CLASS_NAME
+G_IS_VALUE_OBJECT
+G_TYPE_IS_OBJECT
+G_IS_OBJECT
+G_OBJECT_CLASS
+G_IS_OBJECT_CLASS
+G_NOTIFY_PRIORITY
+GObjectGetParamFunc
+GObjectSetParamFunc
+GObjectFinalizeFunc
+g_object_class_install_param
+g_object_class_find_param_spec
+g_object_new
+g_object_new_valist
+g_object_set
+g_object_get
+g_object_set_valist
+g_object_get_valist
+g_object_set_param
+g_object_get_param
+g_object_queue_param_changed
+g_object_ref
+g_object_unref
+g_object_get_qdata
+g_object_set_qdata
+g_object_set_qdata_full
+g_object_steal_qdata
+g_value_set_object
+g_value_get_object
+g_value_dup_object
+G_WARN_INVALID_PARAM_ID
+</SECTION>
+
+<SECTION>
+<TITLE>Enumeration and Flag Types</TITLE>
+<FILE>enumerations_flags</FILE>
+GEnumClass
+GFlagsClass
+G_ENUM_CLASS_TYPE
+G_ENUM_CLASS_TYPE_NAME
+G_TYPE_IS_ENUM
+G_ENUM_CLASS
+G_IS_ENUM_CLASS
+G_TYPE_IS_FLAGS
+G_FLAGS_CLASS
+G_IS_FLAGS_CLASS
+G_FLAGS_CLASS_TYPE
+G_FLAGS_CLASS_TYPE_NAME
+G_IS_VALUE_ENUM
+G_IS_VALUE_FLAGS
+GEnumValue
+GFlagsValue
+g_enum_get_value
+g_enum_get_value_by_name
+g_enum_get_value_by_nick
+g_flags_get_first_value
+g_flags_get_value_by_name
+g_flags_get_value_by_nick
+g_value_set_enum
+g_value_get_enum
+g_value_set_flags
+g_value_get_flags
+g_enum_register_static
+g_flags_register_static
+g_enum_complete_type_info
+g_flags_complete_type_info
+</SECTION>
+
+<SECTION>
+<TITLE>Generic values</TITLE>
+<FILE>generic_values</FILE>
+G_VALUE_TYPE
+G_VALUE_TYPE_NAME
+G_TYPE_IS_VALUE
+G_IS_VALUE
+GValueExchange
+GValue
+g_value_init
+g_value_copy
+g_value_convert
+g_value_reset
+g_value_unset
+g_values_exchange
+g_value_types_exchangable
+g_value_register_exchange_func
+</SECTION>
+
+<SECTION>
+<TITLE>Standard value types</TITLE>
+<FILE>value_types</FILE>
+G_IS_VALUE_CHAR
+G_IS_VALUE_UCHAR
+G_IS_VALUE_BOOLEAN
+G_IS_VALUE_INT
+G_IS_VALUE_UINT
+G_IS_VALUE_LONG
+G_IS_VALUE_ULONG
+G_IS_VALUE_FLOAT
+G_IS_VALUE_DOUBLE
+G_IS_VALUE_STRING
+g_value_set_char
+g_value_get_char
+g_value_set_uchar
+g_value_get_uchar
+g_value_set_boolean
+g_value_get_boolean
+g_value_set_int
+g_value_get_int
+g_value_set_uint
+g_value_get_uint
+g_value_set_long
+g_value_get_long
+g_value_set_ulong
+g_value_get_ulong
+g_value_set_float
+g_value_get_float
+g_value_set_double
+g_value_get_double
+g_value_set_string
+g_value_get_string
+g_value_dup_string
+</SECTION>
+
+<SECTION>
+<TITLE>Object Parameter Specifications</TITLE>
+<FILE>param_specs</FILE>
+GParamSpec
+GParamSpecClass
+G_PARAM_SPEC_TYPE
+G_PARAM_SPEC_TYPE_NAME
+G_PARAM_SPEC
+G_IS_PARAM_SPEC
+G_PARAM_SPEC_GET_CLASS
+G_IS_PARAM_VALUE
+G_PARAM_SPEC_VALUE_TYPE
+G_TYPE_IS_PARAM
+GParamFlags
+g_param_spec_ref
+g_param_spec_unref
+g_param_spec_get_qdata
+g_param_spec_set_qdata
+g_param_spec_set_qdata_full
+g_param_spec_steal_qdata
+g_param_value_set_default
+g_param_value_defaults
+g_param_value_validate
+g_param_values_cmp
+g_param_spec_internal
+g_param_spec_hash_table_new
+g_param_spec_hash_table_insert
+g_param_spec_hash_table_remove
+g_param_spec_hash_table_lookup
+</SECTION>
+
+<SECTION>
+<TITLE>Standard Parameter Types</TITLE>
+<FILE>standard_params</FILE>
+G_IS_PARAM_SPEC_CHAR
+G_PARAM_SPEC_CHAR
+G_IS_PARAM_SPEC_UCHAR
+G_PARAM_SPEC_UCHAR
+G_IS_PARAM_SPEC_BOOLEAN
+G_PARAM_SPEC_BOOLEAN
+G_IS_PARAM_SPEC_INT
+G_PARAM_SPEC_INT
+G_IS_PARAM_SPEC_UINT
+G_PARAM_SPEC_UINT
+G_IS_PARAM_SPEC_LONG
+G_PARAM_SPEC_LONG
+G_IS_PARAM_SPEC_ULONG
+G_PARAM_SPEC_ULONG
+G_IS_PARAM_SPEC_ENUM
+G_PARAM_SPEC_ENUM
+G_IS_PARAM_SPEC_FLAGS
+G_PARAM_SPEC_FLAGS
+G_IS_PARAM_SPEC_FLOAT
+G_PARAM_SPEC_FLOAT
+G_IS_PARAM_SPEC_DOUBLE
+G_PARAM_SPEC_DOUBLE
+G_IS_PARAM_SPEC_STRING
+G_PARAM_SPEC_STRING
+G_IS_PARAM_SPEC_OBJECT
+G_PARAM_SPEC_OBJECT
+GParamSpecChar
+GParamSpecUChar
+GParamSpecBoolean
+GParamSpecInt
+GParamSpecUInt
+GParamSpecLong
+GParamSpecULong
+GParamSpecEnum
+GParamSpecFlags
+GParamSpecFloat
+GParamSpecDouble
+GParamSpecString
+GParamSpecObject
+g_param_spec_char
+g_param_spec_uchar
+g_param_spec_boolean
+g_param_spec_int
+g_param_spec_uint
+g_param_spec_long
+g_param_spec_ulong
+g_param_spec_enum
+g_param_spec_flags
+g_param_spec_float
+g_param_spec_double
+g_param_spec_string
+g_param_spec_string_c
+g_param_spec_object
+</SECTION>
+
+<SECTION>
+<TITLE>Varargs Value Collection</TITLE>
+<FILE>value_collection</FILE>
+GTypeCValue
+G_VALUE_COLLECT
+G_VALUE_LCOPY
+</SECTION>
+
+Tue Sep 5 20:03:25 2000 Owen Taylor <otaylor@redhat.com>
+
+ * Moved into glib source tree, updated glib-sections.txt
+ and Makefile.am for glib-1.3.x.
+
2000-07-01 Damon Chaplin <damon@helixcode.com>
* tmpl/string_utils.sgml: updated g_strndup.
# The top-level SGML file.
DOC_MAIN_SGML_FILE=glib-docs.sgml
+# The directory containing the source code (if it contains documentation).
+DOC_SOURCE_DIR=$(top_srcdir)
TARGET_DIR=$(HTML_DIR)/$(DOC_MODULE)
+tmpl_sources = \
+ tmpl/allocators.sgml \
+ tmpl/arrays.sgml \
+ tmpl/arrays_byte.sgml \
+ tmpl/arrays_pointer.sgml \
+ tmpl/byte_order.sgml \
+ tmpl/caches.sgml \
+ tmpl/completion.sgml \
+ tmpl/datalist.sgml \
+ tmpl/datasets.sgml \
+ tmpl/date.sgml \
+ tmpl/glib-unused.sgml \
+ tmpl/hash_tables.sgml \
+ tmpl/hooks.sgml \
+ tmpl/iochannels.sgml \
+ tmpl/limits.sgml \
+ tmpl/linked_lists_double.sgml \
+ tmpl/linked_lists_single.sgml \
+ tmpl/macros.sgml \
+ tmpl/macros_misc.sgml \
+ tmpl/main.sgml \
+ tmpl/memory.sgml \
+ tmpl/memory_chunks.sgml \
+ tmpl/messages.sgml \
+ tmpl/misc_utils.sgml \
+ tmpl/modules.sgml \
+ tmpl/quarks.sgml \
+ tmpl/relations.sgml \
+ tmpl/scanner.sgml \
+ tmpl/string_chunks.sgml \
+ tmpl/string_utils.sgml \
+ tmpl/strings.sgml \
+ tmpl/threads.sgml \
+ tmpl/timers.sgml \
+ tmpl/trees-binary.sgml \
+ tmpl/trees-nary.sgml \
+ tmpl/type_conversion.sgml \
+ tmpl/types.sgml \
+ tmpl/warnings.sgml \
+ tmpl/windows.sgml
+
+glib_docdir = $(HTML_DIR)
+glib_doc_DATA = \
+ glib-decl.txt \
+ glib-sections.txt \
+ glib-overrides.txt
+
+EXTRA_DIST = \
+ $(glib_doc_DATA)
+
+html/book1.html: sgml/glib-doc.bottom
+ $(MAKE) html
+
+sgml/glib-doc.bottom: $(tmpl_sources)
+ $(MAKE) sgml
+
scan:
- gtkdoc-scan --module=$(DOC_MODULE) `glib-config --prefix`/include/glib.h `glib-config --prefix`/include/gmodule.h `glib-config --prefix`/lib/glib/include/glibconfig.h
+ -(cd $(srcdir) \
+ && gtkdoc-scan --module=$(DOC_MODULE) --source-dir=$(DOC_SOURCE_DIR) --ignore-headers="config.h gmoduleconf.h gunidecomp.h gunichartables.h glibconfig-sysdefs.h" )
templates: scan
- gtkdoc-mktmpl --module=$(DOC_MODULE)
+ cd $(srcdir) && gtkdoc-mktmpl --module=$(DOC_MODULE)
sgml:
- gtkdoc-mkdb --module=$(DOC_MODULE)
+ cd $(srcdir) \
+ && gtkdoc-mkdb --module=$(DOC_MODULE) --source-dir=$(DOC_SOURCE_DIR)
html:
- if ! test -d html ; then mkdir html ; fi
- -cd html && gtkdoc-mkhtml $(DOC_MODULE) ../$(DOC_MAIN_SGML_FILE)
+ test -d $(srcdir)/html || mkdir $(srcdir)/html
+ -cd $(srcdir)/html && gtkdoc-mkhtml $(DOC_MODULE) ../$(DOC_MAIN_SGML_FILE)
clean-local:
- rm -f *~ *.bak *.hierarchy *.signals *.args *-unused.txt
+ rm -f *~ *.bak *.signals *-unused.txt
maintainer-clean-local: clean
- rm -rf sgml html $(DOC_MODULE)-decl-list.txt $(DOC_MODULE)-decl.txt
+ cd $(srcdir) && rm -rf sgml html $(DOC_MODULE)-decl-list.txt $(DOC_MODULE)-decl.txt
install-data-local:
- install -d -m 0755 $(TARGET_DIR)
- install -m 0644 html/*.html $(TARGET_DIR)
- install -m 0644 html/index.sgml $(TARGET_DIR)
- gtkdoc-fixxref --module=$(DOC_MODULE) --html-dir=$(HTML_DIR)
-
-EXTRA_DIST = \
- $(DOC_MAIN_SGML_FILE) \
- $(DOC_MODULE)-sections.txt \
- glib-decl.txt \
- glib-overrides.txt
+ $(mkinstalldirs) $(DESTDIR)$(TARGET_DIR)
+ (installfiles=`echo $(srcdir)/html/*.html`; \
+ if test "$$installfiles" = '$(srcdir)/html/*.html'; \
+ then echo '-- Nothing to install' ; \
+ else \
+ for i in $$installfiles; do \
+ echo '-- Installing '$$i ; \
+ $(INSTALL_DATA) $$i $(DESTDIR)$(TARGET_DIR); \
+ done; \
+ echo '-- Installing $(srcdir)/html/index.sgml' ; \
+ $(INSTALL_DATA) $(srcdir)/html/index.sgml $(DESTDIR)$(TARGET_DIR); \
+ echo '-- Fixing Crossreferences' ; \
+ gtkdoc-fixxref --module=$(DOC_MODULE) --html-dir=$(HTML_DIR)|| true; \
+ fi)
dist-hook:
+ mkdir $(distdir)/html
+ mkdir $(distdir)/sgml
mkdir $(distdir)/tmpl
- cp -p tmpl/*.sgml $(distdir)/tmpl
+ -cp $(srcdir)/html/*.html $(srcdir)/html/*.css $(distdir)/html
+ -cp $(srcdir)/tmpl/*.sgml $(distdir)/tmpl
+ -cp $(srcdir)/sgml/*.sgml $(distdir)/sgml
+ -cp $(srcdir)/sgml/*.bottom $(srcdir)/sgml/*.top $(distdir)/sgml
.PHONY : html sgml templates scan
Memory Allocators
<!-- ##### SECTION Short_Description ##### -->
-allocates chunks of memory for #GList, #GSList and #GNode.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-The #GAllocator is used as an efficient way to allocate small pieces of
-memory for use with the #GList, #GSList and #GNode data structures.
-It uses a #GMemChunk so elements are allocated in groups, rather than
-individually.
-</para>
-<para>
-The #GList, #GSList and #GNode implementations create default #GAllocator
-objects, which are probably sufficient for most purposes. These default
-allocators use blocks of 128 elements.
-</para>
-<para>
-To use your own #GAllocator, create it with g_allocator_new(). Then
-use g_list_push_allocator(), g_slist_push_allocator() or
-g_node_push_allocator() before any code which allocates new #GList, #GSList
-or #GNode elements respectively. After allocating the new elements, you must
-use g_list_pop_allocator(), g_slist_pop_allocator() or g_node_pop_allocator()
-to restore the previous allocators.
-</para>
-<para>
-Note that you cannot use the same allocator for #GList, #GSList and #GNode
-elements. Each must use separate allocators.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GAllocator ##### -->
<para>
-The #GAllocator struct contains private data. and should only be accessed
-using the following functions.
+
</para>
<!-- ##### FUNCTION g_allocator_new ##### -->
<para>
-Creates a new #GAllocator.
+
</para>
-@name: the name of the #GAllocator. This name is used to set the name of the
-#GMemChunk used by the #GAllocator, and is only used for debugging.
-@n_preallocs: the number of elements in each block of memory allocated.
-Larger blocks mean less calls to g_malloc(), but some memory may be wasted.
-(GLib uses 128 elements per block by default.) The value must be between 1
-and 65535.
-@Returns: a new #GAllocator.
+@name:
+@n_preallocs:
+@Returns:
<!-- ##### FUNCTION g_allocator_free ##### -->
<para>
-Frees all of the memory allocated by the #GAllocator.
+
</para>
-@allocator: a #GAllocator.
+@allocator:
Arrays
<!-- ##### SECTION Short_Description ##### -->
-arrays of arbitrary elements which grow automatically as elements are added.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-Arrays are similar to standard C arrays, except that they grow automatically
-as elements are added.
-</para>
-<para>
-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.
-</para>
-<para>
-To create a new array use g_array_new().
-</para>
-<para>
-To add elements to an array, use g_array_append_val(), g_array_append_vals(),
-g_array_prepend_val(), and g_array_prepend_vals().
-</para>
-<para>
-To access an element of an array, use g_array_index().
-</para>
-<para>
-To set the size of an array, use g_array_set_size().
-</para>
-<para>
-To free an array, use g_array_free().
-</para>
-<example>
-<title>Using a GArray to store gint values.</title>
-<programlisting>
- GArray *garray;
- gint i;
- /* We create a new array to store gint values.
- We don't want it zero-terminated or cleared to 0's. */
- garray = g_array_new (FALSE, FALSE, sizeof (gint));
- for (i = 0; i < 10000; i++)
- g_array_append_val (garray, i);
-
- for (i = 0; i < 10000; i++)
- if (g_array_index (garray, gint, i) != i)
- g_print ("ERROR: got %d instead of %d\n",
- g_array_index (garray, gint, i), i);
+</para>
- g_array_free (garray, TRUE);
-</programlisting></example>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GArray ##### -->
<para>
-Contains the public fields of an <link linkend="glib-arrays">Array</link>.
+
</para>
-@data: a pointer to the element data. The data may be moved as elements are
-added to the #GArray.
-@len: the number of elements in the #GArray.
+@data:
+@len:
<!-- ##### FUNCTION g_array_new ##### -->
<para>
-Creates a new #GArray.
+
</para>
-@zero_terminated: TRUE if the array should have an extra element at the end
-which is set to '0'.
-@clear: TRUE if #GArray elements should be automatically cleared to '0'
-when they are allocated.
-@element_size: the size of each element in bytes.
-@Returns: the new #GArray.
+@zero_terminated:
+@clear:
+@element_size:
+@Returns:
-<!-- ##### MACRO g_array_append_val ##### -->
+<!-- ##### FUNCTION g_array_sized_new ##### -->
<para>
-Adds the value on to the end of the array.
-The array will grow in size automatically if necessary.
+
</para>
-<note>
+
+@zero_terminated:
+@clear:
+@element_size:
+@reserved_size:
+@Returns:
+
+
+<!-- ##### MACRO g_array_append_val ##### -->
<para>
-g_array_append_val() is a macro which uses a reference to the value
-parameter @v. This means that you cannot use it with literal values
-such as "27". You must use variables.
+
</para>
-</note>
-@a: a #GArray.
-@v: the value to append to the #GArray.
-@Returns: the #GArray.
+@a:
+@v:
<!-- ##### FUNCTION g_array_append_vals ##### -->
<para>
-Adds @len elements onto the end of the array.
+
</para>
-@array: a #GArray.
-@data: a pointer to the elements to append to the end of the array.
-@len: the number of elements to append.
-@Returns: the #GArray.
+@array:
+@data:
+@len:
+@Returns:
<!-- ##### MACRO g_array_prepend_val ##### -->
<para>
-Adds the value on to the start of the array.
-The array will grow in size automatically if necessary.
-</para>
-<para>
-This operation is slower than g_array_append_val() since the existing elements
-in the array have to be moved to make space for the new element.
-</para>
-<note>
-<para>
-g_array_prepend_val() is a macro which uses a reference to the value
-parameter @v. This means that you cannot use it with literal values
-such as "27". You must use variables.
+
</para>
-</note>
-@a: a #GArray.
-@v: the value to prepend to the #GArray.
-@Returns: the #GArray.
+@a:
+@v:
<!-- ##### FUNCTION g_array_prepend_vals ##### -->
<para>
-Adds @len elements onto the start of the array.
-</para>
-<para>
-This operation is slower than g_array_append_vals() since the existing elements
-in the array have to be moved to make space for the new elements.
+
</para>
-@array: a #GArray.
-@data: a pointer to the elements to prepend to the start of the array.
-@len: the number of elements to prepend.
-@Returns: the #GArray.
+@array:
+@data:
+@len:
+@Returns:
<!-- ##### MACRO g_array_insert_val ##### -->
<para>
-Inserts an element into an array at the given index.
-</para>
-<note>
-<para>
-g_array_insert_val() is a macro which uses a reference to the value
-parameter @v. This means that you cannot use it with literal values
-such as "27". You must use variables.
+
</para>
-</note>
-@a: a #GArray.
-@i: the index to place the element at.
-@v: the value to insert into the array.
-@Returns: the #GArray.
+@a:
+@i:
+@v:
<!-- ##### FUNCTION g_array_insert_vals ##### -->
<para>
-Inserts @len elements into a #GArray at the given index.
+
</para>
-@array: a #GArray.
-@index: the index to place the elements at.
-@data: a pointer to the elements to insert.
-@len: the number of elements to insert.
-@Returns: the #GArray.
+@array:
+@index:
+@data:
+@len:
+@Returns:
<!-- ##### FUNCTION g_array_remove_index ##### -->
<para>
-Removes the element at the given index from a #GArray.
-The following elements are moved down one place.
+
</para>
-@array: a #GArray.
-@index: the index of the element to remove.
-@Returns: the #GArray.
+@array:
+@index:
+@Returns:
<!-- ##### FUNCTION g_array_remove_index_fast ##### -->
<para>
-Removes the element at the given index from a #GArray.
-The last element in the array is used to fill in the space, so this function
-does not preserve the order of the #GArray. But it is faster than
-g_array_remove_index().
+
</para>
-@array: a @GArray.
-@index: the index of the element to remove.
-@Returns: the #GArray.
+@array:
+@index:
+@Returns:
<!-- ##### MACRO g_array_index ##### -->
<para>
-Returns the element of a #GArray at the given index.
-The return value is cast to the given type.
-
-<example>
-<title>Getting a pointer to an element in a GArray.</title>
-<programlisting>
- EDayViewEvent *event;
- /* This gets a pointer to the 3rd element in the array of EDayViewEvent
- structs. */
- event = &g_array_index (events, EDayViewEvent, 3);
-</programlisting>
-</example>
</para>
-@a: a #GArray.
-@t: the type of the elements.
-@i: the index of the element to return.
-@Returns: the element of the #GArray at the index given by @i.
+@a:
+@t:
+@i:
<!-- ##### FUNCTION g_array_set_size ##### -->
<para>
-Sets the size of the array, expanding it if necessary.
-If the array was created with clear set to TRUE, the new elements are set to 0.
+
</para>
-@array: a #GArray.
-@length: the new size of the #GArray.
-@Returns: the #GArray.
+@array:
+@length:
+@Returns:
<!-- ##### FUNCTION g_array_free ##### -->
<para>
-Frees the memory allocated for the #GArray.
-If free_segment is TRUE it frees the actual element data as well.
+
</para>
-@array: a #GArray.
-@free_segment: if TRUE the actual element data is freed as well.
+@array:
+@free_segment:
+@Returns:
Byte Arrays
<!-- ##### SECTION Short_Description ##### -->
-arrays of bytes, which grow automatically as elements are added.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-GByteArray is based on #GArray, to provide arrays of bytes which grow
-automatically as elements are added.
-</para>
-<para>
-To create a new #GByteArray use g_byte_array_new().
-</para>
-<para>
-To add elements to a #GByteArray, use g_byte_array_append(), and
-g_byte_array_prepend().
-</para>
-<para>
-To set the size of a GByteArray, use g_byte_array_set_size().
-</para>
-<para>
-To free a GByteArray, use g_byte_array_free().
-</para>
-
-<example>
-<title>Using a GByteArray.</title>
-<programlisting>
- GByteArray *gbarray;
- gint i;
- gbarray = g_byte_array_new ();
- for (i = 0; i < 10000; i++)
- g_byte_array_append (gbarray, (guint8*) "abcd", 4);
-
- for (i = 0; i < 10000; i++)
- {
- g_assert (gbarray->data[4*i] == 'a');
- g_assert (gbarray->data[4*i+1] == 'b');
- g_assert (gbarray->data[4*i+2] == 'c');
- g_assert (gbarray->data[4*i+3] == 'd');
- }
+</para>
- g_byte_array_free (gbarray, TRUE);
-</programlisting></example>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GByteArray ##### -->
<para>
-The #GByteArray struct allows access to the public fields of a #GByteArray.
+
</para>
-@data: a pointer to the element data. The data may be moved as elements are
-added to the #GByteArray.
-@len: the number of elements in the #GByteArray.
+@data:
+@len:
<!-- ##### FUNCTION g_byte_array_new ##### -->
<para>
-Creates a new #GByteArray.
+
+</para>
+
+@Returns:
+
+
+<!-- ##### FUNCTION g_byte_array_sized_new ##### -->
+<para>
+
</para>
-@Returns: the new #GByteArray.
+@reserved_size:
+@Returns:
<!-- ##### FUNCTION g_byte_array_append ##### -->
<para>
-Adds the given bytes to the end of the #GByteArray.
-The array will grow in size automatically if necessary.
+
</para>
-@array: a #GByteArray.
-@data: the byte data to be added.
-@len: the number of bytes to add.
-@Returns: the #GByteArray.
+@array:
+@data:
+@len:
+@Returns:
<!-- ##### FUNCTION g_byte_array_prepend ##### -->
<para>
-Adds the given data to the start of the #GByteArray.
-The array will grow in size automatically if necessary.
+
</para>
-@array: a #GByteArray.
-@data: the byte data to be added.
-@len: the number of bytes to add.
-@Returns: the #GByteArray.
+@array:
+@data:
+@len:
+@Returns:
<!-- ##### FUNCTION g_byte_array_remove_index ##### -->
<para>
-Removes the byte at the given index from a #GByteArray.
-The following bytes are moved down one place.
+
</para>
-@array: a #GByteArray.
-@index: the index of the byte to remove.
-@Returns: the #GByteArray.
+@array:
+@index:
+@Returns:
<!-- ##### FUNCTION g_byte_array_remove_index_fast ##### -->
<para>
-Removes the byte at the given index from a #GByteArray.
-The last element in the array is used to fill in the space, so this function
-does not preserve the order of the #GByteArray. But it is faster than
-g_byte_array_remove_index().
+
</para>
-@array: a #GByteArray.
-@index: the index of the byte to remove.
-@Returns: the #GByteArray.
+@array:
+@index:
+@Returns:
<!-- ##### FUNCTION g_byte_array_set_size ##### -->
<para>
-Sets the size of the #GByteArray, expanding it if necessary.
+
</para>
-@array: a #GByteArray.
-@length: the new size of the #GByteArray.
-@Returns: the #GByteArray.
+@array:
+@length:
+@Returns:
<!-- ##### FUNCTION g_byte_array_free ##### -->
<para>
-Frees the memory allocated by the #GByteArray.
-If free_segment is TRUE it frees the actual byte data.
+
</para>
-@array: a #GByteArray.
-@free_segment: if TRUE the actual byte data is freed as well.
+@array:
+@free_segment:
+@Returns:
Pointer Arrays
<!-- ##### SECTION Short_Description ##### -->
-arrays of pointers to any type of data, which grow automatically as new
-elements are added.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-Pointer Arrays are similar to Arrays but are used only for storing pointers.
-</para>
-<note>
-<para>
-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.
-</para>
-</note>
-<para>
-To create a pointer array, use g_ptr_array_new().
-</para>
-<para>
-To add elements to a pointer array, use g_ptr_array_add().
-</para>
-<para>
-To remove elements from a pointer array, use g_ptr_array_remove(),
-g_ptr_array_remove_index() or g_ptr_array_remove_index_fast().
-</para>
-<para>
-To access an element of a pointer array, use g_ptr_array_index().
-</para>
-<para>
-To set the size of a pointer array, use g_ptr_array_set_size().
-</para>
-<para>
-To free a pointer array, use g_ptr_array_free().
-</para>
-<example>
-<title>Using a GPtrArray.</title>
-<programlisting>
- GPtrArray *gparray;
- gchar *string1 = "one", *string2 = "two", *string3 = "three";
-
- gparray = g_ptr_array_new ();
- 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 ("ERROR: got %p instead of %p\n",
- g_ptr_array_index (gparray, 0), string1);
+</para>
- g_ptr_array_free (gparray, TRUE);
-</programlisting></example>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GPtrArray ##### -->
<para>
-Contains the public fields of a pointer array.
-The <structfield>pdata</structfield> field points to the array of pointers,
-which may as when the array grows.
-The <structfield>len</structfield> field is the number of pointers in the
-array.
+
</para>
@pdata:
<!-- ##### FUNCTION g_ptr_array_new ##### -->
<para>
-Creates a new #GPtrArray.
+
</para>
-@Returns: the new #GPtrArray.
+@Returns:
-<!-- ##### FUNCTION g_ptr_array_add ##### -->
+<!-- ##### FUNCTION g_ptr_array_sized_new ##### -->
<para>
-Adds a pointer to the end of the pointer array.
-The array will grow in size automatically if necessary.
+
</para>
-@array: a #GPtrArray.
-@data: the pointer to add.
+@reserved_size:
+@Returns:
-<!-- ##### FUNCTION g_ptr_array_remove ##### -->
+<!-- ##### FUNCTION g_ptr_array_add ##### -->
<para>
-Removes the first occurrence of the given pointer from the pointer array.
-The following elements are moved down one place.
+
</para>
+
+@array:
+@data:
+
+
+<!-- ##### FUNCTION g_ptr_array_remove ##### -->
<para>
-It returns TRUE if the pointer was removed, or FALSE if the pointer
-was not found.
+
</para>
-@array: a #GPtrArray.
-@data: the pointer to remove.
-@Returns: TRUE if the pointer is removed. FALSE if the pointer is not found
-in the array.
+@array:
+@data:
+@Returns:
<!-- ##### FUNCTION g_ptr_array_remove_index ##### -->
<para>
-Removes the pointer at the given index from the pointer array.
-The following elements are moved down one place.
+
</para>
-@array: a #GPtrArray.
-@index: the index of the pointer to remove.
-@Returns: the pointer which was removed.
+@array:
+@index:
+@Returns:
<!-- ##### FUNCTION g_ptr_array_remove_fast ##### -->
<para>
-Removes the first occurrence of the given pointer from the pointer array.
-The last element in the array is used to fill in the space, so this function
-does not preserve the order of the array. But it is faster than
-g_ptr_array_remove().
-</para>
-<para>
-It returns TRUE if the pointer was removed, or FALSE if the pointer
-was not found.
+
</para>
-@array: a #GPtrArray.
-@data: the pointer to remove.
-@Returns: TRUE if the pointer was found in the array.
+@array:
+@data:
+@Returns:
<!-- ##### FUNCTION g_ptr_array_remove_index_fast ##### -->
<para>
-Removes the pointer at the given index from the pointer array.
-The last element in the array is used to fill in the space, so this function
-does not preserve the order of the array. But it is faster than
-g_ptr_array_remove_index().
+
</para>
-@array: a #GPtrArray.
-@index: the index of the pointer to remove.
-@Returns: the pointer which was removed.
+@array:
+@index:
+@Returns:
<!-- ##### FUNCTION g_ptr_array_set_size ##### -->
<para>
-Sets the size of the array, expanding it if necessary.
-New elements are set to NULL.
+
</para>
-@array: a #GPtrArray.
-@length: the new length of the pointer array.
+@array:
+@length:
<!-- ##### MACRO g_ptr_array_index ##### -->
<para>
-Returns the pointer at the given index of the pointer array.
+
</para>
-@array: a #GPtrArray.
-@index: the index of the pointer to return.
-@Returns: the pointer at the given index.
+@array:
+@index:
<!-- ##### FUNCTION g_ptr_array_free ##### -->
<para>
-Frees all of the memory allocated for the pointer array.
+
</para>
-@array: a #GPtrArray.
-@free_seg: if TRUE the actual element data is freed as well.
+@array:
+@free_seg:
+@Returns:
Byte Order Macros
<!-- ##### SECTION Short_Description ##### -->
-a portable way to convert between different byte orders.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These macros provide a portable way to determine the host byte order
-and to convert values between different byte orders.
-</para>
-<para>
-The byte order is the order in which bytes are stored to create larger
-data types such as the #gint and #glong values.
-The host byte order is the byte order used on the current machine.
-</para>
-<para>
-Some processors store the most significant bytes (i.e. the bytes that
-hold the largest part of the value) first. These are known as big-endian
-processors.
-</para>
-<para>
-Other processors (notably the x86 family) store the most significant byte
-last. These are known as little-endian processors.
-</para>
-<para>
-Finally, to complicate matters, some other processors store the bytes in
-a rather curious order known as PDP-endian. For a 4-byte word, the 3rd
-most significant byte is stored first, then the 4th, then the 1st and finally
-the 2nd.
-</para>
-<para>
-Obviously there is a problem when these different processors communicate
-with each other, for example over networks or by using binary file formats.
-This is where these macros come in.
-They are typically used to convert values into a byte order
-which has been agreed on for use when communicating between different
-processors. The Internet uses what is known as 'network byte order'
-as the standard byte order (which is in fact the big-endian byte order).
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### MACRO G_BYTE_ORDER ##### -->
<para>
-The host byte order.
-This can be either #G_LITTLE_ENDIAN or #G_BIG_ENDIAN (support for
-#G_PDP_ENDIAN may be added in future.)
+
</para>
<!-- ##### MACRO G_LITTLE_ENDIAN ##### -->
<para>
-Specifies one of the possible types of byte order.
-See #G_BYTE_ORDER.
+
</para>
<!-- ##### MACRO G_BIG_ENDIAN ##### -->
<para>
-Specifies one of the possible types of byte order.
-See #G_BYTE_ORDER.
+
</para>
<!-- ##### MACRO G_PDP_ENDIAN ##### -->
<para>
-Specifies one of the possible types of byte order (currently unused).
-See #G_BYTE_ORDER.
+
</para>
<!-- ##### MACRO g_htonl ##### -->
<para>
-Converts a 32-bit integer value from host to network byte order.
+
</para>
-@val: a 32-bit integer value in host byte order.
-@Returns: @val converted to network byte order.
+@val:
<!-- ##### MACRO g_htons ##### -->
<para>
-Converts a 16-bit integer value from host to network byte order.
+
</para>
-@val: a 16-bit integer value in host byte order.
-@Returns: @val converted to network byte order.
+@val:
<!-- ##### MACRO g_ntohl ##### -->
<para>
-Converts a 32-bit integer value from network to host byte order.
+
</para>
-@val: a 32-bit integer value in network byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO g_ntohs ##### -->
<para>
-Converts a 16-bit integer value from network to host byte order.
+
</para>
-@val: a 16-bit integer value in network byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GINT_FROM_BE ##### -->
<para>
-Converts a #gint value from big-endian to host byte order.
+
</para>
-@val: a #gint value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GINT_FROM_LE ##### -->
<para>
-Converts a #gint value from little-endian to host byte order.
+
</para>
-@val: a #gint value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GINT_TO_BE ##### -->
<para>
-Converts a #gint value from host byte order to big-endian.
+
</para>
-@val: a #gint value in host byte order.
-@Returns: @val converted to big-endian byte order.
+@val:
<!-- ##### MACRO GINT_TO_LE ##### -->
<para>
-Converts a #gint value from host byte order to little-endian.
+
</para>
-@val: a #gint value in host byte order.
-@Returns: @val converted to little-endian byte order.
+@val:
<!-- ##### MACRO GUINT_FROM_BE ##### -->
<para>
-Converts a #guint value from big-endian to host byte order.
+
</para>
-@val: a #guint value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GUINT_FROM_LE ##### -->
<para>
-Converts a #guint value from little-endian to host byte order.
+
</para>
-@val: a #guint value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GUINT_TO_BE ##### -->
<para>
-Converts a #guint value from host byte order to big-endian.
+
</para>
-@val: a #guint value in host byte order.
-@Returns: @val converted to big-endian byte order.
+@val:
<!-- ##### MACRO GUINT_TO_LE ##### -->
<para>
-Converts a #guint value from host byte order to little-endian.
+
</para>
-@val: a #guint value in host byte order.
-@Returns: @val converted to little-endian byte order.
+@val:
<!-- ##### MACRO GLONG_FROM_BE ##### -->
<para>
-Converts a #glong value from big-endian to the host byte order.
+
</para>
-@val: a #glong value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GLONG_FROM_LE ##### -->
<para>
-Converts a #glong value from little-endian to host byte order.
+
</para>
-@val: a #glong value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GLONG_TO_BE ##### -->
<para>
-Converts a #glong value from host byte order to big-endian.
+
</para>
-@val: a #glong value in host byte order.
-@Returns: @val converted to big-endian byte order.
+@val:
<!-- ##### MACRO GLONG_TO_LE ##### -->
<para>
-Converts a #glong value from host byte order to little-endian.
+
</para>
-@val: a #glong value in host byte order.
-@Returns: @val converted to little-endian.
+@val:
<!-- ##### MACRO GULONG_FROM_BE ##### -->
<para>
-Converts a #gulong value from big-endian to host byte order.
+
</para>
-@val: a #gulong value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GULONG_FROM_LE ##### -->
<para>
-Converts a #gulong value from little-endian to host byte order.
+
</para>
-@val: a #gulong value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GULONG_TO_BE ##### -->
<para>
-Converts a #gulong value from host byte order to big-endian.
+
</para>
-@val: a #gulong value in host byte order.
-@Returns: @val converted to big-endian.
+@val:
<!-- ##### MACRO GULONG_TO_LE ##### -->
<para>
-Converts a #gulong value from host byte order to little-endian.
+
</para>
-@val: a #gulong value in host byte order.
-@Returns: @val converted to little-endian.
+@val:
<!-- ##### MACRO GINT16_FROM_BE ##### -->
<para>
-Converts a #gint16 value from big-endian to host byte order.
+
</para>
-@val: a #gint16 value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GINT16_FROM_LE ##### -->
<para>
-Converts a #gint16 value from little-endian to host byte order.
+
</para>
-@val: a #gint16 value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GINT16_TO_BE ##### -->
<para>
-Converts a #gint16 value from host byte order to big-endian.
+
</para>
-@val: a #gint16 value in host byte order.
-@Returns: @val converted to big-endian.
+@val:
<!-- ##### MACRO GINT16_TO_LE ##### -->
<para>
-Converts a #gint16 value from host byte order to little-endian.
+
</para>
-@val: a #gint16 value in host byte order.
-@Returns: @val converted to little-endian.
+@val:
<!-- ##### MACRO GUINT16_FROM_BE ##### -->
<para>
-Converts a #guint16 value from big-endian to host byte order.
+
</para>
-@val: a #guint16 value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GUINT16_FROM_LE ##### -->
<para>
-Converts a #guint16 value from little-endian to host byte order.
+
</para>
-@val: a #guint16 value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GUINT16_TO_BE ##### -->
<para>
-Converts a #guint16 value from host byte order to big-endian.
+
</para>
-@val: a #guint16 value in host byte order.
-@Returns: @val converted to big-endian.
+@val:
<!-- ##### MACRO GUINT16_TO_LE ##### -->
<para>
-Converts a #guint16 value from host byte order to little-endian.
+
</para>
-@val: a #guint16 value in host byte order.
-@Returns: @val converted to little-endian.
+@val:
<!-- ##### MACRO GINT32_FROM_BE ##### -->
<para>
-Converts a #gint32 value from big-endian to host byte order.
+
</para>
-@val: a #gint32 value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GINT32_FROM_LE ##### -->
<para>
-Converts a #gint32 value from little-endian to host byte order.
+
</para>
-@val: a #gint32 value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GINT32_TO_BE ##### -->
<para>
-Converts a #gint32 value from host byte order to big-endian.
+
</para>
-@val: a #gint32 value in host byte order.
-@Returns: @val converted to big-endian.
+@val:
<!-- ##### MACRO GINT32_TO_LE ##### -->
<para>
-Converts a #gint32 value from host byte order to little-endian.
+
</para>
-@val: a #gint32 value in host byte order.
-@Returns: @val converted to little-endian.
+@val:
<!-- ##### MACRO GUINT32_FROM_BE ##### -->
<para>
-Converts a #guint32 value from big-endian to host byte order.
+
</para>
-@val: a #guint32 value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GUINT32_FROM_LE ##### -->
<para>
-Converts a #guint32 value from little-endian to host byte order.
+
</para>
-@val: a #guint32 value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GUINT32_TO_BE ##### -->
<para>
-Converts a #guint32 value from host byte order to big-endian.
+
</para>
-@val: a #guint32 value in host byte order.
-@Returns: @val converted to big-endian.
+@val:
<!-- ##### MACRO GUINT32_TO_LE ##### -->
<para>
-Converts a #guint32 value from host byte order to little-endian.
+
</para>
-@val: a #guint32 value in host byte order.
-@Returns: @val converted to little-endian.
+@val:
<!-- ##### MACRO GINT64_FROM_BE ##### -->
<para>
-Converts a #gint64 value from big-endian to host byte order.
+
</para>
-@val: a #gint64 value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GINT64_FROM_LE ##### -->
<para>
-Converts a #gint64 value from little-endian to host byte order.
+
</para>
-@val: a #gint64 value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GINT64_TO_BE ##### -->
<para>
-Converts a #gint64 value from host byte order to big-endian.
+
</para>
-@val: a #gint64 value in host byte order.
-@Returns: @val converted to big-endian.
+@val:
<!-- ##### MACRO GINT64_TO_LE ##### -->
<para>
-Converts a #gint64 value from host byte order to little-endian.
+
</para>
-@val: a #gint64 value in host byte order.
-@Returns: @val converted to little-endian.
+@val:
<!-- ##### MACRO GUINT64_FROM_BE ##### -->
<para>
-Converts a #guint64 value from big-endian to host byte order.
+
</para>
-@val: a #guint64 value in big-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GUINT64_FROM_LE ##### -->
<para>
-Converts a #guint64 value from little-endian to host byte order.
+
</para>
-@val: a #guint64 value in little-endian byte order.
-@Returns: @val converted to host byte order.
+@val:
<!-- ##### MACRO GUINT64_TO_BE ##### -->
<para>
-Converts a #guint64 value from host byte order to big-endian.
+
</para>
-@val: a #guint64 value in host byte order.
-@Returns: @val converted to big-endian.
+@val:
<!-- ##### MACRO GUINT64_TO_LE ##### -->
<para>
-Converts a #guint64 value from host byte order to little-endian.
+
</para>
-@val: a #guint64 value in host byte order.
-@Returns: @val converted to little-endian.
+@val:
<!-- ##### MACRO GUINT16_SWAP_BE_PDP ##### -->
<para>
-Converts a #guint16 value between big-endian and pdp-endian byte order.
-The conversion is symmetric so it can be used both ways.
+
</para>
-@val: a #guint16 value in big-endian or pdp-endian byte order.
-@Returns: @val converted to the opposite byte order.
+@val:
<!-- ##### MACRO GUINT16_SWAP_LE_BE ##### -->
<para>
-Converts a #guint16 value between little-endian and big-endian byte order.
-The conversion is symmetric so it can be used both ways.
+
</para>
-@val: a #guint16 value in little-endian or big-endian byte order.
-@Returns: @val converted to the opposite byte order.
+@val:
<!-- ##### MACRO GUINT16_SWAP_LE_PDP ##### -->
<para>
-Converts a #guint16 value between little-endian and pdp-endian byte order.
-The conversion is symmetric so it can be used both ways.
+
</para>
-@val: a #guint16 value in little-endian or pdp-endian byte order.
-@Returns: @val converted to the opposite byte order.
+@val:
<!-- ##### MACRO GUINT32_SWAP_BE_PDP ##### -->
<para>
-Converts a #guint32 value between big-endian and pdp-endian byte order.
-The conversion is symmetric so it can be used both ways.
+
</para>
-@val: a #guint32 value in big-endian or pdp-endian byte order.
-@Returns: @val converted to the opposite byte order.
+@val:
<!-- ##### MACRO GUINT32_SWAP_LE_BE ##### -->
<para>
-Converts a #guint32 value between little-endian and big-endian byte order.
-The conversion is symmetric so it can be used both ways.
+
</para>
-@val: a #guint32 value in little-endian or big-endian byte order.
-@Returns: @val converted to the opposite byte order.
+@val:
<!-- ##### MACRO GUINT32_SWAP_LE_PDP ##### -->
<para>
-Converts a #guint32 value between little-endian and pdp-endian byte order.
-The conversion is symmetric so it can be used both ways.
+
</para>
-@val: a #guint32 value in little-endian or pdp-endian byte order.
-@Returns: @val converted to the opposite byte order.
+@val:
<!-- ##### MACRO GUINT64_SWAP_LE_BE ##### -->
<para>
-Converts a #guint64 value between little-endian and big-endian byte order.
-The conversion is symmetric so it can be used both ways.
+
</para>
-@val: a #guint64 value in little-endian or big-endian byte order.
-@Returns: @val converted to the opposite byte order.
+@val:
Caches
<!-- ##### SECTION Short_Description ##### -->
-allows sharing of complex data structures to save resources.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-A #GCache allows sharing of complex data structures, in order to save
-system resources.
-</para>
-<para>
-GTK uses a #GCache for both GtkStyles and GdkGCs. These consume a lot of
-resouces, so a #GCache is used to see if a GtkStyle or GdkGC with the
-required properties already exists. If it does, then the existing
-GtkStyle or GdkGC is used instead of creating a new one.
-</para>
-<para>
-#GCache uses keys and values.
-A #GCache key describes the properties of a particular resource.
-A #GCache value is the actual resource.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GCache ##### -->
<para>
-The #GCache struct is an opaque data structure containing information about
-a #GCache. It should only be accesssed via the following functions.
+
</para>
<!-- ##### FUNCTION g_cache_new ##### -->
<para>
-Creates a new GCache.
+
</para>
-@value_new_func: 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.
-@value_destroy_func: 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).
-@key_dup_func: a function to copy a key. It is called by
-g_cache_insert() if the key does not already exist in the GCache.
-@key_destroy_func: 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).
-@hash_key_func: a function to create a hash value from a key.
-@hash_value_func: a function to create a hash value from a value.
-@key_compare_func: a function to compare two keys. It should return TRUE if
-the two keys are equivalent.
-@Returns: a new #GCache.
+@value_new_func:
+@value_destroy_func:
+@key_dup_func:
+@key_destroy_func:
+@hash_key_func:
+@hash_value_func:
+@key_compare_func:
+@Returns:
<!-- ##### FUNCTION g_cache_insert ##### -->
<para>
-Gets the value corresponding to the given key, creating it if necessary.
-It first checks if the value already exists in the #GCache, by using
-the @key_compare_func function passed to g_cache_new().
-If it does already exist it is returned, and its reference count is increased
-by one.
-If the value does not currently exist, if is created by calling the
-@value_new_func. The key is duplicated by calling
-@key_dup_func and the duplicated key and value are inserted
-into the #GCache.
+
</para>
-@cache: a #GCache.
-@key: a key describing a #GCache object.
-@Returns: a pointer to a #GCache value.
+@cache:
+@key:
+@Returns:
<!-- ##### FUNCTION g_cache_remove ##### -->
<para>
-Decreases the reference count of the given value.
-If it drops to 0 then the value and its corresponding key are destroyed,
-using the @value_destroy_func and @key_destroy_func passed to g_cache_new().
+
</para>
-@cache: a #GCache.
-@value: the value to remove.
+@cache:
+@value:
<!-- ##### FUNCTION g_cache_destroy ##### -->
<para>
-Frees the memory allocated for the GCache.
-</para>
-<para>
-Note that it does not destroy the keys and values which were contained in the
-GCache.
+
</para>
@cache:
<!-- ##### FUNCTION g_cache_key_foreach ##### -->
<para>
-Calls the given function for each of the keys in the #GCache.
+
</para>
-@cache: a #GCache.
-@func: the function to call with each #GCache key.
-@user_data: user data to pass to the function.
+@cache:
+@func:
+@user_data:
<!-- ##### FUNCTION g_cache_value_foreach ##### -->
<para>
-Calls the given function for each of the values in the #GCache.
+
</para>
-@cache: a #GCache.
-@func: the function to call with each #GCache value.
-@user_data: user data to pass to the function.
+@cache:
+@func:
+@user_data:
<!-- ##### USER_FUNCTION GCacheDestroyFunc ##### -->
<para>
-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.
+
</para>
-@value: the #GCache value to destroy.
+@value:
<!-- ##### USER_FUNCTION GCacheDupFunc ##### -->
<para>
-Specifies the type of the @key_dup_func function passed to g_cache_new().
-The function is passed a key (NOT a value as the prototype implies) and
-should return a duplicate of the key.
+
</para>
-@value: the #GCache key to destroy (NOT a #GCache value as it seems).
-@Returns: a copy of the #GCache key.
+@value:
+@Returns:
<!-- ##### USER_FUNCTION GCacheNewFunc ##### -->
<para>
-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.
+
</para>
-@key: a #GCache key.
-@Returns: a new #GCache value corresponding to the key.
+@key:
+@Returns:
Automatic String Completion
<!-- ##### SECTION Short_Description ##### -->
-support for automatic completion using a group of target strings.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-#GCompletion provides support for automatic completion of a string using
-any group of target strings. It is typically used for file name completion
-as is common in many Unix shells.
-</para>
-<para>
-A #GCompletion is created using g_completion_new().
-Target items are added and removed with
-g_completion_add_items(), g_completion_remove_items() and
-g_completion_clear_items().
-A completion attempt is requested with g_completion_complete().
-When no longer needed, the #GCompletion is freed with g_completion_free().
-</para>
-<para>
-Items in the completion can be simple strings (e.g. file names),
-or pointers to arbitrary data structures. If data structures are used
-you must provide a #GCompletionFunc in g_completion_new(),
-which retrieves the item's string from the data structure.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GCompletion ##### -->
<para>
-The data structure used for automatic completion.
-<structfield>items</structfield> is the list of target items (strings
-or data structures).
-<structfield>func</structfield> is the function called to get the string
-associated with a target item. It is NULL if the target items are strings.
-<structfield>prefix</structfield> is the last prefix passed to
-g_completion_complete().
-<structfield>cache</structfield> is the list of items which begin with
-<structfield>prefix</structfield>.
+
</para>
@items:
<!-- ##### FUNCTION g_completion_new ##### -->
<para>
-Creates a new #GCompletion.
+
</para>
-@func: the function to be called to return the string representing an item
-in the #GCompletion, or NULL if strings are going to be used as the
-#GCompletion items.
-@Returns: the new #GCompletion.
+@func:
+@Returns:
<!-- ##### USER_FUNCTION GCompletionFunc ##### -->
<para>
-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.
+
</para>
-@Param1: the completion item.
-@Returns: the string corresponding to the item.
+@Param1:
+@Returns:
<!-- ##### FUNCTION g_completion_add_items ##### -->
<para>
-Adds items to the #GCompletion.
+
</para>
-@cmp: the #GCompletion.
-@items: the list of items to add.
+@cmp:
+@items:
<!-- ##### FUNCTION g_completion_remove_items ##### -->
<para>
-Removes items from a #GCompletion.
+
</para>
-@cmp: the #GCompletion.
-@items: the items to remove.
+@cmp:
+@items:
<!-- ##### FUNCTION g_completion_clear_items ##### -->
<para>
-Removes all items from the #GCompletion.
+
</para>
-@cmp: the #GCompletion.
+@cmp:
<!-- ##### FUNCTION g_completion_complete ##### -->
<para>
-Attempts to complete the string @prefix using the #GCompletion target items.
+
</para>
-@cmp: the #GCompletion.
-@prefix: the prefix string, typically typed by the user, which is compared
-with each of the items.
-@new_prefix: if non-NULL, returns the longest prefix which is common to all
-items that matched @prefix, or NULL if no items matched @prefix.
-This string should be freed when no longer needed.
-@Returns: the list of items whose strings begin with @prefix. This should
-not be changed.
+@cmp:
+@prefix:
+@new_prefix:
+@Returns:
<!-- ##### FUNCTION g_completion_free ##### -->
<para>
-Frees all memory used by the #GCompletion.
+
</para>
-@cmp: the #GCompletion.
+@cmp:
Keyed Data Lists
<!-- ##### SECTION Short_Description ##### -->
-lists of data elements which are accessible by a string or #GQuark identifier.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-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.
-</para>
-<para>
-The GQuark methods are quicker, since the strings have to be converted to
-GQuarks anyway.
-</para>
-<para>
-Data lists are used in GTK for associating arbitrary data with
-GtkObjects, using gtk_object_set_data() and related functions.
-</para>
-<para>
-To create a datalist, use g_datalist_init().
-</para>
-<para>
-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().
-</para>
-<para>
-To get data elements from a datalist use g_datalist_id_get_data() and
-g_datalist_get_data().
-</para>
-<para>
-To iterate over all data elements in a datalist use g_datalist_foreach().
-</para>
-<para>
-To remove data elements from a datalist use g_datalist_id_remove_data() and
-g_datalist_remove_data().
-</para>
-<para>
-To remove all data elements from a datalist, use g_datalist_clear().
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GData ##### -->
<para>
-The #GData struct is an opaque data structure to represent a
-<link linkend="glib-Keyed-Data-Lists">Keyed Data List</link>.
-It should only be accessed via the following functions.
+
</para>
<!-- ##### FUNCTION g_datalist_init ##### -->
<para>
-Resets the datalist to NULL.
-It does not free any memory or call any destroy functions.
+
</para>
-@datalist: a pointer to a pointer to a datalist.
+@datalist:
<!-- ##### MACRO g_datalist_id_set_data ##### -->
<para>
-Sets the data corresponding to the given #GQuark id.
-Any previous data with the same key is removed, and its
-destroy function is called.
+
</para>
-@dl: a datalist.
-@q: the #GQuark to identify the data element.
-@d: the data element.
+@dl:
+@q:
+@d:
<!-- ##### FUNCTION g_datalist_id_set_data_full ##### -->
<para>
-Sets the data corresponding to the given #GQuark id, and the function to
-be called when the element is removed from the datalist.
-Any previous data with the same key is removed, and its
-destroy function is called.
+
</para>
-@datalist: a datalist.
-@key_id: the #GQuark to identify the data element.
-@data: the data element.
-@destroy_func: the function to call when the data element is removed. This
-function will be called with the data element and can be used to free any
-memory allocated for it.
+@datalist:
+@key_id:
+@data:
+@destroy_func:
<!-- ##### FUNCTION g_datalist_id_get_data ##### -->
<para>
-Gets a data element.
+
</para>
-@datalist: a datalist.
-@key_id: the #GQuark identifying a data element.
-@Returns: the data element, or NULL if it is not found.
+@datalist:
+@key_id:
+@Returns:
<!-- ##### MACRO g_datalist_id_remove_data ##### -->
<para>
-Removes an element, using its #GQuark identifier.
+
</para>
-@dl: a datalist.
-@q: the #GQuark identifying the data element.
+@dl:
+@q:
<!-- ##### FUNCTION g_datalist_id_remove_no_notify ##### -->
@datalist:
@key_id:
+@Returns:
<!-- ##### MACRO g_datalist_set_data ##### -->
<para>
-Sets the data element corresponding to the given string identifier.
+
</para>
-@dl: a datalist.
-@k: the string to identify the data element.
-@d: the data element.
+@dl:
+@k:
+@d:
<!-- ##### MACRO g_datalist_set_data_full ##### -->
<para>
-Sets the data element corresponding to the given string identifier, and the
-function to be called when the data element is removed.
+
</para>
-@dl: a datalist.
-@k: the string to identify the data element.
-@d: the data element.
-@f: the function to call when the data element is removed. This
-function will be called with the data element and can be used to free any
-memory allocated for it.
+@dl:
+@k:
+@d:
+@f:
<!-- ##### MACRO g_datalist_get_data ##### -->
<para>
-Gets a data element, using its string identifer.
-This is slower than g_datalist_id_get_data() because the string is first
-converted to a #GQuark.
+
</para>
-@dl: a datalist.
-@k: the string identifying a data element.
-@Returns: the data element, or NULL if it is not found.
+@dl:
+@k:
<!-- ##### MACRO g_datalist_remove_data ##### -->
<para>
-Removes an element using its string identifier.
-The data element's destroy function is called if it has been set.
+
</para>
-@dl: a datalist.
-@k: the string identifying the data element.
+@dl:
+@k:
<!-- ##### MACRO g_datalist_remove_no_notify ##### -->
<!-- ##### FUNCTION g_datalist_foreach ##### -->
<para>
-Calls the given function for each data element of the datalist.
-The function is called with each data element's #GQuark id and data,
-together with the given @user_data parameter.
+
</para>
-@datalist: a datalist.
-@func: the function to call for each data element.
-@user_data: user data to pass to the function.
+@datalist:
+@func:
+@user_data:
<!-- ##### FUNCTION g_datalist_clear ##### -->
<para>
-Frees all the data elements of the datalist.
-The data elements' destroy functions are called if they have been set.
+
</para>
-@datalist: a datalist.
+@datalist:
Datasets
<!-- ##### SECTION Short_Description ##### -->
-associate groups of data elements with particular memory locations.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-Datasets associate groups of data elements with particular memory locations.
-These are useful if you need to associate data with a structure returned
-from an external library. Since you cannot modify the structure, you use
-its location in memory as the key into a dataset, where you can associate
-any number of data elements with it.
-</para>
-<para>
-There are two forms of most of the dataset functions.
-The first form uses strings to identify the data elements associated with
-a location. The second form uses #GQuark identifiers, which are created
-with a call to g_quark_from_string() or g_quark_from_static_string().
-The second form is quicker, since it does not require looking up the string
-in the hash table of #GQuark identifiers.
-</para>
-<para>
-There is no function to create a dataset. It is automatically created as
-soon as you add elements to it.
-</para>
-<para>
-To add data elements to a dataset use g_dataset_id_set_data(),
-g_dataset_id_set_data_full(), g_dataset_set_data()
-and g_dataset_set_data_full().
-</para>
-<para>
-To get data elements from a dataset use g_dataset_id_get_data() and
-g_dataset_get_data().
-</para>
-<para>
-To iterate over all data elements in a dataset use g_dataset_foreach().
-</para>
-<para>
-To remove data elements from a dataset use g_dataset_id_remove_data() and
-g_dataset_remove_data().
-</para>
-<para>
-To destroy a dataset, use g_dataset_destroy().
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### MACRO g_dataset_id_set_data ##### -->
<para>
-Sets the data element associated with the given #GQuark id.
-Any previous data with the same key is removed, and its destroy function
-is called.
+
</para>
-@l: the location identifying the dataset.
-@k: the #GQuark id to identify the data element.
-@d: the data element.
+@l:
+@k:
+@d:
<!-- ##### FUNCTION g_dataset_id_set_data_full ##### -->
<para>
-Sets the data element associated with the given #GQuark id, and also the
-function to call when the data element is destroyed.
-Any previous data with the same key is removed, and its
-destroy function is called.
+
</para>
-@dataset_location: the location identifying the dataset.
-@key_id: the #GQuark id to identify the data element.
-@data: the data element.
-@destroy_func: the function to call when the data element is removed. This
-function will be called with the data element and can be used to free any
-memory allocated for it.
+@dataset_location:
+@key_id:
+@data:
+@destroy_func:
<!-- ##### USER_FUNCTION GDestroyNotify ##### -->
<para>
-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.
+
</para>
-@data: the data element.
+@data:
<!-- ##### FUNCTION g_dataset_id_get_data ##### -->
<para>
-Gets the data element corresponding to a #GQuark.
+
</para>
-@dataset_location: the location identifying the dataset.
-@key_id: the #GQuark id to identify the data element.
-@Returns: the data element corresponding to the #GQuark, or NULL if it is
-not found.
+@dataset_location:
+@key_id:
+@Returns:
<!-- ##### MACRO g_dataset_id_remove_data ##### -->
<para>
-Removes a data element from a dataset.
-The data element's destroy function is called if it has been set.
+
</para>
-@l: the location identifying the dataset.
-@k: the #GQuark id identifying the data element.
+@l:
+@k:
<!-- ##### FUNCTION g_dataset_id_remove_no_notify ##### -->
@dataset_location:
@key_id:
+@Returns:
<!-- ##### MACRO g_dataset_set_data ##### -->
<para>
-Sets the data corresponding to the given string identifier.
+
</para>
-@l: the location identifying the dataset.
-@k: the string to identify the data element.
-@d: the data element.
+@l:
+@k:
+@d:
<!-- ##### MACRO g_dataset_set_data_full ##### -->
<para>
-Sets the data corresponding to the given string identifier, and the function
-to call when the data element is destroyed.
+
</para>
-@l: the location identifying the dataset.
-@k: the string to identify the data element.
-@d: the data element.
-@f: the function to call when the data element is removed. This
-function will be called with the data element and can be used to free any
-memory allocated for it.
+@l:
+@k:
+@d:
+@f:
<!-- ##### MACRO g_dataset_get_data ##### -->
<para>
-Gets the data element corresponding to a string.
+
</para>
-@l: the location identifying the dataset.
-@k: the string identifying the data element.
-@Returns: the data element corresponding to the string, or NULL if it is not
-found.
+@l:
+@k:
<!-- ##### MACRO g_dataset_remove_data ##### -->
<para>
-Removes a data element corresponding to a string.
-Its destroy function is called if it has been set.
+
</para>
-@l: the location identifying the dataset.
-@k: the string identifying the data element.
+@l:
+@k:
<!-- ##### MACRO g_dataset_remove_no_notify ##### -->
<!-- ##### FUNCTION g_dataset_foreach ##### -->
<para>
-Calls the given function for each data element which is associated with the
-given location.
+
</para>
-@dataset_location: the location identifying the dataset.
-@func: the function to call for each data element.
-@user_data: user data to pass to the function.
+@dataset_location:
+@func:
+@user_data:
<!-- ##### USER_FUNCTION GDataForeachFunc ##### -->
<para>
-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().
+
</para>
-@key_id: the #GQuark id to identifying the data element.
-@data: the data element.
-@user_data: user data passed to g_dataset_foreach().
+@key_id:
+@data:
+@user_data:
<!-- ##### FUNCTION g_dataset_destroy ##### -->
<para>
-Destroys the dataset, freeing all memory allocated, and calling any
-destroy functions set for data elements.
+
</para>
-@dataset_location: the location identifying the dataset.
+@dataset_location:
-<!-- ##### SECTION Title ##### -->\r
-Date and Time Functions\r
-\r
-<!-- ##### SECTION Short_Description ##### -->\r
-calendrical calculations and miscellaneous time stuff.\r
-\r
-<!-- ##### SECTION Long_Description ##### -->\r
-<para>\r
-The #GDate data structure represents a day between January 1, Year 1,\r
-and sometime a few thousand years in the future (right now it will go\r
-to the year 65535 or so, but g_date_set_parse() only parses up to the\r
-year 8000 or so - just count on "a few thousand"). #GDate is meant to\r
-represent everyday dates, not astronomical dates or historical dates\r
-or ISO timestamps or the like. It extrapolates the current Gregorian\r
-calendar forward and backward in time; there is no attempt to change\r
-the calendar to match time periods or locations. #GDate does not store\r
-time information; it represents a <emphasis>day</emphasis>.\r
-</para>\r
-\r
-<para>\r
-The #GDate implementation has several nice features; it is only a\r
-64-bit struct, so storing large numbers of dates is very efficient. It\r
-can keep both a Julian and Day-Month-Year representation of the date,\r
-since some calculations are much easier with one representation or the\r
-other. A Julian representation is simply a count of days since some\r
-fixed day in the past; for #GDate the fixed day is January 1, 1 AD.\r
-("Julian" dates in the #GDate API aren't really Julian dates in the\r
-technical sense; technically, Julian dates count from the start of the\r
-Julian period, Jan 1, 4713 BC).\r
-</para>\r
-\r
-<para>\r
-#GDate is simple to use. First you need a "blank" date; you can get a\r
-dynamically allocated date from g_date_new(), or you can declare an\r
-automatic variable or array and initialize it to a sane state by\r
-calling g_date_clear(). A cleared date is sane; it's safe to call\r
-g_date_set_dmy() and the other mutator functions to initialize the\r
-value of a cleared date. However, a cleared date is initially\r
-<emphasis>invalid</emphasis>, meaning that it doesn't represent a day\r
-that exists. It is undefined to call any of the date calculation\r
-routines on an invalid date. If you obtain a date from a user or other\r
-unpredictable source, you should check its validity with the\r
-g_date_valid() predicate. g_date_valid() is also used to check for\r
-errors with g_date_set_parse() and other functions that can\r
-fail. Dates can be invalidated by calling g_date_clear() again.\r
-</para>\r
-\r
-<para>\r
-<emphasis>It is very important to use the API to access the #GDate\r
-struct.</emphasis> Often only the DMY or only the Julian\r
-representation is valid. Sometimes neither is valid. Use the API.\r
-</para>\r
-\r
-<para>\r
-glib doesn't contain any time-manipulation functions; however, there\r
-is a #GTime typedef which is equivalent to time_t, and a #GTimeVal\r
-struct which represents a more precise time (with microseconds). You\r
-can request the current time as a #GTimeVal with g_get_current_time().\r
-</para>\r
-\r
-<!-- ##### SECTION See_Also ##### -->\r
-<para>\r
-\r
-</para>\r
-\r
-<!-- ##### STRUCT GTimeVal ##### -->\r
-<para>\r
-Represents a precise time, with seconds and microseconds. Same as the\r
-<structname>struct timeval</structname> returned by the\r
-<function>gettimeofday()</function> UNIX call.\r
-</para>\r
-\r
-@tv_sec: \r
-@tv_usec: \r
-\r
-<!-- ##### FUNCTION g_get_current_time ##### -->\r
-<para>\r
-Equivalent to <function>gettimeofday()</function>, but also works on\r
-Win32. Returns the current time.\r
-</para>\r
-\r
-@result: \r
-\r
-\r
-<!-- ##### TYPEDEF GTime ##### -->\r
-<para>\r
-Simply a replacement for time_t. Unrelated to GTimer.\r
-</para>\r
-\r
-\r
-<!-- ##### STRUCT GDate ##### -->\r
-<para>\r
-Represents a day between January 1, Year 1 and a few thousand years in\r
-the future. None of its members should be accessed directly. If the\r
-<structname>GDate</structname> is obtained from g_date_new(), it will\r
-be safe to mutate but invalid and thus not safe for calendrical computations.\r
-If it's declared on the stack, it will contain garbage so must be\r
-initialized with g_date_clear(). g_date_clear() makes the date invalid\r
-but sane. An invalid date doesn't represent a day, it's "empty." A\r
-date becomes valid after you set it to a Julian day or you set a day,\r
-month, and year.\r
-</para>\r
-\r
-@julian_days: \r
-@julian: \r
-@dmy: \r
-@day: \r
-@month: \r
-@year: \r
-\r
-<!-- ##### ENUM GDateDMY ##### -->\r
-<para>\r
-This enumeration isn't used in the API, but may be useful if you need\r
-to mark a number as a day, month, or year.\r
-</para>\r
-\r
-@G_DATE_DAY: \r
-@G_DATE_MONTH: \r
-@G_DATE_YEAR: \r
-\r
-<!-- ##### TYPEDEF GDateDay ##### -->\r
-<para>\r
-Integer representing a day of the month; between 1 and\r
-31. #G_DATE_BAD_DAY represents an invalid day of the month.\r
-</para>\r
-\r
-\r
-<!-- ##### ENUM GDateMonth ##### -->\r
-<para>\r
-Enumeration representing a month; values are #G_DATE_JANUARY,\r
-#G_DATE_FEBRUARY, etc. #G_DATE_BAD_MONTH is the "invalid" value.\r
-</para>\r
-\r
-@G_DATE_BAD_MONTH: \r
-@G_DATE_JANUARY: \r
-@G_DATE_FEBRUARY: \r
-@G_DATE_MARCH: \r
-@G_DATE_APRIL: \r
-@G_DATE_MAY: \r
-@G_DATE_JUNE: \r
-@G_DATE_JULY: \r
-@G_DATE_AUGUST: \r
-@G_DATE_SEPTEMBER: \r
-@G_DATE_OCTOBER: \r
-@G_DATE_NOVEMBER: \r
-@G_DATE_DECEMBER: \r
-\r
-<!-- ##### ENUM GDateWeekday ##### -->\r
-<para>\r
-Enumeration representing a day of the week; #G_DATE_MONDAY,\r
-#G_DATE_TUESDAY, etc. #G_DATE_BAD_WEEKDAY is an invalid weekday.\r
-</para>\r
-\r
-@G_DATE_BAD_WEEKDAY: \r
-@G_DATE_MONDAY: \r
-@G_DATE_TUESDAY: \r
-@G_DATE_WEDNESDAY: \r
-@G_DATE_THURSDAY: \r
-@G_DATE_FRIDAY: \r
-@G_DATE_SATURDAY: \r
-@G_DATE_SUNDAY: \r
-\r
-<!-- ##### TYPEDEF GDateYear ##### -->\r
-<para>\r
-Integer representing a year; #G_DATE_BAD_YEAR is the invalid\r
-value. The year must be 1 or higher; negative (BC) years are not\r
-allowed. The year is represented with four digits.\r
-</para>\r
-\r
-\r
-<!-- ##### MACRO G_DATE_BAD_DAY ##### -->\r
-<para>\r
-Represents an invalid #GDateDay.\r
-</para>\r
-\r
-\r
-\r
-<!-- ##### MACRO G_DATE_BAD_JULIAN ##### -->\r
-<para>\r
-Represents an invalid Julian day number.\r
-</para>\r
-\r
-\r
-\r
-<!-- ##### MACRO G_DATE_BAD_YEAR ##### -->\r
-<para>\r
-Represents an invalid year.\r
-</para>\r
-\r
-\r
-\r
-<!-- ##### FUNCTION g_date_add_days ##### -->\r
-<para>\r
-Increment a date some number of days. To move forward by weeks, add\r
-weeks*7 days. The date must be valid.\r
-</para>\r
-\r
-@date: The date to increment\r
-@n_days: Number of days to move the date forward\r
-\r
-\r
-<!-- ##### FUNCTION g_date_add_months ##### -->\r
-<para>\r
-Increment a date by some number of months. If the day of the month is\r
-greater than 28, this routine may change the day of the month (because\r
-the destination month may not have the current day in it). The date\r
-must be valid.\r
-</para>\r
-\r
-@date: Date to increment\r
-@n_months: Number of months to move forward\r
-\r
-\r
-<!-- ##### FUNCTION g_date_add_years ##### -->\r
-<para>\r
-Increment a date by some number of years. If the date is February 29,\r
-and the destination year is not a leap year, the date will be changed\r
-to February 28. The date must be valid.\r
-</para>\r
-\r
-@date: Date to increment\r
-@n_years: Number of years to move forward\r
-\r
-\r
-<!-- ##### FUNCTION g_date_clear ##### -->\r
-<para>\r
-Initialize one or more #GDate structs to a sane but invalid\r
-state. The cleared dates will not represent an existing date, but will\r
-not contain garbage. Useful to init a date declared on the stack.\r
-Validity can be tested with g_date_valid().\r
-</para>\r
-\r
-@date: Pointer to one or more dates to clear\r
-@n_dates: Number of dates to clear\r
-\r
-\r
-<!-- ##### FUNCTION g_date_compare ##### -->\r
-<para>\r
-<function>qsort()</function>-style comparsion function for dates. Both\r
-dates must be valid.\r
-</para>\r
-\r
-@lhs: First date to compare\r
-@rhs: Second date to compare\r
-@Returns: 0 for equal, less than zero if @lhs is less than @rhs,\r
-greater than zero if @lhs is greater than @rhs\r
-\r
-\r
-<!-- ##### FUNCTION g_date_day ##### -->\r
-<para>\r
-Return the day of the month; the #GDate must be valid.\r
-</para>\r
-\r
-@date: Date to extract the day of the month from\r
-@Returns: Day of the month\r
-\r
-\r
-<!-- ##### FUNCTION g_date_day_of_year ##### -->\r
-<para>\r
-Return the day of the year, where Jan 1 is the first day of the\r
-year. Date must be valid.\r
-</para>\r
-\r
-@date: Date to extract day of year from\r
-@Returns: Day of the year\r
-\r
-\r
-<!-- ##### FUNCTION g_date_days_in_month ##### -->\r
-<para>\r
-Return the number of days in a month, taking leap years into account.\r
-</para>\r
-\r
-@month: Month\r
-@year: Year\r
-@Returns: Number of days in @month during the year @year.\r
-\r
-\r
-<!-- ##### FUNCTION g_date_free ##### -->\r
-<para>\r
-Free a #GDate returned from g_date_new()\r
-</para>\r
-\r
-@date: Date to free\r
-\r
-\r
-<!-- ##### FUNCTION g_date_is_first_of_month ##### -->\r
-<para>\r
-Returns TRUE if the date is on the first of a month. Date must be valid.\r
-</para>\r
-\r
-@date: Date to check\r
-@Returns: Boolean, if the date is the first of the month\r
-\r
-\r
-<!-- ##### FUNCTION g_date_is_last_of_month ##### -->\r
-<para>\r
-Returns TRUE if the date is the last day of the month. Date must be valid.\r
-</para>\r
-\r
-@date: Date to check\r
-@Returns: Boolean, if the date is the last day of the month\r
-\r
-\r
-<!-- ##### FUNCTION g_date_is_leap_year ##### -->\r
-<para>\r
-Returns TRUE if the year is a leap year\r
-</para>\r
-\r
-@year: Year to check\r
-@Returns: Boolean, if the year is a leap year\r
-\r
-\r
-<!-- ##### FUNCTION g_date_julian ##### -->\r
-<para>\r
-Accessor, returns the Julian day or "serial number" of the #GDate. The\r
-Julian day is simply the number of days since January 1, Year 1; i.e.,\r
-January 1, Year 1 is Julian day 1; January 2, Year 1 is Julian day 2,\r
-etc. Date must be valid.\r
-</para>\r
-\r
-@date: Date to extract the Julian day from\r
-@Returns: Julian day\r
-\r
-\r
-<!-- ##### FUNCTION g_date_monday_week_of_year ##### -->\r
-<para>\r
-Return the week of the year, where weeks are understood to start on\r
-Monday. If the date is before the first Monday of the year, return\r
-0. Date must be valid.\r
-</para>\r
-\r
-@date: Date to use\r
-@Returns: Week of the year\r
-\r
-\r
-<!-- ##### FUNCTION g_date_monday_weeks_in_year ##### -->\r
-<para>\r
-Return the number of weeks in the year, where weeks are taken to start\r
-on Monday. Will be 52 or 53. Date must be valid. (Years always have 52\r
-7-day periods, plus 1 or 2 extra days depending on whether it's a leap\r
-year. This function is basically telling you how many Mondays are in\r
-the year, i.e. there are 53 Mondays if one of the extra days happens\r
-to be a Monday.)\r
-</para>\r
-\r
-@year: Year\r
-@Returns: Number of Mondays in the year\r
-\r
-\r
-<!-- ##### FUNCTION g_date_month ##### -->\r
-<para>\r
-Accessor for the month of the year. Date must be valid.\r
-</para>\r
-\r
-@date: Date to get the month from\r
-@Returns: A #GDateMonth\r
-\r
-\r
-<!-- ##### FUNCTION g_date_new ##### -->\r
-<para>\r
-Allocate a #GDate and initialize it to a sane state. The new date will\r
-be cleared (as if you'd called g_date_clear()) but invalid (it won't\r
-represent an existing day). Free the return value with g_date_free().\r
-</para>\r
-\r
-@Returns: The newly-allocated #GDate\r
-\r
-\r
-<!-- ##### FUNCTION g_date_new_dmy ##### -->\r
-<para>\r
-Like g_date_new(), but also sets the value of the date. Assuming the\r
-day/month/year triplet you pass in represents an existing day, the\r
-returned date will be valid.\r
-</para>\r
-\r
-@day: Day of the month\r
-@month: Month of the year\r
-@year: Year\r
-@Returns: Allocated date initialized with @day, @month, and @year\r
-\r
-\r
-<!-- ##### FUNCTION g_date_new_julian ##### -->\r
-<para>\r
-Like g_date_new(), but also sets the value of the date. Assuming the\r
-Julian day number you pass in is valid (greater than 0, less than an\r
-unreasonably large number), the returned date will be valid.\r
-</para>\r
-\r
-@julian_day: Days since January 1, Year 1\r
-@Returns: Allocated date initialized with @julian_day\r
-\r
-\r
-<!-- ##### FUNCTION g_date_set_day ##### -->\r
-<para>\r
-Set the day of the month for a #GDate. If the resulting day-month-year\r
-triplet is invalid, the date will be invalid.\r
-</para>\r
-\r
-@date: Date to set the day for\r
-@day: Day to set\r
-\r
-\r
-<!-- ##### FUNCTION g_date_set_dmy ##### -->\r
-<para>\r
-Set the value of a #GDate from a day, month, and year. The DMY triplet\r
-must be valid; if you aren't sure it is, call g_date_valid_dmy() to\r
-check before you set it.\r
-</para>\r
-\r
-@date: Date to set the value of\r
-@day: Day\r
-@month: Month\r
-@y: Year\r
-\r
-\r
-<!-- ##### FUNCTION g_date_set_julian ##### -->\r
-<para>\r
-Set the value of a #GDate from a Julian day number. \r
-</para>\r
-\r
-@date: Date to set\r
-@julian_date: Julian day number (days since January 1, Year 1)\r
-\r
-\r
-<!-- ##### FUNCTION g_date_set_month ##### -->\r
-<para>\r
-Set the month of the year for a #GDate. If the resulting\r
- day-month-year triplet is invalid, the date will be invalid.\r
-</para>\r
-\r
-@date: Date\r
-@month: Month to set\r
-\r
-\r
-<!-- ##### FUNCTION g_date_set_parse ##### -->\r
-<para>\r
-Parse a user-inputted string @str, and try to figure out what date it\r
-represents, taking the current locale into account. If the string is\r
-successfully parsed, the date will be valid after the call. Otherwise,\r
-it will be invalid. You should check using g_date_valid() to see\r
-whether the parsing succeeded.\r
-</para>\r
-\r
-<para>\r
-This function is not appropriate for file formats and the like; it\r
-isn't very precise, and its exact behavior varies with the\r
-locale. It's intended to be a heuristic routine that guesses what the\r
-user means by a given string (and it does work pretty well in that\r
-capacity).\r
-</para>\r
-\r
-@date: Date to fill in\r
-@str: String to parse\r
-\r
-\r
-<!-- ##### FUNCTION g_date_set_time ##### -->\r
-<para>\r
-Set the value of a date from a #GTime (time_t) value. To set the value\r
-of a date to the current day, you could write:\r
-<informalexample><programlisting>\r
- g_date_set_time(date, time(NULL));\r
-</programlisting></informalexample>\r
-</para>\r
-\r
-@date: Date to update\r
-@time: #GTime value to set\r
-\r
-\r
-<!-- ##### FUNCTION g_date_set_year ##### -->\r
-<para>\r
-Set the year for a #GDate. If the resulting day-month-year triplet is\r
- invalid, the date will be invalid.\r
-</para>\r
-\r
-@date: Date\r
-@year: Year to set\r
-\r
-\r
-<!-- ##### FUNCTION g_date_strftime ##### -->\r
-<para>\r
-Generate a printed representation of the date, in a locale-specific\r
-way. Works just like the standard C <function>strftime()</function>\r
-function, but only accepts date-related formats; time-related formats\r
-give undefined results. Date must be valid.\r
-</para>\r
-\r
-@s: Destination buffer\r
-@slen: Max buffer size\r
-@format: Format string\r
-@date: valid #GDate\r
-@Returns: number of characters written to the buffer, or 0 the buffer was too small\r
-\r
-\r
-<!-- ##### FUNCTION g_date_subtract_days ##### -->\r
-<para>\r
-Move a date some number of days into the past. To move by weeks, just\r
-move by weeks*7 days. Date must be valid.\r
-</para>\r
-\r
-@date: Date to decrement\r
-@n_days: Number of days to move\r
-\r
-\r
-<!-- ##### FUNCTION g_date_subtract_months ##### -->\r
-<para>\r
-Move a date some number of months into the past. If the current day of\r
-the month doesn't exist in the destination month, the day of the month\r
-may change. Date must be valid.\r
-</para>\r
-\r
-@date: Date to decrement\r
-@n_months: Number of months to move\r
-\r
-\r
-<!-- ##### FUNCTION g_date_subtract_years ##### -->\r
-<para>\r
-Move a date some number of years into the past. If the current day\r
-doesn't exist in the destination year (i.e. it's February 29 and you\r
-move to a non-leap-year) then the day is changed to February 29. Date\r
-must be valid.\r
-</para>\r
-\r
-@date: Date to decrement\r
-@n_years: Number of years to move\r
-\r
-\r
-<!-- ##### FUNCTION g_date_sunday_week_of_year ##### -->\r
-<para>\r
-Week of the year during which this date falls, if weeks are understood\r
-to being on Sunday. Date must be valid. Can return 0 if the day is\r
-before the first Sunday of the year.\r
-</para>\r
-\r
-@date: Date\r
-@Returns: Week number\r
-\r
-\r
-<!-- ##### FUNCTION g_date_sunday_weeks_in_year ##### -->\r
-<para>\r
-Return the number of weeks in the year, where weeks are taken to start\r
-on Sunday. Will be 52 or 53. Date must be valid. (Years always have 52\r
-7-day periods, plus 1 or 2 extra days depending on whether it's a leap\r
-year. This function is basically telling you how many Sundays are in\r
-the year, i.e. there are 53 Sundays if one of the extra days happens\r
-to be a Sunday.)\r
-</para>\r
-\r
-@year: Year to count weeks in\r
-@Returns: Number of weeks\r
-\r
-\r
-<!-- ##### FUNCTION g_date_to_struct_tm ##### -->\r
-<para>\r
-Fills in the date-related bits of a <structname>struct tm</structname>\r
-using the @date value. Initializes the non-date parts with something\r
-sane but meaningless.\r
-</para>\r
-\r
-@date: Date to set the <structname>struct tm</structname> from\r
-@tm: <structname>struct tm</structname> to fill\r
-\r
-\r
-<!-- ##### FUNCTION g_date_valid ##### -->\r
-<para>\r
-Returns TRUE if the #GDate represents an existing day. #GDate must not\r
-contain garbage; it should have been initialized with g_date_clear()\r
-if it wasn't allocated by one of the g_date_new() variants.\r
-</para>\r
-\r
-@date: Date to check\r
-@Returns: Whether the date is valid.\r
-\r
-\r
-<!-- ##### FUNCTION g_date_valid_day ##### -->\r
-<para>\r
-Returns TRUE if the day of the month is valid (a day is valid if it's\r
-between 1 and 31 inclusive).\r
-</para>\r
-\r
-@day: Day to check.\r
-@Returns: Boolean, whether the day is valid.\r
-\r
-\r
-<!-- ##### FUNCTION g_date_valid_dmy ##### -->\r
-<para>\r
-Returns TRUE if the day/month/year triplet forms a valid, existing day\r
-in the range of days GDate understands (Year 1 or later, no more than\r
-a few thousand years in the future).\r
-</para>\r
-\r
-@day: Day\r
-@month: Month\r
-@year: Year\r
-@Returns: Boolean, whether the date is a valid one\r
-\r
-\r
-<!-- ##### FUNCTION g_date_valid_julian ##### -->\r
-<para>\r
-Returns TRUE if the Julian day is valid. Anything greater than zero is basically a\r
-valid Julian, though there is a 32-bit limit.\r
-</para>\r
-\r
-@julian_date: Julian day to check\r
-@Returns: Boolean, whether the Julian day is valid.\r
-\r
-\r
-<!-- ##### FUNCTION g_date_valid_month ##### -->\r
-<para>\r
-Returns TRUE if the month value is valid. The 12 #GDateMonth\r
-enumeration values are the only valid months.\r
-</para>\r
-\r
-@month: Month\r
-@Returns: Boolean, whether the month is valid\r
-\r
-\r
-<!-- ##### FUNCTION g_date_valid_weekday ##### -->\r
-<para>\r
-Returns TRUE if the weekday is valid. The 7 #GDateWeekday enumeration\r
-values are the only valid weekdays.\r
-</para>\r
-\r
-@weekday: Weekday\r
-@Returns: Boolean, whether the weekday is valid.\r
-\r
-\r
-<!-- ##### FUNCTION g_date_valid_year ##### -->\r
-<para>\r
-Returns TRUE if the year is valid. Any year greater than 0 is valid,\r
-though there is a 16-bit limit to what GDate will understand.\r
-</para>\r
-\r
-@year: Year\r
-@Returns: Boolean, whether the year is valid.\r
-\r
-\r
-<!-- ##### FUNCTION g_date_weekday ##### -->\r
-<para>\r
-Returns the day of the week for a #GDate. The date must be valid.\r
-</para>\r
-\r
-@date: Date\r
-@Returns: Day of the week as a #GDateWeekday\r
-\r
-\r
-<!-- ##### FUNCTION g_date_year ##### -->\r
-<para>\r
-Accessor; returns the year of a #GDate. The date must be valid.\r
-</para>\r
-\r
-@date: Date\r
-@Returns: Year in which the date falls\r
-\r
-\r
+<!-- ##### SECTION Title ##### -->
+Date and Time Functions
+
+<!-- ##### SECTION Short_Description ##### -->
+
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### MACRO G_MICROSEC ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### STRUCT GTimeVal ##### -->
+<para>
+
+</para>
+
+@tv_sec:
+@tv_usec:
+
+<!-- ##### FUNCTION g_get_current_time ##### -->
+<para>
+
+</para>
+
+@result:
+
+
+<!-- ##### FUNCTION g_usleep ##### -->
+<para>
+
+</para>
+
+@microseconds:
+
+
+<!-- ##### STRUCT GDate ##### -->
+<para>
+
+</para>
+
+@julian_days:
+@julian:
+@dmy:
+@day:
+@month:
+@year:
+
+<!-- ##### TYPEDEF GTime ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### ENUM GDateDMY ##### -->
+<para>
+
+</para>
+
+@G_DATE_DAY:
+@G_DATE_MONTH:
+@G_DATE_YEAR:
+
+<!-- ##### TYPEDEF GDateDay ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### ENUM GDateMonth ##### -->
+<para>
+
+</para>
+
+@G_DATE_BAD_MONTH:
+@G_DATE_JANUARY:
+@G_DATE_FEBRUARY:
+@G_DATE_MARCH:
+@G_DATE_APRIL:
+@G_DATE_MAY:
+@G_DATE_JUNE:
+@G_DATE_JULY:
+@G_DATE_AUGUST:
+@G_DATE_SEPTEMBER:
+@G_DATE_OCTOBER:
+@G_DATE_NOVEMBER:
+@G_DATE_DECEMBER:
+
+<!-- ##### TYPEDEF GDateYear ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### ENUM GDateWeekday ##### -->
+<para>
+
+</para>
+
+@G_DATE_BAD_WEEKDAY:
+@G_DATE_MONDAY:
+@G_DATE_TUESDAY:
+@G_DATE_WEDNESDAY:
+@G_DATE_THURSDAY:
+@G_DATE_FRIDAY:
+@G_DATE_SATURDAY:
+@G_DATE_SUNDAY:
+
+<!-- ##### MACRO G_DATE_BAD_DAY ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_DATE_BAD_JULIAN ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_DATE_BAD_YEAR ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### FUNCTION g_date_new ##### -->
+<para>
+
+</para>
+
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_new_dmy ##### -->
+<para>
+
+</para>
+
+@day:
+@month:
+@year:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_new_julian ##### -->
+<para>
+
+</para>
+
+@julian_day:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_clear ##### -->
+<para>
+
+</para>
+
+@date:
+@n_dates:
+
+
+<!-- ##### FUNCTION g_date_free ##### -->
+<para>
+
+</para>
+
+@date:
+
+
+<!-- ##### FUNCTION g_date_set_day ##### -->
+<para>
+
+</para>
+
+@date:
+@day:
+
+
+<!-- ##### FUNCTION g_date_set_month ##### -->
+<para>
+
+</para>
+
+@date:
+@month:
+
+
+<!-- ##### FUNCTION g_date_set_year ##### -->
+<para>
+
+</para>
+
+@date:
+@year:
+
+
+<!-- ##### FUNCTION g_date_set_dmy ##### -->
+<para>
+
+</para>
+
+@date:
+@day:
+@month:
+@y:
+
+
+<!-- ##### FUNCTION g_date_set_julian ##### -->
+<para>
+
+</para>
+
+@date:
+@julian_date:
+
+
+<!-- ##### FUNCTION g_date_set_time ##### -->
+<para>
+
+</para>
+
+@date:
+@time:
+
+
+<!-- ##### FUNCTION g_date_set_parse ##### -->
+<para>
+
+</para>
+
+@date:
+@str:
+
+
+<!-- ##### FUNCTION g_date_add_days ##### -->
+<para>
+
+</para>
+
+@date:
+@n_days:
+
+
+<!-- ##### FUNCTION g_date_subtract_days ##### -->
+<para>
+
+</para>
+
+@date:
+@n_days:
+
+
+<!-- ##### FUNCTION g_date_add_months ##### -->
+<para>
+
+</para>
+
+@date:
+@n_months:
+
+
+<!-- ##### FUNCTION g_date_subtract_months ##### -->
+<para>
+
+</para>
+
+@date:
+@n_months:
+
+
+<!-- ##### FUNCTION g_date_add_years ##### -->
+<para>
+
+</para>
+
+@date:
+@n_years:
+
+
+<!-- ##### FUNCTION g_date_subtract_years ##### -->
+<para>
+
+</para>
+
+@date:
+@n_years:
+
+
+<!-- ##### FUNCTION g_date_compare ##### -->
+<para>
+
+</para>
+
+@lhs:
+@rhs:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_day ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_month ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_year ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_julian ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_weekday ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_day_of_year ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_days_in_month ##### -->
+<para>
+
+</para>
+
+@month:
+@year:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_is_first_of_month ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_is_last_of_month ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_is_leap_year ##### -->
+<para>
+
+</para>
+
+@year:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_monday_week_of_year ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_monday_weeks_in_year ##### -->
+<para>
+
+</para>
+
+@year:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_sunday_week_of_year ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_sunday_weeks_in_year ##### -->
+<para>
+
+</para>
+
+@year:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_strftime ##### -->
+<para>
+
+</para>
+
+@s:
+@slen:
+@format:
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_to_struct_tm ##### -->
+<para>
+
+</para>
+
+@date:
+@tm:
+
+
+<!-- ##### FUNCTION g_date_valid ##### -->
+<para>
+
+</para>
+
+@date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_valid_day ##### -->
+<para>
+
+</para>
+
+@day:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_valid_month ##### -->
+<para>
+
+</para>
+
+@month:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_valid_year ##### -->
+<para>
+
+</para>
+
+@year:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_valid_dmy ##### -->
+<para>
+
+</para>
+
+@day:
+@month:
+@year:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_valid_julian ##### -->
+<para>
+
+</para>
+
+@julian_date:
+@Returns:
+
+
+<!-- ##### FUNCTION g_date_valid_weekday ##### -->
+<para>
+
+</para>
+
+@weekday:
+@Returns:
+
+
Hash Tables
<!-- ##### SECTION Short_Description ##### -->
-associations between keys and values so that given a key the value
-can be found quickly.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-A #GHashTable provides associations between keys and values which
-is optimized so that given a key, the associated value can be found
-very quickly.
-</para>
-<para>
-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.
-</para>
-<para>
-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.
-</para>
-<para>
-To create a #GHashTable, use g_hash_table_new().
-</para>
-<para>
-To insert a key and value into a #GHashTable, use g_hash_table_insert().
-</para>
-<para>
-To lookup a value corresponding to a given key, use g_hash_table_lookup()
-and g_hash_table_lookup_extended().
-</para>
-<para>
-To remove a key and value, use g_hash_table_remove().
-</para>
-<para>
-To call a function for each key and value pair use g_hash_table_foreach().
-</para>
-<para>
-To destroy a #GHashTable use g_hash_table_destroy().
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GHashTable ##### -->
<para>
-The #GHashTable struct is an opaque data structure to represent a
-<link linkend="glib-Hash-Tables">Hash Table</link>.
-It should only be accessed via the following functions.
+
</para>
<!-- ##### FUNCTION g_hash_table_new ##### -->
<para>
-Creates a new #GHashTable.
+
</para>
-@hash_func: a function to create a hash value from a key.
-Hash values are used to determine where keys are stored within the
-#GHashTable data structure.
-The g_direct_hash(), g_int_hash() and g_str_hash() functions are provided for
-some common types of keys. If hash_func is NULL, g_direct_hash() is used.
-@key_compare_func: a function to compare two keys to see if they are equal.
-This is used when looking up keys in the #GHashTable.
-The g_direct_equal(), g_int_equal() and g_str_equal() functions are provided
-for the most common types of keys. If compare_func is NULL, keys are compared
-directly in a similar fashion to g_direct_equal(), but without the overhead
-of a function call.
-@Returns: a new #GHashTable.
+@hash_func:
+@key_compare_func:
+@Returns:
<!-- ##### USER_FUNCTION GHashFunc ##### -->
<para>
-Specifies the type of the hash function which is passed to
-g_hash_table_new() when a #GHashTable is created.
-</para>
-<para>
-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.
-</para>
-<para>
-FIXME: Need more here.
-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.
+
</para>
-@key: a key.
-@Returns: the hash value corresponding to the key.
+@key:
+@Returns:
<!-- ##### USER_FUNCTION GCompareFunc ##### -->
<para>
-Specifies the type of a comparison function used to compare two values.
-The value which should be returned depends on the context in which the
-#GCompareFunc is used.
-</para>
-<para>
-In g_hash_table_new(), g_cache_new(), and g_relation_index() the function
-should return TRUE if the two parameters are equal, or FALSE if they are not.
-</para>
-<para>
-In g_list_find_custom() and g_slist_find_custom() the function should return
-0 if the two parameters are equal.
-</para>
-<para>
-In g_list_insert_sorted(), g_list_sort(), g_slist_insert_sorted(),
-g_slist_sort() and g_tree_new() 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.
+
</para>
-@a: a value.
-@b: a value to compare with.
-@Returns: TRUE if the two values are equivalent.
+@a:
+@b:
+@Returns:
<!-- ##### FUNCTION g_hash_table_insert ##### -->
<para>
-Inserts a new key and value into a #GHashTable.
-If the key already exists in the #GHashTable its current value is replaced
-with the new value.
-</para>
-<note>
-<para>
-If the keys or values use dynamically allocated memory, then you should
-first check if the key already exists in the GHashTable. If it does,
-you should free the existing key and/or value before inserting the
-new key and value.
+
</para>
-</note>
-@hash_table: a #GHashTable.
-@key: a key to insert.
-@value: the value to associate with the key.
+@hash_table:
+@key:
+@value:
<!-- ##### FUNCTION g_hash_table_size ##### -->
<para>
-Returns the number of key/value pairs in a #GHashTable.
+
</para>
-@hash_table: a #GHashTable.
-@Returns: the number of key/value pairs in the #GHashTable.
+@hash_table:
+@Returns:
<!-- ##### FUNCTION g_hash_table_lookup ##### -->
<para>
-Looks up a key in the #GHashTable, returning the associated value or NULL
-if the key is not found.
+
</para>
-@hash_table: a #GHashTable.
-@key: the key to look up.
-@Returns: the associated value, or NULL if the key is not found.
+@hash_table:
+@key:
+@Returns:
<!-- ##### FUNCTION g_hash_table_lookup_extended ##### -->
<para>
-Looks up a key in the #GHashTable, returning the original key and the
-associated value and a gboolean which is TRUE if the key was found.
-This is useful if you need to free the memory allocated for the
-original key, for example before calling g_hash_table_remove().
+
</para>
-@hash_table: a #GHashTable.
-@lookup_key: the key to look up.
-@orig_key: returns the original key.
-@value: returns the value associated with the key.
-@Returns: TRUE if the key was found in the #GHashTable.
+@hash_table:
+@lookup_key:
+@orig_key:
+@value:
+@Returns:
<!-- ##### FUNCTION g_hash_table_foreach ##### -->
<para>
-Calls the given function for each of the key/value pairs in the #GHashTable.
-The function is passed the key and value of each pair, and the given
-@user_data parameter.
+
</para>
-@hash_table: a #GHashTable.
-@func: the function to call for each key/value pair.
-@user_data: use data to pass to the function.
+@hash_table:
+@func:
+@user_data:
<!-- ##### USER_FUNCTION GHFunc ##### -->
<para>
-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().
+
</para>
-@key: a key.
-@value: the value corresponding to the key.
-@user_data: user data passed to g_hash_table_foreach().
+@key:
+@value:
+@user_data:
<!-- ##### FUNCTION g_hash_table_remove ##### -->
<para>
-Removes a key and its associated value from a #GHashTable.
-</para>
-<note>
-<para>
-As with g_hash_table_insert(), you should make sure that any dynamically
-allocated values are freed yourself.
+
</para>
-</note>
-@hash_table: a #GHashTable.
-@key: the key to remove.
+@hash_table:
+@key:
<!-- ##### FUNCTION g_hash_table_foreach_remove ##### -->
<para>
-Calls the given function for each key/value pair in the #GHashTable.
-If the function returns TRUE, then the key/value pair is removed from the
-#GHashTable.
+
</para>
-@hash_table: a #GHashTable.
-@func: the function to call for each key/value pair.
-@user_data: user data to pass to the function.
-@Returns: the number of key/value paris removed.
+@hash_table:
+@func:
+@user_data:
+@Returns:
<!-- ##### USER_FUNCTION GHRFunc ##### -->
<para>
-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.
+
</para>
-@key: a key.
-@value: the value associated with the key.
-@user_data: user data passed to g_hash_table_remove().
-@Returns: TRUE if the key/value pair should be removed from the #GHashTable.
+@key:
+@value:
+@user_data:
+@Returns:
<!-- ##### FUNCTION g_hash_table_freeze ##### -->
<para>
-Disable resizing of a #GHashTable.
-</para>
-<para>
-This should be used if you need to make a lot of changes to a #GHashTable
-at once, as it reduces the number of times that the #GHashTable is rebuilt.
-You should call g_hash_table_thaw() after updating the #GHashTable to
-enable resizing again.
+
</para>
-@hash_table: a #GHashTable.
+@hash_table:
<!-- ##### FUNCTION g_hash_table_thaw ##### -->
<para>
-Enables resizing of a #GHashTable.
+
</para>
-@hash_table: a #GHashTable.
+@hash_table:
<!-- ##### FUNCTION g_hash_table_destroy ##### -->
<para>
-Destroys the #GHashTable.
-</para>
-<note>
-<para>
-If keys and/or values are dynamically allocated, you should free them
-first.
+
</para>
-</note>
-@hash_table: a #GHashTable.
+@hash_table:
<!-- ##### FUNCTION g_direct_equal ##### -->
<para>
-Compares two #gpointer arguments and returns TRUE if they are equal.
-It can be passed to g_hash_table_new() as the @key_compare_func
-parameter, when using pointers as keys in a #GHashTable.
+
</para>
-@v: a key.
-@v2: a key to compare with @v.
-@Returns: TRUE if the two keys match.
+@v:
+@v2:
+@Returns:
<!-- ##### FUNCTION g_direct_hash ##### -->
<para>
-Converts a gpointer to a hash value.
-It can be passed to g_hash_table_new() as the @hash_func parameter, when
-using gpointer values as keys in a #GHashTable.
+
</para>
-@v: a gpointer key.
-@Returns: a hash value corresponding to the key.
+@v:
+@Returns:
<!-- ##### FUNCTION g_int_equal ##### -->
<para>
-Compares the two #gint values being pointed to and returns TRUE if they are
-equal.
-It can be passed to g_hash_table_new() as the @key_compare_func
-parameter, when using pointers to integers as keys in a #GHashTable.
+
</para>
-@v: a pointer to a #gint key.
-@v2: a pointer to a #gint key to compare with @v.
-@Returns: TRUE if the two keys match.
+@v:
+@v2:
+@Returns:
<!-- ##### FUNCTION g_int_hash ##### -->
<para>
-Converts a pointer to a #gint to a hash value.
-It can be passed to g_hash_table_new() as the @hash_func parameter, when
-using pointers to gint values as keys in a #GHashTable.
+
</para>
-@v: a pointer to a #gint key.
-@Returns: a hash value corresponding to the key.
+@v:
+@Returns:
<!-- ##### FUNCTION g_str_equal ##### -->
<para>
-Compares two strings and returns TRUE if they are equal.
-It can be passed to g_hash_table_new() as the @key_compare_func
-parameter, when using strings as keys in a #GHashTable.
+
</para>
-@v: a key.
-@v2: a key to compare with @v.
-@Returns: TRUE if the two keys match.
+@v:
+@v2:
+@Returns:
<!-- ##### FUNCTION g_str_hash ##### -->
<para>
-Converts a string to a hash value.
-It can be passed to g_hash_table_new() as the @hash_func parameter, when
-using strings as keys in a #GHashTable.
+
</para>
-@v: a string key.
-@Returns: a hash value corresponding to the key.
+@v:
+@Returns:
Hook Functions
<!-- ##### SECTION Short_Description ##### -->
-support for manipulating lists of hook functions.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-The #GHookList, #GHook and their related functions provide support for
-lists of hook functions. Functions can be added and removed from the lists,
-and the list of hook functions can be invoked.
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GHookList ##### -->
<para>
-<informaltable pgwide=1 frame="none" role="struct">
-<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
-<tbody>
-
-<row>
-<entry>#guint seq_id;</entry>
-<entry>the next free #GHook id.</entry>
-</row>
-
-<row>
-<entry>#guint hook_size;</entry>
-<entry>the size of the #GHookList elements, in bytes.</entry>
-</row>
-
-<row>
-<entry>#guint is_setup : 1;</entry>
-<entry>1 if the #GHookList has been initialized.</entry>
-</row>
-
-<row>
-<entry>#GHook *hooks;</entry>
-<entry>the first #GHook element in the list.</entry>
-</row>
-
-<row>
-<entry>#GMemChunk *hook_memchunk;</entry>
-<entry>the #GMemChunk used for allocating the #GHook elements.</entry>
-</row>
-
-<row>
-<entry>#GHookFreeFunc hook_free;</entry>
-<entry>the function to call to free a #GHook element.</entry>
-</row>
-
-<row>
-<entry>#GHookFreeFunc hook_destroy;</entry>
-<entry>the function to call to destory a #GHook element.</entry>
-</row>
-
-</tbody></tgroup></informaltable>
-
</para>
@seq_id:
<!-- ##### STRUCT GHook ##### -->
<para>
-<informaltable pgwide=1 frame="none" role="struct">
-<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
-<tbody>
-
-<row>
-<entry>#gpointer data;</entry>
-<entry>.</entry>
-</row>
-
-<row>
-<entry>#GHook *next;</entry>
-<entry>.</entry>
-</row>
-
-<row>
-<entry>#GHook *prev;</entry>
-<entry>.</entry>
-</row>
-
-<row>
-<entry>#guint ref_count;</entry>
-<entry>.</entry>
-</row>
-
-<row>
-<entry>#guint hook_id;</entry>
-<entry>.</entry>
-</row>
-
-<row>
-<entry>#guint flags;</entry>
-<entry>.</entry>
-</row>
-
-<row>
-<entry>#gpointer data;</entry>
-<entry>.</entry>
-</row>
-
-<row>
-<entry>#GDestroyNotify destroy;</entry>
-<entry>.</entry>
-</row>
-
-</tbody></tgroup></informaltable>
</para>
@data:
<!-- ##### FUNCTION g_hook_list_init ##### -->
<para>
-Initializes a #GHookList.
-This must be called before the #GHookList is used.
+
</para>
-@hook_list: a #GHookList.
-@hook_size: the size of each element in the #GHookList, typically
-sizeof (GHook).
+@hook_list:
+@hook_size:
<!-- ##### FUNCTION g_hook_list_invoke ##### -->
<para>
-Calls all of the #GHook functions in a #GHookList.
+
</para>
-@hook_list: a #GHookList.
-@may_recurse: TRUE if functions which are already running (e.g. in another
-thread) can be called. If set to FALSE, these are skipped.
+@hook_list:
+@may_recurse:
<!-- ##### FUNCTION g_hook_list_invoke_check ##### -->
<para>
-Calls all of the #GHook functions in a #GHookList.
-Any function which returns TRUE is removed from the #GHookList.
+
</para>
-@hook_list: a #GHookList.
-@may_recurse: TRUE if functions which are already running (e.g. in another
-thread) can be called. If set to FALSE, these are skipped.
+@hook_list:
+@may_recurse:
<!-- ##### FUNCTION g_hook_list_marshal ##### -->
</para>
-@hook_list: a #GHookList.
+@hook_list:
@may_recurse:
@marshaller:
@data:
</para>
-@hook_list: a #GHookList.
+@hook_list:
@may_recurse:
@marshaller:
@data:
<!-- ##### FUNCTION g_hook_list_clear ##### -->
<para>
-Removes all the #GHook elements from a #GHookList.
+
</para>
-@hook_list: a #GHookList.
+@hook_list:
<!-- ##### FUNCTION g_hook_alloc ##### -->
<para>
-Allocates space for a #GHook and initializes it.
+
</para>
-@hook_list: a #GHookList.
-@Returns: a new #GHook.
+@hook_list:
+@Returns:
<!-- ##### MACRO g_hook_append ##### -->
<para>
-Appends a #GHook onto the end of a #GHookList.
+
</para>
-@hook_list: a #GHookList.
-@hook: the #GHook to add to the end of @hook_list.
+@hook_list:
+@hook:
<!-- ##### FUNCTION g_hook_prepend ##### -->
<para>
-Prepends a #GHook on the start of a #GHookList.
+
</para>
-@hook_list: a #GHookList.
-@hook: the #GHook to add to the start of @hook_list.
+@hook_list:
+@hook:
<!-- ##### FUNCTION g_hook_insert_before ##### -->
<para>
-Inserts a #GHook into a #GHookList, before a given #GHook.
+
</para>
-@hook_list: a #GHookList.
-@sibling: the #GHook to insert the new #GHook before.
-@hook: the #GHook to insert.
+@hook_list:
+@sibling:
+@hook:
<!-- ##### FUNCTION g_hook_insert_sorted ##### -->
<para>
-Inserts a #GHook into a #GHookList, sorted by the given function.
+
</para>
-@hook_list: a #GHookList.
-@hook: the #GHook to insert.
-@func: the comparison function used to sort the #GHook elements.
+@hook_list:
+@hook:
+@func:
<!-- ##### USER_FUNCTION GHookCompareFunc ##### -->
<para>
-Defines the type of function used to compare #GHook elements in
-g_hook_insert_sorted().
+
</para>
-@new_hook: the #GHook being inserted.
-@sibling: the #GHook to compare with @new_hook.
-@Returns: a value <= 0 if @new_hook should be before @sibling.
+@new_hook:
+@sibling:
+@Returns:
<!-- ##### FUNCTION g_hook_compare_ids ##### -->
<para>
-Compares the ids of two #GHook elements, returning a negative value
-if the second id is greater than the first.
+
</para>
-@new_hook: a #GHook.
-@sibling: a #GHook to compare with @new_hook.
-@Returns: a value <= 0 if the id of @sibling is >= the id of @new_hook.
+@new_hook:
+@sibling:
+@Returns:
<!-- ##### FUNCTION g_hook_get ##### -->
<para>
-Returns the #GHook with the given id, or NULL if it is not found.
+
</para>
-@hook_list: a #GHookList.
-@hook_id: a hook id.
-@Returns: the #GHook with the given id, or NULL if it is not found.
+@hook_list:
+@hook_id:
+@Returns:
<!-- ##### FUNCTION g_hook_find ##### -->
<para>
-Finds a #GHook in a #GHookList using the given function to test for a match.
+
</para>
-@hook_list: a #GHookList.
-@need_valids: TRUE if #GHook elements which have been destroyed should be
-skipped.
-@func: the function to call for each #GHook, which should return TRUE when
-the #GHook has been found.
-@data: the data passed to @func.
-@Returns: the found #GHook or NULL if no matching #GHook is found.
+@hook_list:
+@need_valids:
+@func:
+@data:
+@Returns:
<!-- ##### FUNCTION g_hook_find_data ##### -->
<para>
-Finds a #GHook in a #GHookList with the given data.
+
</para>
-@hook_list: a #GHookList.
-@need_valids: TRUE if #GHook elements which have been destroyed should be
-skipped.
-@data: the data to find.
-@Returns: the #GHook with the given @data or NULL if no matching
-#GHook is found.
+@hook_list:
+@need_valids:
+@data:
+@Returns:
<!-- ##### FUNCTION g_hook_find_func ##### -->
<para>
-Finds a #GHook in a #GHookList with the given function.
+
</para>
-@hook_list: a #GHookList.
-@need_valids: TRUE if #GHook elements which have been destroyed should be
-skipped.
-@func: the function to find.
-@Returns: the #GHook with the given @func or NULL if no matching
-#GHook is found.
+@hook_list:
+@need_valids:
+@func:
+@Returns:
<!-- ##### USER_FUNCTION GHookFindFunc ##### -->
<para>
-Defines the type of the function passed to g_hooK_find_func().
+
</para>
-@hook: a #GHook.
-@data: user data passed to g_hook_find_func().
-@Returns: TRUE if the required #GHook has been found.
+@hook:
+@data:
+@Returns:
<!-- ##### FUNCTION g_hook_find_func_data ##### -->
<para>
-Finds a #GHook in a #GHookList with the given function and data.
+
</para>
-@hook_list: a #GHookList.
-@need_valids: TRUE if #GHook elements which have been destroyed should be
-skipped.
-@func: the function to find.
-@data: the data to find.
-@Returns: the #GHook with the given @func and @data or NULL if no matching
-#GHook is found.
+@hook_list:
+@need_valids:
+@func:
+@data:
+@Returns:
<!-- ##### FUNCTION g_hook_first_valid ##### -->
<para>
-Returns the first #GHook in a #GHookList which has not been destroyed.
-The reference count for the #GHook is incremented, so you must call
-g_hook_unref() to restore it when no longer needed. (Or call
-g_hook_next_valid() if you are stepping through the #GHookList.)
+
</para>
-@hook_list: a #GHookList.
-@may_be_in_call: TRUE if hooks which are currently running (e.g. in another
-thread) are considered valid. If set to FALSE, these are skipped.
-@Returns: the first valid #GHook, or NULL if none are valid.
+@hook_list:
+@may_be_in_call:
+@Returns:
<!-- ##### FUNCTION g_hook_next_valid ##### -->
<para>
-Returns the next #GHook in a #GHookList which has not been destroyed.
-The reference count for the #GHook is incremented, so you must call
-g_hook_unref() to restore it when no longer needed. (Or continue to call
-g_hook_next_valid() until NULL is returned.)
</para>
-@hook_list: a #GHookList.
-@hook: the current #GHook.
-@may_be_in_call: TRUE if hooks which are currently running (e.g. in another
-thread) are considered valid. If set to FALSE, these are skipped.
-@Returns: the next valid #GHook, or NULL if none are valid.
+@hook_list:
+@hook:
+@may_be_in_call:
+@Returns:
<!-- ##### ENUM GHookFlagMask ##### -->
<!-- ##### MACRO G_HOOK_IS_VALID ##### -->
<para>
-Returns TRUE if the #GHook is valid, i.e. it is in a #GHookList, it is active
-and it has not been destroyed.
+
</para>
-@hook: a #GHook.
-@Returns: TRUE if the #GHook is valid.
+@hook:
<!-- ##### MACRO G_HOOK_ACTIVE ##### -->
<para>
-Returns TRUE if the #GHook is active, which is normally TRUE until the #GHook
-is destroyed.
+
</para>
-@hook: a #GHook.
-@Returns: TRUE if the #GHook is active.
+@hook:
<!-- ##### MACRO G_HOOK_IN_CALL ##### -->
<para>
-Returns TRUE if the #GHook function is currently executing.
+
</para>
-@hook: a #GHook.
-@Returns: TRUE if the #GHook function is currently executing.
+@hook:
<!-- ##### MACRO G_HOOK_IS_UNLINKED ##### -->
<para>
-Returns TRUE if the #GHook is not in a #GHookList.
</para>
-@hook: a #GHook.
-@Returns: TRUE if the #GHook is not in a #GHookList.
+@hook:
<!-- ##### FUNCTION g_hook_ref ##### -->
<para>
-Increments the reference count for a #GHook.
+
</para>
-@hook_list: a #GHookList.
-@hook: the #GHook to increment the reference count of.
+@hook_list:
+@hook:
<!-- ##### FUNCTION g_hook_unref ##### -->
<para>
-Decrements the reference count of a #GHook.
-If the reference count falls to 0, the #GHook is removed from the #GHookList
-and g_hook_free() is called to free it.
+
</para>
-@hook_list: a #GHookList.
+@hook_list:
@hook:
<!-- ##### FUNCTION g_hook_free ##### -->
<para>
-Calls the #GHookList @hook_free function if it exists, and frees the memory
-allocated for the #GHook.
+
</para>
-@hook_list: a #GHookList.
-@hook: the #GHook to free.
+@hook_list:
+@hook:
<!-- ##### FUNCTION g_hook_destroy ##### -->
<para>
-Destroys a #GHook, given its ID.
+
</para>
-@hook_list: a #GHookList.
-@hook_id: a hook ID.
-@Returns: TRUE if the #GHook was found in the #GHookList and destroyed.
+@hook_list:
+@hook_id:
+@Returns:
<!-- ##### FUNCTION g_hook_destroy_link ##### -->
<para>
-Removes one #GHook from a #GHookList, calling the @hook_destroy function in
-the #GHookList, and the @destroy function of the #GHook, if they exist.
+
</para>
-@hook_list: a #GHookList.
-@hook: the #GHook to remove.
+@hook_list:
+@hook:
IO Channels
<!-- ##### SECTION Short_Description ##### -->
-portable support for using files, pipes and sockets.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-The #GIOChannel data type aims to provide a portable method for using file
-descriptors, pipes, and sockets, and integrating them into the
-<link linkend="glib-The-Main-Event-Loop">main event loop</link>.
-Currently full support is available on Unix platforms, though support for
-Windows is only partially complete.
-</para>
-<para>
-To create a new #GIOChannel on Unix systems use g_io_channel_unix_new().
-This works for plain file descriptors, pipes and sockets.
-</para>
-<para>
-Once a #GIOChannel has been created, it can be used in a generic manner
-with the functions g_io_channel_read(), g_io_channel_write(),
-g_io_channel_seek(), and g_io_channel_close().
-</para>
-<para>
-To add a #GIOChannel to the
-<link linkend="glib-The-Main-Event-Loop">main event loop</link>
-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.
-</para>
-<para>
-#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.)
-Using g_io_add_watch() or g_io_add_watch_full() increments a channel's
-reference count.
-</para>
-<para>
-GTK+ contains the convenience function gtk_input_add_full()
-which creates a #GIOChannel from a file descriptor and adds it to the
-<link linkend="glib-The-Main-Event-Loop">main event loop</link>.
-The event source can later be removed with gtk_input_remove().
-Similar functions can also be found in GDK.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
-<variablelist>
-
-<varlistentry>
-<term>gtk_input_add_full(), gtk_input_remove(), gdk_input_add(),
-gdk_input_add_full(), gdk_input_remove()</term>
-<listitem><para>
-Convenience functions for creating #GIOChannel instances and adding them to the
-<link linkend="glib-The-Main-Event-Loop">main event loop</link>.
-</para></listitem>
-</varlistentry>
-
-</variablelist>
+
</para>
+
<!-- ##### STRUCT GIOChannel ##### -->
<para>
-A data structure representing an IO Channel. The fields should be considered
-private and should only be accessed with the following functions.
+
</para>
@channel_flags:
<!-- ##### FUNCTION g_io_channel_unix_new ##### -->
<para>
-Creates a new #GIOChannel given a file descriptor.
-On Unix systems this works for plain files, pipes, and sockets.
-</para>
-<para>
-The returned #GIOChannel has a reference count of 1.
+
</para>
-@fd: a file descriptor.
-@Returns: a new #GIOChannel.
+@fd:
+@Returns:
<!-- ##### FUNCTION g_io_channel_unix_get_fd ##### -->
<para>
-Returns the file descriptor of the Unix #GIOChannel.
+
</para>
-@channel: a #GIOChannel, created with g_io_channel_unix_new().
-@Returns: the file descriptor of the #GIOChannel.
+@channel:
+@Returns:
<!-- ##### FUNCTION g_io_channel_init ##### -->
<para>
-Initializes a #GIOChannel struct. This is called by each of the above functions
-when creating a #GIOChannel, and so is not often needed by the application
-programmer (unless you are creating a new type of #GIOChannel).
+
</para>
-@channel: a #GIOChannel.
+@channel:
<!-- ##### FUNCTION g_io_channel_read ##### -->
<para>
-Reads data from a #GIOChannel.
+
</para>
-@channel: a #GIOChannel.
-@buf: a buffer to read the data into (which should be at least count bytes
-long).
-@count: the number of bytes to read from the #GIOChannel.
-@bytes_read: returns the number of bytes actually read.
-@Returns: %G_IO_ERROR_NONE if the operation was successful.
+@channel:
+@buf:
+@count:
+@bytes_read:
+@Returns:
<!-- ##### ENUM GIOError ##### -->
<!-- ##### FUNCTION g_io_channel_write ##### -->
<para>
-Writes data to a #GIOChannel.
+
</para>
-@channel: a #GIOChannel.
-@buf: the buffer containing the data to write.
-@count: the number of bytes to write.
-@bytes_written: the number of bytes actually written.
-@Returns: %G_IO_ERROR_NONE if the operation was successful.
+@channel:
+@buf:
+@count:
+@bytes_written:
+@Returns:
<!-- ##### FUNCTION g_io_channel_seek ##### -->
<para>
-Sets the current position in the #GIOChannel, similar to the standard system
-call <function>fseek()</function>.
+
</para>
-@channel: a #GIOChannel.
-@offset: an offset, in bytes, which is added to the position specified by
-@type.
-@type: the position in the file, which can be %G_SEEK_CUR (the current
-position), %G_SEEK_SET (the start of the file), or %G_SEEK_END (the end of the
-file).
-@Returns: %G_IO_ERROR_NONE if the operation was successful.
+@channel:
+@offset:
+@type:
+@Returns:
<!-- ##### ENUM GSeekType ##### -->
<para>
-An enumeration specifying the base position for a g_io_channel_seek()
-operation.
-
-<informaltable pgwide=1 frame="none" role="enum">
-<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
-<tbody>
-
-<row>
-<entry>G_SEEK_CUR</entry>
-<entry>the current position in the file.</entry>
-</row>
-
-<row>
-<entry>G_SEEK_SET</entry>
-<entry>the start of the file.</entry>
-</row>
-
-<row>
-<entry>G_SEEK_END</entry>
-<entry>the end of the file.</entry>
-</row>
-
-</tbody></tgroup></informaltable>
</para>
<!-- ##### FUNCTION g_io_channel_close ##### -->
<para>
-Closes a #GIOChannel.
-The #GIOChannel will be freed when its reference count drops to 0.
+
</para>
-@channel: a #GIOChannel.
+@channel:
<!-- ##### FUNCTION g_io_channel_ref ##### -->
<para>
-Increments the reference count of a #GIOChannel.
+
</para>
-@channel: a #GIOChannel.
+@channel:
<!-- ##### FUNCTION g_io_channel_unref ##### -->
<para>
-Decrements the reference count of a #GIOChannel.
+
</para>
-@channel: a #GIOChannel.
+@channel:
<!-- ##### FUNCTION g_io_add_watch ##### -->
<para>
-Adds the #GIOChannel into the
-<link linkend="glib-The-Main-Event-Loop">main event loop</link>
-with the default priority.
+
</para>
-@channel: a #GIOChannel.
-@condition: the condition to watch for.
-@func: the function to call when the condition is satisfied.
-@user_data: user data to pass to @func.
-@Returns: the event source id.
+@channel:
+@condition:
+@func:
+@user_data:
+@Returns:
<!-- ##### FUNCTION g_io_add_watch_full ##### -->
<para>
-Adds the #GIOChannel into the
-<link linkend="glib-The-Main-Event-Loop">main event loop</link>
-with the given priority.
+
</para>
-@channel: a #GIOChannel.
-@priority: the priority of the #GIOChannel source.
-@condition: the condition to watch for.
-@func: the function to call when the condition is satisfied.
-@user_data: user data to pass to @func.
-@notify: the function to call when the source is removed.
-@Returns: the event source id.
+@channel:
+@priority:
+@condition:
+@func:
+@user_data:
+@notify:
+@Returns:
<!-- ##### ENUM GIOCondition ##### -->
<para>
-A bitwise combination representing a condition to watch for on an event
-source.
-
-<informaltable pgwide=1 frame="none" role="enum">
-<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
-<tbody>
-
-<row>
-<entry>G_IO_IN</entry>
-<entry>There is data to read.</entry>
-</row>
-
-<row>
-<entry>G_IO_OUT</entry>
-<entry>Data can be written (without blocking).</entry>
-</row>
-
-<row>
-<entry>G_IO_PRI</entry>
-<entry>There is urgent data to read.</entry>
-</row>
-
-<row>
-<entry>G_IO_ERR</entry>
-<entry>Error condition.</entry>
-</row>
-
-<row>
-<entry>G_IO_HUP</entry>
-<entry>Hung up (the connection has been broken, usually for pipes and
-sockets).</entry>
-</row>
-
-<row>
-<entry>G_IO_NVAL</entry>
-<entry>Invalid request. The file descriptor is not open.</entry>
-</row>
-
-</tbody></tgroup></informaltable>
</para>
<!-- ##### USER_FUNCTION GIOFunc ##### -->
<para>
-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.
+
</para>
-@source: the #GIOChannel event source.
-@condition: the condition which has been satisfied.
-@data: user data set in g_io_add_watch() or g_io_add_watch_full().
-@Returns: the function should return FALSE if the event source should be
-removed.
+@source:
+@condition:
+@data:
+@Returns:
<!-- ##### STRUCT GIOFuncs ##### -->
<para>
-A table of functions used to handle different types of #GIOChannel in a
-generic way.
+
</para>
@io_read:
Limits of Basic Types
<!-- ##### SECTION Short_Description ##### -->
-portable method of determining the limits of the standard types.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These macros provide a portable method to determine the limits of some of
-the standard integer and floating point types.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### MACRO G_MININT ##### -->
<para>
-The minimum value which can be held in a #gint.
+
</para>
<!-- ##### MACRO G_MAXINT ##### -->
<para>
-The maximum value which can be held in a #gint.
+
+</para>
+
+
+
+<!-- ##### MACRO G_MAXUINT ##### -->
+<para>
+
</para>
<!-- ##### MACRO G_MINSHORT ##### -->
<para>
-The minimum value which can be held in a #gshort.
+
</para>
<!-- ##### MACRO G_MAXSHORT ##### -->
<para>
-The maximum value which can be held in a #gshort.
+
+</para>
+
+
+
+<!-- ##### MACRO G_MAXUSHORT ##### -->
+<para>
+
</para>
<!-- ##### MACRO G_MINLONG ##### -->
<para>
-The minimum value which can be held in a #glong.
+
</para>
<!-- ##### MACRO G_MAXLONG ##### -->
<para>
-The maximum value which can be held in a #glong.
+
+</para>
+
+
+
+<!-- ##### MACRO G_MAXULONG ##### -->
+<para>
+
</para>
<!-- ##### MACRO G_MINFLOAT ##### -->
<para>
-The minimum value which can be held in a #gfloat.
+
</para>
<!-- ##### MACRO G_MAXFLOAT ##### -->
<para>
-The maximum value which can be held in a #gfloat.
+
</para>
<!-- ##### MACRO G_MINDOUBLE ##### -->
<para>
-The minimum value which can be held in a #gdouble.
+
</para>
<!-- ##### MACRO G_MAXDOUBLE ##### -->
<para>
-The maximum value which can be held in a #gdouble.
+
</para>
Doubly-Linked Lists
<!-- ##### SECTION Short_Description ##### -->
-linked lists containing integer values or pointers to data, with the ability
-to iterate over the list in both directions.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-The #GList structure and its associated functions provide a standard
-doubly-linked list data structure.
-</para>
-<para>
-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
-<link linkend="glib-Singly-Linked-lists">Singly-Linked Lists</link>
-which only allows movement through the list in the forward direction).
-</para>
-<para>
-The data contained in each element can be either integer values, by using one
-of the
-<link linkend="glib-Type-Conversion-Macros">Type Conversion Macros</link>,
-or simply pointers to any type of data.
-</para>
-<para>
-List elements are allocated in blocks using a #GListAllocator, which is
-more efficient than allocating elements individually.
-</para>
-<para>
-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.
-</para>
-<para>
-There is no function to create a #GList. NULL is considered to be the empty
-list so you simply set a #GList* to NULL.
-</para>
-<para>
-To add elements, use g_list_append(), g_list_prepend(), g_list_insert()
-and g_list_insert_sorted().
-</para>
-<para>
-To remove elements, use g_list_remove().
-</para>
-<para>
-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().
-</para>
-<para>
-To find the index of an element use g_list_position() and g_list_index().
-</para>
-<para>
-To call a function for each element in the list use g_list_foreach().
-</para>
-<para>
-To free the entire list, use g_list_free().
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GList ##### -->
<para>
-The #GList struct is used for each element in a doubly-linked list.
-The <structfield>data</structfield> field holds the element's data, which can
-be a pointer to any kind of data, or any integer value using the
-<link linkend="glib-Type-Conversion-Macros">Type Conversion Macros</link>.
-The <structfield>next</structfield> and <structfield>prev</structfield>
-pointers are the links to the next and previous elements in the list.
+
</para>
@data:
<!-- ##### FUNCTION g_list_append ##### -->
<para>
-Adds a new element on to the end of the list.
-</para>
-<note>
-<para>
-The return value is the new start of the list, which may have changed, so
-make sure you store the new value.
-</para>
-</note>
-<informalexample><programlisting>
- /* Notice that these are initialized to the empty list. */
- GList *list = NULL, *number_list = NULL;
-
- /* This is a list of strings. */
- list = g_list_append (list, "first");
- list = g_list_append (list, "second");
- /* This is a list of integers. */
- number_list = g_list_append (number_list, GINT_TO_POINTER (27));
- number_list = g_list_append (number_list, GINT_TO_POINTER (14));
-</programlisting></informalexample>
+</para>
-@list: a pointer to a #GList.
-@data: the data for the new element.
-@Returns: the new start of the #GList.
+@list:
+@data:
+@Returns:
<!-- ##### FUNCTION g_list_prepend ##### -->
<para>
-Adds a new element on to the start of the list.
-</para>
-<note>
-<para>
-The return value is the new start of the list, which may have changed, so
-make sure you store the new value.
+
</para>
-</note>
-<informalexample><programlisting>
- /* Notice that it is initialized to the empty list. */
- GList *list = NULL;
- list = g_list_prepend (list, "last");
- list = g_list_prepend (list, "first");
-</programlisting></informalexample>
-@list: a pointer to a #GList.
-@data: the data for the new element.
-@Returns: the new start of the #GList.
+@list:
+@data:
+@Returns:
<!-- ##### FUNCTION g_list_insert ##### -->
<para>
-Inserts a new element into the list at the given position.
+
</para>
-@list: a pointer to a #GList.
-@data: the data for the new element.
-@position: the position to insert the element. If this is negative, or is
-larger than the number of elements in the list, the new element is added on
-to the end of the list.
-@Returns: the new start of the #GList.
+@list:
+@data:
+@position:
+@Returns:
<!-- ##### FUNCTION g_list_insert_sorted ##### -->
<para>
-Inserts a new element into the list, using the given comparison function
-to determine its position.
+
</para>
-@list: a pointer to a #GList.
-@data: the data for the new element.
-@func: the function to compare elements in the list. It should return a
-number > 0 if the first parameter comes after the second parameter in
-the sort order.
-@Returns: the new start of the #GList.
+@list:
+@data:
+@func:
+@Returns:
<!-- ##### FUNCTION g_list_remove ##### -->
<para>
-Removes an element from a #GList.
-If two elements contain the same data, only the first is removed.
-If none of the elements contain the data, the #GList is unchanged.
+
</para>
-@list: a #GList.
-@data: the data of the element to remove.
-@Returns: the new start of the #GList.
+@list:
+@data:
+@Returns:
<!-- ##### FUNCTION g_list_remove_link ##### -->
<para>
-Removes an element from a #GList, without freeing the element.
-The removed element's prev and next links are set to NULL, so that it becomes a
-self-contained list with one element.
+
</para>
-@list: a #GList.
-@llink: an element in the #GList.
-@Returns: the new start of the #GList, without the element.
+@list:
+@llink:
+@Returns:
-<!-- ##### FUNCTION g_list_free ##### -->
+<!-- ##### FUNCTION g_list_delete_link ##### -->
<para>
-Frees all of the memory used by a #GList.
-The freed elements are added to the #GListAllocator free list.
+
</para>
-<note>
+
+@list:
+@link:
+@Returns:
+
+
+<!-- ##### FUNCTION g_list_free ##### -->
<para>
-If list elements contain dynamically-allocated memory, they should be freed
-first.
+
</para>
-</note>
@list:
<!-- ##### FUNCTION g_list_alloc ##### -->
<para>
-Allocates space for one #GList element.
-It is called by g_list_append(), g_list_prepend(), g_list_insert() and
-g_list_insert_sorted() and so is rarely used on its own.
+
</para>
-@Returns: a pointer to the newly-allocated #GList element.
+@Returns:
<!-- ##### FUNCTION g_list_free_1 ##### -->
<para>
-Frees one #GList element.
-It is usually used after g_list_remove_link().
+
</para>
-@list: a #GList element.
+@list:
<!-- ##### FUNCTION g_list_length ##### -->
<para>
-Gets the number of elements in a #GList.
+
</para>
-@list: a #GList.
-@Returns: the number of elements in the #GList.
+@list:
+@Returns:
<!-- ##### FUNCTION g_list_copy ##### -->
<para>
-Copies a #GList.
-</para>
-<para>
-Note that this is a "shallow" copy. If the list elements consist of pointers
-to data, the pointers are copied but the actual data isn't.
+
</para>
-@list: a #GList.
-@Returns: a copy of @list.
+@list:
+@Returns:
<!-- ##### FUNCTION g_list_reverse ##### -->
<para>
-Reverses a #GList.
-It simply switches the next and prev pointers of each element.
+
</para>
-@list: a #GList.
-@Returns: the start of the reversed #GList.
+@list:
+@Returns:
<!-- ##### FUNCTION g_list_sort ##### -->
<para>
-Sorts a #GList using the given comparison function.
+
</para>
-@list: a #GList.
-@compare_func: the comparison function used to sort the #GList. This function
-is passed 2 elements of the #GList and should return 0 if they are equal,
-a negative value if the first element comes before the second, or a positive
-value if the first element comes after the second.
-@Returns: the start of the sorted #GList.
+@list:
+@compare_func:
+@Returns:
<!-- ##### FUNCTION g_list_concat ##### -->
<para>
-Adds the second #GList onto the end of the first #GList.
-Note that the elements of the second #GList are not copied.
-They are used directly.
+
</para>
-@list1: a #GList.
-@list2: the #GList to add to the end of the first #GList.
-@Returns: the start of the new #GList.
+@list1:
+@list2:
+@Returns:
<!-- ##### FUNCTION g_list_foreach ##### -->
<para>
-Calls a function for each element of a #GList.
+
</para>
-@list: a #GList.
-@func: the function to call with each element's data.
-@user_data: user data to pass to the function.
+@list:
+@func:
+@user_data:
<!-- ##### USER_FUNCTION GFunc ##### -->
<para>
-Specifies the type of functions passed to g_list_foreach() and
-g_slist_foreach().
+
</para>
-@data: the element's data.
-@user_data: user data passed to g_list_foreach() or g_slist_foreach().
+@data:
+@user_data:
<!-- ##### FUNCTION g_list_first ##### -->
<para>
-Gets the first element in a #GList.
+
</para>
-@list: a #GList.
-@Returns: the first element in a #GList, or NULL if the #GList has no elements.
+@list:
+@Returns:
<!-- ##### FUNCTION g_list_last ##### -->
<para>
-Gets the last element in a #GList.
+
</para>
-@list: a #GList.
-@Returns: the last element in the #GList, or NULL if the #GList has no
-elements.
+@list:
+@Returns:
<!-- ##### MACRO g_list_previous ##### -->
<para>
-A convenience macro to gets the previous element in a #GList.
+
</para>
-@list: an element in a #GList.
-@Returns: the previous element, or NULL if there are no previous elements.
+@list:
<!-- ##### MACRO g_list_next ##### -->
<para>
-A convenience macro to gets the next element in a #GList.
+
</para>
-@list: an element in a #GList.
-@Returns: the next element, or NULL if there are no more elements.
+@list:
<!-- ##### FUNCTION g_list_nth ##### -->
<para>
-Gets the element at the given position in a #GList.
+
</para>
-@list: a #GList.
-@n: the position of the element, counting from 0.
-@Returns: the element, or NULL if the position is off the end of the #GList.
+@list:
+@n:
+@Returns:
<!-- ##### FUNCTION g_list_nth_data ##### -->
<para>
-Gets the data of the element at the given position.
+
</para>
-@list: a #GList.
-@n: the position of the element.
-@Returns: the element's data, or NULL if the position is off the end of the
-#GList.
+@list:
+@n:
+@Returns:
<!-- ##### FUNCTION g_list_find ##### -->
<para>
-Finds the element in a #GList which contains the given data.
+
</para>
-@list: a #GList.
-@data: the element data to find.
-@Returns: the found #GList element, or NULL if it is not found.
+@list:
+@data:
+@Returns:
<!-- ##### FUNCTION g_list_find_custom ##### -->
<para>
-Finds an element in a #GList, using a supplied function to find the desired
-element.
-It iterates over the list, calling the given function which should return 0
-when the desired element is found.
-The function takes two #gconstpointer arguments, the #GList element's data
-and the given user data.
+
</para>
-@list: a #GList.
-@data: user data passed to the function.
-@func: the function to call for each element. It should return 0 when the
-desired element is found.
-@Returns: the found #GList element, or NULL if it is not found.
+@list:
+@data:
+@func:
+@Returns:
<!-- ##### FUNCTION g_list_position ##### -->
<para>
-Gets the position of the given element in the #GList (starting from 0).
+
</para>
-@list: a #GList.
-@llink: an element in the #GList.
-@Returns: the position of the element in the #GList, or -1 if the element is
-not found.
+@list:
+@llink:
+@Returns:
<!-- ##### FUNCTION g_list_index ##### -->
<para>
-Gets the position of the element containing the given data (starting from 0).
+
</para>
-@list: a #GList.
-@data: the data to find.
-@Returns: the index of the element containing the data, or -1 if the data
-is not found.
+@list:
+@data:
+@Returns:
-<!-- ##### FUNCTION g_list_pop_allocator ##### -->
+<!-- ##### FUNCTION g_list_push_allocator ##### -->
<para>
-Restores the previous #GAllocator, used when allocating #GList elements.
+
</para>
+@allocator:
-<!-- ##### FUNCTION g_list_push_allocator ##### -->
+<!-- ##### FUNCTION g_list_pop_allocator ##### -->
<para>
-Sets the allocator to use to allocate #GList elements.
-Use g_list_pop_allocator() to restore the previous allocator.
+
</para>
-@allocator: the #GAllocator to use when allocating #GList elements.
Singly-Linked Lists
<!-- ##### SECTION Short_Description ##### -->
-linked lists containing integer values or pointers to data, limited to
-iterating over the list in one direction.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-The #GSList structure and its associated functions provide a standard
-singly-linked list data structure.
-</para>
-<para>
-Each element in the list contains a piece of data, together with a pointer
-which links to the next element in the list.
-Using this pointer it is possible to move through the list in one
-direction only (unlike the
-<link linkend="glib-Doubly-Linked-lists">Doubly-Linked Lists</link>
-which allow movement in both directions).
-</para>
-<para>
-The data contained in each element can be either integer values, by using one
-of the
-<link linkend="glib-Type-Conversion-Macros">Type Conversion Macros</link>,
-or simply pointers to any type of data.
-</para>
-<para>
-List elements are allocated in blocks using a #GListAllocator, which is
-more efficient than allocating elements individually.
-</para>
-<para>
-Note that most of the #GSList 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.
-</para>
-<para>
-There is no function to create a #GSList. NULL is considered to be the empty
-list so you simply set a #GSList* to NULL.
-</para>
-<para>
-To add elements, use g_slist_append(), g_slist_prepend(), g_slist_insert()
-and g_slist_insert_sorted().
-</para>
-<para>
-To remove elements, use g_slist_remove().
-</para>
-<para>
-To find elements in the list use g_slist_last(), g_slist_next(),
-g_slist_nth(), g_slist_nth_data(), g_slist_find() and
-g_slist_find_custom().
-</para>
-<para>
-To find the index of an element use g_slist_position() and g_slist_index().
-</para>
-<para>
-To call a function for each element in the list use g_slist_foreach().
-</para>
-<para>
-To free the entire list, use g_slist_free().
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GSList ##### -->
<para>
-The #GSList struct is used for each element in the singly-linked list.
-The <structfield>data</structfield> field holds the element's data, which can
-be a pointer to any kind of data, or any integer value using the
-<link linkend="glib-Type-Conversion-Macros">Type Conversion Macros</link>.
-The <structfield>next</structfield> field contains the link to the next
-element in the list.
+
</para>
@data:
<!-- ##### FUNCTION g_slist_alloc ##### -->
<para>
-Allocates space for one #GSList element.
-It is called by the g_slist_append(), g_slist_prepend(), g_slist_insert() and
-g_slist_insert_sorted() functions and so is rarely used on its own.
+
</para>
-@Returns: a pointer to the newly-allocated #GSList element.
+@Returns:
<!-- ##### FUNCTION g_slist_append ##### -->
<para>
-Adds a new element on to the end of the list.
-</para>
-<note>
-<para>
-The return value is the new start of the list, which may have changed, so
-make sure you store the new value.
-</para>
-</note>
-<informalexample><programlisting>
- /* Notice that these are initialized to the empty list. */
- GSList *list = NULL, *number_list = NULL;
-
- /* This is a list of strings. */
- list = g_slist_append (list, "first");
- list = g_slist_append (list, "second");
- /* This is a list of integers. */
- number_list = g_slist_append (number_list, GINT_TO_POINTER (27));
- number_list = g_slist_append (number_list, GINT_TO_POINTER (14));
-</programlisting></informalexample>
+</para>
-@list: a #GSList.
-@data: the data for the new element.
-@Returns: the new start of the #GSList.
+@list:
+@data:
+@Returns:
<!-- ##### FUNCTION g_slist_prepend ##### -->
<para>
-Adds a new element on to the start of the list.
+
</para>
-<note>
+
+@list:
+@data:
+@Returns:
+
+
+<!-- ##### FUNCTION g_slist_insert ##### -->
<para>
-The return value is the new start of the list, which may have changed, so
-make sure you store the new value.
+
</para>
-</note>
-<informalexample><programlisting>
- /* Notice that it is initialized to the empty list. */
- GSList *list = NULL;
- list = g_slist_prepend (list, "last");
- list = g_slist_prepend (list, "first");
-</programlisting></informalexample>
-@list: a #GSList.
-@data: the data for the new element.
-@Returns: the new start of the #GSList.
+@list:
+@data:
+@position:
+@Returns:
-<!-- ##### FUNCTION g_slist_insert ##### -->
+<!-- ##### FUNCTION g_slist_insert_before ##### -->
<para>
-Inserts a new element into the list at the given position.
+
</para>
-@list: a #GSList.
-@data: the data for the new element.
-@position: the position to insert the element. If this is negative, or is
-larger than the number of elements in the list, the new element is added on
-to the end of the list.
-@Returns: the new start of the #GSList.
+@slist:
+@sibling:
+@data:
+@Returns:
<!-- ##### FUNCTION g_slist_insert_sorted ##### -->
<para>
-Inserts a new element into the list, using the given comparison function
-to determine its position.
+
</para>
-@list: a #GSList.
-@data: the data for the new element.
-@func: the function to compare elements in the list. It should return a
-number > 0 if the first parameter comes after the second parameter in
-the sort order.
-@Returns: the new start of the #GSList.
+@list:
+@data:
+@func:
+@Returns:
<!-- ##### FUNCTION g_slist_remove ##### -->
<para>
-Removes an element from a #GSList.
-If two elements contain the same data, only the first is removed.
-If none of the elements contain the data, the #GSList is unchanged.
+
</para>
-@list: a #GSList.
-@data: the data of the element to remove.
-@Returns: the new start of the #GSList.
+@list:
+@data:
+@Returns:
<!-- ##### FUNCTION g_slist_remove_link ##### -->
<para>
-Removes an element from a #GSList, without freeing the element.
-The removed element's next link is set to NULL, so that it becomes a
-self-contained list with one element.
+
</para>
-@list: a #GSList.
-@llink: an element in the #GSList.
-@Returns: the new start of the #GSList, without the element.
+@list:
+@link:
+@Returns:
+
+
+<!-- ##### FUNCTION g_slist_delete_link ##### -->
+<para>
+
+</para>
+
+@list:
+@link:
+@Returns:
<!-- ##### FUNCTION g_slist_free ##### -->
<para>
-Frees all of the memory used by a #GSList.
-The freed elements are added to the #GListAllocator free list.
+
</para>
-@list: a #GSList.
+@list:
<!-- ##### FUNCTION g_slist_free_1 ##### -->
<para>
-Frees one #GSList element.
-It is usually used after g_slist_remove_link().
+
</para>
-@list: a #GSList element.
+@list:
<!-- ##### FUNCTION g_slist_length ##### -->
<para>
-Gets the number of elements in a #GSList.
+
</para>
-@list: a #GSList.
-@Returns: the number of elements in the #GSList.
+@list:
+@Returns:
<!-- ##### FUNCTION g_slist_copy ##### -->
<para>
-Copies a #GSList.
-</para>
-<para>
-Note that this is a "shallow" copy. If the list elements consist of pointers
-to data, the pointers are copied but the actual data isn't.
+
</para>
-@list: a #GSList.
-@Returns: a copy of @list.
+@list:
+@Returns:
<!-- ##### FUNCTION g_slist_reverse ##### -->
<para>
-Reverses a #GSList.
+
</para>
-@list: a #GSList.
-@Returns: the start of the reversed #GSList.
+@list:
+@Returns:
<!-- ##### FUNCTION g_slist_sort ##### -->
<para>
-Sorts a #GSList using the given comparison function.
+
</para>
-@list: a #GSList.
-@compare_func: the comparison function used to sort the #GSList. This function
-is passed 2 elements of the #GSList and should return 0 if they are equal,
-a negative value if the first element comes before the second, or a positive
-value if the first element comes after the second.
-@Returns: the start of the sorted #GList.
+@list:
+@compare_func:
+@Returns:
<!-- ##### FUNCTION g_slist_concat ##### -->
<para>
-Adds the second #GSList onto the end of the first #GSList.
-Note that the elements of the second #GSList are not copied.
-They are used directly.
+
</para>
-@list1: a #GSList.
-@list2: the #GSList to add to the end of the first #GSList.
-@Returns: the start of the new #GSList.
+@list1:
+@list2:
+@Returns:
<!-- ##### FUNCTION g_slist_foreach ##### -->
<para>
-Calls a function for each element of a #GSList.
+
</para>
-@list: a #GSList.
-@func: the function to call with each element's data.
-@user_data: user data to pass to the function.
+@list:
+@func:
+@user_data:
<!-- ##### FUNCTION g_slist_last ##### -->
<para>
-Gets the last element in a #GSList.
+
</para>
-@list: a #GSList.
-@Returns: the last element in the #GSList, or NULL if the #GSList has no
-elements.
+@list:
+@Returns:
<!-- ##### MACRO g_slist_next ##### -->
<para>
-A convenience macro to gets the next element in a #GSList.
+
</para>
-@slist: an element in a #GSList.
-@Returns: the next element, or NULL if there are no more elements.
+@slist:
<!-- ##### FUNCTION g_slist_nth ##### -->
<para>
-Gets the element at the given position in a #GSList.
+
</para>
-@list: a #GSList.
-@n: the position of the element, counting from 0.
-@Returns: the element, or NULL if the position is off the end of the #GSList.
+@list:
+@n:
+@Returns:
<!-- ##### FUNCTION g_slist_nth_data ##### -->
<para>
-Gets the data of the element at the given position.
+
</para>
-@list: a #GSList.
-@n: the position of the element.
-@Returns: the element's data, or NULL if the position is off the end of the
-#GSList.
+@list:
+@n:
+@Returns:
<!-- ##### FUNCTION g_slist_find ##### -->
<para>
-Finds the element in a #GSList which contains the given data.
+
</para>
-@list: a #GSList.
-@data: the element data to find.
-@Returns: the found #GSList element, or NULL if it is not found.
+@list:
+@data:
+@Returns:
<!-- ##### FUNCTION g_slist_find_custom ##### -->
<para>
-Finds an element in a #GSList, using a supplied function to find the desired
-element.
-It iterates over the list, calling the given function which should return 0
-when the desired element is found.
-The function takes two #gconstpointer arguments, the #GSList element's data
-and the given user data.
+
</para>
-@list: a #GSList.
-@data: user data passed to the function.
-@func: the function to call for each element. It should return 0 when the
-desired element is found.
-@Returns: the found #GSList element, or NULL if it is not found.
+@list:
+@data:
+@func:
+@Returns:
<!-- ##### FUNCTION g_slist_position ##### -->
<para>
-Gets the position of the given element in the #GSList (starting from 0).
+
</para>
-@list: a #GSList.
-@llink: an element in the #GSList.
-@Returns: the position of the element in the #GSList, or -1 if the element
-is not found.
+@list:
+@llink:
+@Returns:
<!-- ##### FUNCTION g_slist_index ##### -->
<para>
-Gets the position of the element containing the given data (starting from 0).
+
</para>
-@list: a #GSList.
-@data: the data to find.
-@Returns: the index of the element containing the data, or -1 if the data
-is not found.
+@list:
+@data:
+@Returns:
-<!-- ##### FUNCTION g_slist_pop_allocator ##### -->
+<!-- ##### FUNCTION g_slist_push_allocator ##### -->
<para>
-Restores the previous #GAllocator, used when allocating #GSList elements.
+
</para>
+@allocator:
-<!-- ##### FUNCTION g_slist_push_allocator ##### -->
+
+<!-- ##### FUNCTION g_slist_pop_allocator ##### -->
<para>
-Sets the allocator to use to allocate #GSList elements.
-Use g_slist_pop_allocator() to restore the previous allocator.
+
</para>
-@allocator: the #GAllocator to use when allocating #GSList elements.
Standard Macros
<!-- ##### SECTION Short_Description ##### -->
-commonly-used macros.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These macros provide a few commonly-used features.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### MACRO GLIB_MAJOR_VERSION ##### -->
<para>
-The major version number of the GLib library.
+
</para>
<!-- ##### MACRO GLIB_MINOR_VERSION ##### -->
<para>
-The minor version number of the GLib library.
+
</para>
<!-- ##### MACRO GLIB_MICRO_VERSION ##### -->
<para>
-The micro version number of the GLib library.
+
+</para>
+
+
+
+<!-- ##### MACRO G_OS_WIN32 ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_OS_BEOS ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_OS_UNIX ##### -->
+<para>
+
</para>
<!-- ##### MACRO GLIB_CHECK_VERSION ##### -->
<para>
-Checks the version of the GLib library.
-It returns TRUE if the GLib library is the same or newer than the given
-version.
-<example>
-<title>Checking the version of the GLib library.</title>
-<programlisting>
- if (!GLIB_CHECK_VERSION (1, 2, 0))
- g_error ("GLib version 1.2.0 or above is needed");
-</programlisting>
-</example>
</para>
-@major: the major version number.
-@minor: the minor version number.
-@micro: the micro version number.
+@major:
+@minor:
+@micro:
<!-- ##### MACRO G_DIR_SEPARATOR ##### -->
<para>
-The directory separator character.
-This is '/' on Unix machines and '\' under Windows.
+
</para>
<!-- ##### MACRO G_DIR_SEPARATOR_S ##### -->
<para>
-The directory separator as a string.
-This is "/" on Unix machines and "\" under Windows.
+
</para>
<!-- ##### MACRO G_SEARCHPATH_SEPARATOR ##### -->
<para>
-The search path separator character.
-This is ':' on Unix machines and ';' under Windows.
+
</para>
<!-- ##### MACRO G_SEARCHPATH_SEPARATOR_S ##### -->
<para>
-The search path separator as a string.
-This is ":" on Unix machines and ";" under Windows.
+
</para>
<!-- ##### MACRO TRUE ##### -->
<para>
-Defines the TRUE value for the #gboolean type.
+
</para>
<!-- ##### MACRO FALSE ##### -->
<para>
-Defines the FALSE value for the #gboolean type.
+
</para>
<!-- ##### MACRO NULL ##### -->
<para>
-Defines the standard NULL pointer.
+
</para>
<!-- ##### MACRO MIN ##### -->
<para>
-Calculates the minimum of @a and @b.
+
</para>
-@a: a numeric value.
-@b: a numeric value.
-@Returns: the minimum of @a and @b.
+@a:
+@b:
<!-- ##### MACRO MAX ##### -->
<para>
-Calculates the maximum of @a and @b.
+
</para>
-@a: a numeric value.
-@b: a numeric value.
-@Returns: the maximum of @a and @b.
+@a:
+@b:
<!-- ##### MACRO ABS ##### -->
<para>
-Calculates the absolute value of @a.
-The absolute value is simply the number with any negative sign taken away.
-</para>
-<para>
-For example,
-<itemizedlist>
-<listitem><para>
-ABS(-10) is 10.
-</para></listitem>
-<listitem><para>
-ABS(10) is also 10.
-</para></listitem>
-</itemizedlist>
+
</para>
-@a: a numeric value.
-@Returns: the absolute value of @a.
+@a:
<!-- ##### MACRO CLAMP ##### -->
<para>
-Ensures that @x is between the limits set by @low and @high.
-</para>
-<para>
-For example,
-<itemizedlist>
-<listitem><para>
-CLAMP(5, 10, 15) is 10.
-</para></listitem>
-<listitem><para>
-CLAMP(15, 5, 10) is 10.
-</para></listitem>
-<listitem><para>
-CLAMP(20, 15, 25) is 20.
-</para></listitem>
-</itemizedlist>
+
</para>
-@x: the value to clamp.
-@low: the minimum value allowed.
-@high: the maximum value allowed.
-@Returns: the value of @x clamped to the range between @low and @high.
+@x:
+@low:
+@high:
<!-- ##### MACRO G_STRUCT_MEMBER ##### -->
<para>
-Returns a member of a structure at a given offset, using the given type.
+
</para>
-@member_type: the type of the struct field.
-@struct_p: a pointer to a struct.
-@struct_offset: the offset of the field from the start of the struct, in bytes.
-@Returns: the struct member.
+@member_type:
+@struct_p:
+@struct_offset:
<!-- ##### MACRO G_STRUCT_MEMBER_P ##### -->
<para>
-Returns an untyped pointer to a given offset of a struct.
+
</para>
-@struct_p: a pointer to a struct.
-@struct_offset: the offset from the start of the struct, in bytes.
-@Returns: an untyped pointer to @struct_p plus @struct_offset bytes.
+@struct_p:
+@struct_offset:
<!-- ##### MACRO G_STRUCT_OFFSET ##### -->
<para>
-Returns the offset, in bytes, of a member of a struct.
+
</para>
-@struct_type: a structure type, e.g. <structname>GtkWidget</structname>.
-@member: a field in the structure, e.g. <structfield>window</structfield>.
-@Returns: the offset of @member from the start of @struct_type.
+@struct_type:
+@member:
Miscellaneous Macros
<!-- ##### SECTION Short_Description ##### -->
-specialised macros which are not used often.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These macros provide more specialized features which are not needed so often
-by application programmers.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### MACRO G_INLINE_FUNC ##### -->
<para>
-Used to declare inline functions. If inline functions are not supported on
-the particular platform, the macro evaluates to the empty string.
+
</para>
<!-- ##### MACRO G_STMT_START ##### -->
<para>
-Used within multi-statement macros so that they can be used in places where
-only one statement is expected by the compiler.
+
</para>
<!-- ##### MACRO G_STMT_END ##### -->
<para>
-Used within multi-statement macros so that they can be used in places where
-only one statement is expected by the compiler.
+
+</para>
+
+
+
+<!-- ##### MACRO G_N_ELEMENTS ##### -->
+<para>
+
</para>
+@arr:
<!-- ##### MACRO G_VA_COPY ##### -->
<para>
-Portable way to copy <type>va_list</type> variables.
+
+</para>
+
+@ap1:
+@ap2:
+
+
+<!-- ##### MACRO G_STRINGIFY ##### -->
+<para>
+
</para>
-@ap1: the <type>va_list</type> variable to place a copy of @ap2 in.
-@ap2: a <type>va_list</type>.
+@macro_or_string:
<!-- ##### MACRO G_GNUC_EXTENSION ##### -->
<para>
-Expands to "__extension__" when GNU C is used as the compiler.
-This simply tells GNU C not to warn about the following non-standard code
-when compiling with the -pedantic option.
+
</para>
<!-- ##### MACRO G_GNUC_CONST ##### -->
<para>
-Expands to the GNU C const function attribute if the compiler is GNU C.
-This enables optimization of the function.
-See the GNU C documentation for details.
+
</para>
<!-- ##### MACRO G_GNUC_NORETURN ##### -->
<para>
-Expands to the GNU C noreturn function attribute if the compiler is GNU C.
-It is used for declaring functions which never return.
-It enables optimization of the function, and avoids possible compiler
-warnings. See the GNU C documentation for details.
+
</para>
<!-- ##### MACRO G_GNUC_UNUSED ##### -->
<para>
-Expands to the GNU C unused function attribute if the compiler is GNU C.
-It is used for declaring functions which may never be used.
-It avoids possible compiler warnings. See the GNU C documentation for details.
+
</para>
<!-- ##### MACRO G_GNUC_PRINTF ##### -->
<para>
-Expands to the GNU C format function attribute if the compiler is GNU C.
-This is used for declaring functions which take a variable number of
-arguments, with the same syntax as <function>printf()</function>.
-It allows the compiler to type-check the arguments passed to the function.
-See the GNU C documentation for details.
+
</para>
-@format_idx: the index of the argument corresponding to the format string.
-(The arguments are numbered from 1).
-@arg_idx: the index of the first of the format arguments.
+@format_idx:
+@arg_idx:
<!-- ##### MACRO G_GNUC_SCANF ##### -->
<para>
-Expands to the GNU C format function attribute if the compiler is GNU C.
-This is used for declaring functions which take a variable number of
-arguments, with the same syntax as <function>scanf()</function>.
-It allows the compiler to type-check the arguments passed to the function.
-See the GNU C documentation for details.
+
</para>
-@format_idx: the index of the argument corresponding to the format string.
-(The arguments are numbered from 1).
-@arg_idx: the index of the first of the format arguments.
+@format_idx:
+@arg_idx:
<!-- ##### MACRO G_GNUC_FORMAT ##### -->
<para>
-Expands to the GNU C format_arg function attribute if the compiler is GNU C.
-This is used for declaring functions which take a variable number of
-parameters, like <function>printf()</function> and
-<function>scanf()</function>. See the GNU C documentation for details.
-FIXME: I can't find this in my GNU C documentation. Take out?
</para>
-@arg_idx: the index of the argument.
+@arg_idx:
<!-- ##### MACRO G_GNUC_FUNCTION ##### -->
<para>
-Expands to the GNU C __FUNCTION__ variable if the compiler is GNU C,
-or "" if it isn't.
-The GNU C __FUNCTION__ variable contains the name of the current function.
-See the GNU C documentation for details.
+
</para>
<!-- ##### MACRO G_GNUC_PRETTY_FUNCTION ##### -->
<para>
-Expands to the GNU C __PRETTY_FUNCTION__ variable if the compiler is GNU C,
-or "" if it isn't.
-The GNU C __PRETTY_FUNCTION__ variable contains the name of the current
-function. For a C program this is the same as the __FUNCTION__ variable
-but for C++ it also includes extra information such as the class
-and function prototype. See the GNU C documentation for details.
+
</para>
-<!-- ##### MACRO g_string ##### -->
+<!-- ##### MACRO G_STRLOC ##### -->
<para>
-Turns the argument into a string literal by using the '#' stringizing operator.
+
+</para>
+
+
+
+<!-- ##### MACRO G_GSHORT_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GUSHORT_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GINT_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GUINT_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GLONG_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GULONG_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GINT16_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GUINT16_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GINT32_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GUINT32_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GINT64_FORMAT ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_GUINT64_FORMAT ##### -->
+<para>
+
</para>
-@x: text to convert to a literal string.
The Main Event Loop
<!-- ##### SECTION Short_Description ##### -->
-manages all available sources of events.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-The main event loop manages all the available sources of events for GLib
-and GTK+ applications. These events can come from any number of different
-types of sources such as file descriptors (plain files, pipes or sockets)
-and timeouts.
-New types of event sources can also be added using g_source_add().
-</para>
-<para>
-Each event source is assigned a priority.
-The default priority, #G_PRIORITY_DEFAULT, is 0.
-Values less than 0 denote higher priorities.
-Values greater than 0 denote lower priorities.
-Events from high priority sources
-are always processed before events from lower priority sources.
-</para>
-<para>
-Idle functions can also be added, and assigned a priority. These will be
-run whenever no events with a higher priority are ready to be processed.
-</para>
-<para>
-The #GMainLoop data type represents a main event loop.
-A #GMainLoop is created with g_main_new(). After adding the initial event
-sources, g_main_run() is called. This continuously checks for new events
-from each of the event sources and dispatches them.
-Finally, the processing of an event from one of the sources leads to a call
-to g_main_quit() to exit the main loop, and g_main_run() returns.
-</para>
-<para>
-It is possible to create new instances of #GMainLoop recursively.
-This is often used in GTK+ applications when showing modal dialog boxes.
-However, all event sources are global; they are not tied to a particular
-#GMainLoop.
-</para>
-<para>
-GTK+ contains wrappers of many of these functions,
-e.g. gtk_main(), gtk_main_quit(), gtk_events_pending(), gtk_idle_add(),
-gtk_timeout_add() and gtk_input_add_full().
-In a GTK+ application, these wrapper functions should be used instead.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GMainLoop ##### -->
<para>
-The #GMainLoop struct is an opaque data type representing the main event loop
-of a GLib or GTK+ application.
+
</para>
<!-- ##### FUNCTION g_main_new ##### -->
<para>
-Creates a new #GMainLoop.
+
</para>
-@is_running: set to TRUE to indicate that the loop is running. This is not
-very important since calling g_main_run() will set this to TRUE anyway.
-@Returns: a new #GMainLoop.
+@is_running:
+@Returns:
<!-- ##### FUNCTION g_main_destroy ##### -->
<para>
-Frees the memory allocated for the #GMainLoop.
+
</para>
-@loop: a #GMainLoop.
+@loop:
<!-- ##### FUNCTION g_main_run ##### -->
<para>
-Runs a main loop until it stops running, which occurs when g_main_quit()
-is called.
+
</para>
-@loop: a #GMainLoop.
+@loop:
<!-- ##### FUNCTION g_main_is_running ##### -->
<para>
-Returns TRUE if the main loop is running.
+
</para>
-@loop: a #GMainLoop.
-@Returns: TRUE if the main loop is running.
+@loop:
+@Returns:
<!-- ##### FUNCTION g_main_pending ##### -->
<para>
-Returns TRUE if any events are pending (i.e. ready to be processed).
+
</para>
-@Returns: TRUE if any events are pending.
+@Returns:
<!-- ##### FUNCTION g_main_iteration ##### -->
<para>
-Runs a single iteration of the main loop.
-This will check which event sources are ready to be processed, and will
-process the highest priority event sources which are ready.
+
</para>
-@may_block: set to TRUE if it should block (i.e. wait) until an event source
-becomes ready. It will return after an event source has been processed.
-If set to FALSE it will return immediately if no event source is ready to be
-processed.
-@Returns: TRUE if more events are pending.
+@may_block:
+@Returns:
<!-- ##### FUNCTION g_main_quit ##### -->
<para>
-Stops the #GMainLoop. If g_main_run() was called to run the #GMainLoop,
-it will now return.
+
</para>
-@loop: a #GMainLoop.
+@loop:
<!-- ##### MACRO G_PRIORITY_HIGH ##### -->
<para>
-Use this for high priority event sources.
-It is not used within GLib or GTK+.
+
</para>
<!-- ##### MACRO G_PRIORITY_DEFAULT ##### -->
<para>
-Use this for default priority event sources.
-In GLib this priority is used when adding timeout functions with
-g_timeout_add().
-In GDK this priority is used for events from the X Windows server.
+
</para>
<!-- ##### MACRO G_PRIORITY_HIGH_IDLE ##### -->
<para>
-Use this for high priority idle functions.
-GTK+ uses #G_PRIORITY_HIGH_IDLE + 10 for resizing operations, and
-#G_PRIORITY_HIGH_IDLE + 20 for redrawing operations. (This is done to
-ensure that any pending resizes are processed before any pending redraws,
-so that widgets are not redrawn twice unnecessarily.)
+
</para>
<!-- ##### MACRO G_PRIORITY_DEFAULT_IDLE ##### -->
<para>
-Use this for default priority idle functions.
-In GLib this priority is used when adding idle functions with g_idle_add().
+
</para>
<!-- ##### MACRO G_PRIORITY_LOW ##### -->
<para>
-Use this for very low priority background tasks.
-It is not used within GLib or GTK+.
+
</para>
<!-- ##### FUNCTION g_timeout_add ##### -->
<para>
-Sets a function to be called at regular intervals, with the default priority,
-#G_PRIORITY_DEFAULT.
-The function is called repeatedly until it returns FALSE, at which point
-the timeout is automatically destroyed and the function will not be called
-again.
-The first call to the function will be at the end of the first @interval.
-</para>
-<para>
-Note that timeout functions may be delayed, due to the processing of other
-event sources. Thus they should not be relied on for precise timing.
-After each call to the timeout function, the time of the next
-timeout is recalculated based on the current time and the given interval
-(it does not try to 'catch up' time lost in delays).
+
</para>
-@interval: the time between calls to @function, in milliseconds (1/1000ths
-of a second.)
-@function: the function to call at each interval.
-@data: data to pass to @function.
-@Returns: the id of the event source.
+@interval:
+@function:
+@data:
+@Returns:
<!-- ##### FUNCTION g_timeout_add_full ##### -->
<para>
-Sets a function to be called at regular intervals, with the given priority.
-The function is called repeatedly until it returns FALSE, at which point
-the timeout is automatically destroyed and the function will not be called
-again.
-The @notify function is called when the timeout is destroyed.
-The first call to the function will be at the end of the first @interval.
-</para>
-<para>
-Note that timeout functions may be delayed, due to the processing of other
-event sources. Thus they should not be relied on for precise timing.
-After each call to the timeout function, the time of the next
-timeout is recalculated based on the current time and the given interval
-(it does not try to 'catch up' time lost in delays).
+
</para>
-@priority: the priority of the function. See #G_PRIORITY_DEFAULT,
-#G_PRIORITY_DEFAULT_IDLE, #G_PRIORITY_HIGH, #G_PRIORITY_HIGH_IDLE, and
-#G_PRIORITY_LOW.
-@interval: the time between calls to the function, in milliseconds (1/1000ths
-of a second.)
-@function: the function to call at each interval.
-@data: data to pass to @function (and @notify).
-@notify: the function to call when the timeout is destroyed, or NULL.
-@Returns: the id of event source.
+@priority:
+@interval:
+@function:
+@data:
+@notify:
+@Returns:
<!-- ##### USER_FUNCTION GSourceFunc ##### -->
<para>
-Specifies the type of function passed to g_timeout_add(), g_timeout_add_full(),
-g_idle_add(), and g_idle_add_full().
+
</para>
-@data: data passed to the function, set when the source was created with one
-of the above functions.
-@Returns: it should return FALSE if the source should be removed.
+@data:
+@Returns:
<!-- ##### FUNCTION g_idle_add ##### -->
<para>
-Adds a function to be called whenever there are no higher priority events
-pending. The function is given the default idle priority,
-#G_PRIORITY_DEFAULT_IDLE.
-If the function returns FALSE it is automatically removed from the list of
-event sources and will not be called again.
+
</para>
-@function: the function to call.
-@data: data to pass to the function.
-@Returns: the id of the event source.
+@function:
+@data:
+@Returns:
<!-- ##### FUNCTION g_idle_add_full ##### -->
<para>
-Adds a function to be called whenever there are no higher priority events
-pending.
-If the function returns FALSE it is automatically removed from the list of
-event sources and will not be called again.
+
</para>
-@priority: the priority of the idle function, which should be somewhere around
-#G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
-@function: the function to call.
-@data: data to pass to the function.
-@destroy: the function to call when the timeout is destroyed, or NULL.
-@Returns: the id of the event source.
+@priority:
+@function:
+@data:
+@destroy:
+@Returns:
<!-- ##### FUNCTION g_idle_remove_by_data ##### -->
<para>
-Removes the idle function with the given data.
+
</para>
-@data: the data which is passed to the idle function.
-@Returns: TRUE if the idle function was found.
+@data:
+@Returns:
<!-- ##### FUNCTION g_main_add_poll ##### -->
<para>
-Adds a file descriptor to be polled.
-This is usually combined with g_source_add() to add an event source.
-The event source's check function will typically test the revents
-field in the #GPollFD struct and return TRUE if events need to be processed.
+
</para>
-@fd: a #GPollFD, which is a file descriptor together with a bitwise
-combination of #GIOCondition flags determining which events to poll for.
-@priority: the priority of the poll, which should be the same as the priority
-used for g_source_add() to ensure that the file descriptor is polled whenever
-the results may be needed.
-See #G_PRIORITY_DEFAULT, #G_PRIORITY_DEFAULT_IDLE, #G_PRIORITY_HIGH,
-#G_PRIORITY_HIGH_IDLE, and #G_PRIORITY_LOW.
+@fd:
+@priority:
<!-- ##### STRUCT GPollFD ##### -->
<para>
-<informaltable pgwide=1 frame="none" role="struct">
-<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
-<tbody>
-
-<row>
-<entry>#gint fd;</entry>
-<entry>the file descriptor to poll (or a HANDLE on Win32 platforms).</entry>
-</row>
-
-<row>
-<entry>#gushort events;</entry>
-<entry>a bitwise combination of flags from #GIOCondition, specifying which
-events should be polled for. Typically for reading from a file descriptor
-you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and for writing you would use
-%G_IO_OUT | %G_IO_ERR.
-</entry>
-</row>
-
-<row>
-<entry>#gushort revents;</entry>
-<entry>a bitwise combination of flags from #GIOCondition, returned from the
-poll() function to indicate which events occurred.
-</entry>
-</row>
-</tbody></tgroup></informaltable>
-
</para>
@fd:
<!-- ##### FUNCTION g_main_remove_poll ##### -->
<para>
-Removes a file descriptor from the list being polled.
+
</para>
-@fd: the #GPollFD to remove.
+@fd:
<!-- ##### FUNCTION g_main_set_poll_func ##### -->
<para>
-Sets the function to use to handle polling of file descriptors.
-It will be used instead of the <function>poll()</function> system call
-(or GLib's replacement function, which is used where
-<function>poll()</function> isn't available).
+
</para>
+
+@func:
+
+
+<!-- ##### FUNCTION g_main_win32_get_poll_func ##### -->
<para>
-This function could possibly be used to integrate the GLib event loop
-with an external event loop.
+
</para>
-@func: the function to call to poll all file descriptors.
+@Returns:
<!-- ##### USER_FUNCTION GPollFunc ##### -->
<para>
-Specifies the type of function passed to g_main_set_poll_func().
-The semantics of the function should match those of the
-<function>poll()</function> system call.
+
</para>
-@ufds: an array of #GPollFD elements.
-@nfsd: the number of elements in @ufds.
-@timeout: the maximum time to wait for an event of the file descriptors.
-@Returns: the number of #GPollFD elements which have events or errors reported,
-or -1 if an error occurred.
+@ufds:
+@nfsd:
+@timeout:
+@Returns:
<!-- ##### FUNCTION g_source_add ##### -->
<para>
-Adds an event source to the main loop.
+
</para>
-@priority: the priority of the event source. See #G_PRIORITY_DEFAULT,
-#G_PRIORITY_DEFAULT_IDLE, #G_PRIORITY_HIGH, #G_PRIORITY_HIGH_IDLE, and
-#G_PRIORITY_LOW.
-@can_recurse: if it is safe to call the source functions recursively.
-@funcs: the functions to handle the source.
-@source_data: data specific to the type of event source.
-@user_data: user data which will be passed to the user function handling the
-source.
-@notify: the function to call when the source is destroyed.
-@Returns: the id of the event source.
+@priority:
+@can_recurse:
+@funcs:
+@source_data:
+@user_data:
+@notify:
+@Returns:
<!-- ##### STRUCT GSourceFuncs ##### -->
<para>
-The #GSourceFuncs struct contains a table of functions used to handle
-event sources in a generic manner.
-
-<informaltable pgwide=1 frame="none" role="struct">
-<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
-<tbody>
-
-<row>
-<entry>prepare</entry>
-<entry>
-Called before all the file descriptors are polled.
-If the source can determine that it is ready here (without waiting for the
-results of the poll() call) it should return TRUE.
-It can also return a @timeout value which should be the maximum timeout
-(in milliseconds) which should be passed to the poll() call.
-The actual timeout used will be -1 if all sources returned -1, or it will
-be the minimum of all the @timeout values returned which were >= 0.
-</entry>
-</row>
-
-<row>
-<entry>check</entry>
-<entry>
-Called after all the file descriptors are polled.
-The source should return TRUE if it is ready to be processed.
-Note that some time may have passed since the previous prepare function was
-called, so the source should be checked again here.
-</entry>
-</row>
-
-<row>
-<entry>dispatch</entry>
-<entry>
-Called to process the event source, after it has returned TRUE in either
-its @prepare or its @check function.
-</entry>
-</row>
-
-<row>
-<entry>destroy</entry>
-<entry>
-Called when the source is destroyed. It will be called with the user data
-parameter passed to the g_source_add() and related functions.
-</entry>
-</row>
-</tbody></tgroup></informaltable>
-</para>
-
-<para>
-For idle sources, the prepare and check functions always return TRUE to
-indicate that the source is always ready to be processed.
-The prepare function also returns a timeout value of 0 to ensure that the
-poll() call doesn't block (since that would be time wasted which could have
-been spent running the idle function).
-</para>
-<para>
-For timeout sources, the prepare and check functions both return TRUE if the
-timeout interval has expired.
-The prepare function also returns a timeout value to ensure that the poll()
-call doesn't block too long and miss the next timeout.
-</para>
-<para>
-For file descriptor sources, the prepare function typically returns FALSE,
-since it must wait until poll() has been called before it knows whether any
-events need to be processed. It sets the returned timeout to -1 to indicate
-that it doesn't mind how long the poll() call blocks.
-In the check function, it tests the results of the poll() call to see if
-the required condition has been met, and returns TRUE if so.
+
</para>
@prepare:
<!-- ##### FUNCTION g_source_remove ##### -->
<para>
-Removes the event source with the given id.
-The id is returned when the source is created, either directly with
-g_source_add(), or indirectly with g_idle_add(), g_idle_add_full(),
-g_timeout_add() and g_timeout_add_full().
+
</para>
-@tag: the id of the event source to remove.
-@Returns: TRUE if the source was found and removed.
+@tag:
+@Returns:
<!-- ##### FUNCTION g_source_remove_by_funcs_user_data ##### -->
<para>
-Removes the first event source found with the given #GSourceFuncs and user
-data.
-</para>
-<para>
-Event sources are sorted with the highest priority first. Sources with equal
-priority are stored in the order in which they were added.
+
</para>
-@funcs: the #GSourceFuncs of the source to remove.
-@user_data: the user data of the source to remove.
-@Returns: TRUE if an event source was found and removed.
+@funcs:
+@user_data:
+@Returns:
<!-- ##### FUNCTION g_source_remove_by_source_data ##### -->
<para>
-Removes the first event source found with the given source data.
-</para>
-<para>
-Event sources are sorted with the highest priority first. Sources with equal
-priority are stored in the order in which they were added.
+
</para>
-@source_data: the source data, which contains information specific to the
-type of source.
-@Returns: TRUE if an event source was found and removed.
+@source_data:
+@Returns:
<!-- ##### FUNCTION g_source_remove_by_user_data ##### -->
<para>
-Removes the first event source found with the given user data.
-</para>
-<para>
-Event sources are sorted with the highest priority first. Sources with equal
-priority are stored in the order in which they were added.
+
</para>
-@user_data: the user data of the source to remove.
-@Returns: TRUE if an event source was found and removed.
+@user_data:
+@Returns:
Memory Allocation
<!-- ##### SECTION Short_Description ##### -->
-general memory-handling.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These functions provide support for allocating and freeing memory.
-</para>
-<note>
-<para>
-If any call to allocate memory fails, the application is terminated.
-This also means that there is no need to check if the call succeeded.
+
</para>
-</note>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### MACRO g_new ##### -->
<para>
-Allocates @count elements of type @type.
-The returned pointer is cast to a pointer to the given type.
-If @count is 0 it returns NULL.
+
</para>
-@type: the type of the elements to allocate.
-@count: the number of elements to allocate.
-@Returns: a pointer to the allocated memory, cast to a pointer to @type.
+@type:
+@count:
<!-- ##### MACRO g_new0 ##### -->
<para>
-Allocates @count elements of type @type, initialized to 0's.
-The returned pointer is cast to a pointer to the given type.
-If @count is 0 it returns NULL.
+
</para>
-@type: the type of the elements to allocate.
-@count: the number of elements to allocate.
-@Returns: a pointer to the allocated memory, cast to a pointer to @type.
+@type:
+@count:
<!-- ##### MACRO g_renew ##### -->
<para>
-Reallocates the memory pointed to by @mem, so that it now has space for
-@count elements of type @type. It returns the new address of the memory,
-which may have been moved.
+
</para>
-@type: the type of the elements to allocate.
-@mem: the currently allocated memory.
-@count: the number of elements to allocate.
-@Returns: a pointer to the new allocated memory, cast to a pointer to @type.
+@type:
+@mem:
+@count:
<!-- ##### FUNCTION g_malloc ##### -->
<para>
-Allocates @size bytes of memory.
-If @size is 0 it returns NULL.
+
</para>
-@size: the number of bytes to allocate.
-@Returns: a pointer to the allocated memory.
+@size:
+@Returns:
<!-- ##### FUNCTION g_malloc0 ##### -->
<para>
-Allocates @size bytes of memory, initialized to 0's.
-If @size is 0 it returns NULL.
+
</para>
-@size: the number of bytes to allocate.
-@Returns: a pointer to the allocated memory.
+@size:
+@Returns:
<!-- ##### FUNCTION g_realloc ##### -->
<para>
-Reallocates the memory pointed to by @mem, so that it now has space for
-@size bytes of memory. It returns the new address of the memory, which may
-have been moved.
+
</para>
-@mem: the memory to reallocate.
-@size: the new size of the allocated memory, in bytes.
-@Returns: the new address of the allocated memory.
+@mem:
+@size:
+@Returns:
<!-- ##### FUNCTION g_free ##### -->
<para>
-Frees the memory pointed to by @mem.
-If @mem is NULL it simply returns.
+
</para>
-@mem: the memory to free.
+@mem:
<!-- ##### MACRO g_memmove ##### -->
<para>
-Copies a block of memory @n bytes long, from @s to @d.
-The source and destination areas may overlap.
-</para>
-<note>
-<para>
-On architectures where memmove() is not available, this function is implemented
-using bcopy(), which may not be able to handle overlapping areas.
+
</para>
-</note>
-@d: the destination address to copy the bytes to.
-@s: the source address to copy the bytes from.
-@n: the number of bytes to copy.
+@d:
+@s:
+@n:
<!-- ##### FUNCTION g_memdup ##### -->
<para>
-Allocates @byte_size bytes of memory, and copies @byte_size bytes into it
-from @mem. If @mem is NULL it returns NULL.
+
</para>
-@mem: the memory to copy.
-@byte_size: the number of bytes to copy.
-@Returns: a pointer to the newly allocated copy of the memory, or NULL if @mem
-is NULL.
+@mem:
+@byte_size:
+@Returns:
<!-- ##### FUNCTION g_mem_profile ##### -->
<para>
-Outputs a summary of memory usage.
-To use this function you must configure glib with the flag
-'--enable-mem-profile=yes' before compiling.
-</para>
-<para>
-It outputs the frequency of allocations of different sizes,
-the total number of bytes which have been allocated,
-the total number of bytes which have been freed,
-and the difference between the previous two values, i.e. the number of bytes
-still in use.
+
</para>
<!-- ##### FUNCTION g_mem_check ##### -->
<para>
-Checks if the given memory has already been freed. If it has it outputs
-a warning message.
-To use this function you must configure glib with the flag
-'--enable-mem-check=yes' before compiling.
+
</para>
-@mem: the memory to check.
+@mem:
Memory Chunks
<!-- ##### SECTION Short_Description ##### -->
-efficient way to allocate groups of equal-sized chunks of memory.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-Memory chunks provide an efficient way to allocate equal-sized pieces of
-memory, called atoms. They are used extensively within GLib itself.
-For example, the
-<link linkend="glib-Doubly-Linked-lists">Doubly Linked Lists</link>
-use memory chunks to allocate space for elements of the lists.
-</para>
-<para>
-There are two types of memory chunks, #G_ALLOC_ONLY, and #G_ALLOC_AND_FREE.
-<itemizedlist>
-<listitem><para>
-#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.
-</para></listitem>
-<listitem><para>
-#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.
-</para></listitem>
-
-</itemizedlist>
-</para>
-<para>
-To create a memory chunk use g_mem_chunk_new() or the convenience macro
-g_mem_chunk_create().
-</para>
-<para>
-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().
-</para>
-<para>
-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.)
-</para>
-<para>
-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().
-</para>
-<para>
-To reset the memory chunk, freeing all of the atoms, use g_mem_chunk_reset().
-</para>
-<para>
-To destroy a memory chunk, use g_mem_chunk_destroy().
-</para>
-<para>
-To help debug memory chunks, use g_mem_chunk_info() and g_mem_chunk_print().
+
</para>
-<example>
-<title>Using a GMemChunk.</title>
-<programlisting>
- GMemChunk *mem_chunk;
- gchar *mem[10000];
- gint i;
-
- /* 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. */
- mem_chunk = g_mem_chunk_new ("test mem chunk", 50, 100, G_ALLOC_AND_FREE);
-
- /* Now allocate 10000 atoms. */
- for (i = 0; i < 10000; i++)
- {
- mem[i] = g_chunk_new (gchar, mem_chunk);
-
- /* Fill in the atom memory with some junk. */
- for (j = 0; j < 50; j++)
- mem[i][j] = i * j;
- }
-
- /* Now free all of the atoms. Note that since we are going to destroy the
- GMemChunk, this wouldn't normally be used. */
- for (i = 0; i < 10000; i++)
- {
- g_mem_chunk_free (mem_chunk, mem[i]);
- }
-
- /* We are finished with the GMemChunk, so we destroy it. */
- g_mem_chunk_destroy (mem_chunk);
-</programlisting></example>
-
-<example>
-<title>Using a GMemChunk with data structures.</title>
-<programlisting>
- GMemChunk *array_mem_chunk;
- GRealArray *array;
-
- /* Create a GMemChunk to hold GRealArray structures, using the
- g_mem_chunk_create() convenience macro. We want 1024 atoms in each
- memory block, and we want to be able to free individual atoms. */
- array_mem_chunk = g_mem_chunk_create (GRealArray, 1024, G_ALLOC_AND_FREE);
-
- /* Allocate one atom, using the g_chunk_new() convenience macro. */
- array = g_chunk_new (GRealArray, array_mem_chunk);
-
- /* We can now use array just like a normal pointer to a structure. */
- array->data = NULL;
- array->len = 0;
- array->alloc = 0;
- array->zero_terminated = (zero_terminated ? 1 : 0);
- array->clear = (clear ? 1 : 0);
- array->elt_size = elt_size;
-
- /* We can free the element, so it can be reused. */
- g_chunk_free (array, array_mem_chunk);
-
- /* We destroy the GMemChunk when we are finished with it. */
- g_mem_chunk_destroy (array_mem_chunk);
-</programlisting></example>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GMemChunk ##### -->
<para>
-The #GMemChunk struct is an opaque data structure representing a memory
-chunk. It should be accessed only through the use of the following functions.
+
</para>
<!-- ##### MACRO G_ALLOC_AND_FREE ##### -->
<para>
-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.
+
</para>
<!-- ##### MACRO G_ALLOC_ONLY ##### -->
<para>
-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.
+
</para>
<!-- ##### FUNCTION g_mem_chunk_new ##### -->
<para>
-Creates a new #GMemChunk.
+
</para>
-@name: a string to identify the #GMemChunk. It is not copied so it
-should be valid for the lifetime of the #GMemChunk. It is only used in
-g_mem_chunk_print(), which is used for debugging.
-@atom_size: the size, in bytes, of each element in the #GMemChunk.
-@area_size: the size, in bytes, of each block of memory allocated to contain
-the atoms.
-@type: the type of the #GMemChunk.
-#G_ALLOC_AND_FREE is used if the atoms will be freed individually.
-#G_ALLOC_ONLY should be used if atoms will never be freed individually.
-#G_ALLOC_ONLY is quicker, since it does not need to track free atoms,
-but it obviously wastes memory if you no longer need many of the atoms.
-@Returns: the new #GMemChunk.
+@name:
+@atom_size:
+@area_size:
+@type:
+@Returns:
<!-- ##### FUNCTION g_mem_chunk_alloc ##### -->
<para>
-Allocates an atom of memory from a #GMemChunk.
+
</para>
-@mem_chunk: a #GMemChunk.
-@Returns: a pointer to the allocated atom.
+@mem_chunk:
+@Returns:
<!-- ##### FUNCTION g_mem_chunk_alloc0 ##### -->
<para>
-Allocates an atom of memory from a #GMemChunk, setting the memory to 0.
+
</para>
-@mem_chunk: a #GMemChunk.
-@Returns: a pointer to the allocated atom.
+@mem_chunk:
+@Returns:
<!-- ##### FUNCTION g_mem_chunk_free ##### -->
<para>
-Frees an atom in a #GMemChunk.
-This should only be called if the #GMemChunk was created with
-#G_ALLOC_AND_FREE. Otherwise it will simply return.
+
</para>
-@mem_chunk: a #GMemChunk.
-@mem: a pointer to the atom to free.
+@mem_chunk:
+@mem:
<!-- ##### FUNCTION g_mem_chunk_destroy ##### -->
<para>
-Frees all of the memory allocated for a #GMemChunk.
+
</para>
-@mem_chunk: a #GMemChunk.
+@mem_chunk:
<!-- ##### MACRO g_mem_chunk_create ##### -->
<para>
-A convenience macro for creating a new #GMemChunk.
-It calls g_mem_chunk_new(), using the given type to create the #GMemChunk
-name. The atom size is determined using <function>sizeof()</function>, and the
-area size is calculated by multiplying the @pre_alloc parameter with
-the atom size.
+
</para>
-@type: the type of the atoms, typically a structure name.
-@pre_alloc: the number of atoms to store in each block of memory.
-@alloc_type: the type of the #GMemChunk.
-#G_ALLOC_AND_FREE is used if the atoms will be freed individually.
-#G_ALLOC_ONLY should be used if atoms will never be freed individually.
-#G_ALLOC_ONLY is quicker, since it does not need to track free atoms,
-but it obviously wastes memory if you no longer need many of the atoms.
-@Returns: the new #GMemChunk.
+@type:
+@pre_alloc:
+@alloc_type:
<!-- ##### MACRO g_chunk_new ##### -->
<para>
-A convenience macro to allocate an atom of memory from a #GMemChunk.
-It calls g_mem_chunk_alloc() and casts the returned atom to a pointer to
-the given type, avoiding a type cast in the source code.
+
</para>
-@type: the type of the #GMemChunk atoms, typically a structure name.
-@chunk: a #GMemChunk.
-@Returns: a pointer to the allocated atom, cast to a pointer to @type.
+@type:
+@chunk:
<!-- ##### MACRO g_chunk_new0 ##### -->
<para>
-A convenience macro to allocate an atom of memory from a #GMemChunk.
-It calls g_mem_chunk_alloc0() and casts the returned atom to a pointer to
-the given type, avoiding a type cast in the source code.
+
</para>
-@type: the type of the #GMemChunk atoms, typically a structure name.
-@chunk: a #GMemChunk.
-@Returns: a pointer to the allocated atom, cast to a pointer to @type.
+@type:
+@chunk:
<!-- ##### MACRO g_chunk_free ##### -->
<para>
-A convenience macro to free an atom of memory from a #GMemChunk.
-It simply switches the arguments and calls g_mem_chunk_free()
-It is included simply to complement the other convenience macros, g_chunk_new()
-and g_chunk_new0().
+
</para>
-@mem: a pointer to the atom to be freed.
-@mem_chunk: a #GMemChunk.
+@mem:
+@mem_chunk:
<!-- ##### FUNCTION g_mem_chunk_reset ##### -->
<para>
-Resets a GMemChunk to its initial state.
-It frees all of the currently allocated blocks of memory.
+
</para>
-@mem_chunk: a #GMemChunk.
+@mem_chunk:
<!-- ##### FUNCTION g_mem_chunk_clean ##### -->
<para>
-Frees any blocks in a #GMemChunk which are no longer being used.
+
</para>
-@mem_chunk: a #GMemChunk.
+@mem_chunk:
<!-- ##### FUNCTION g_blow_chunks ##### -->
<para>
-Calls g_mem_chunk_clean() on all #GMemChunk objects.
+
</para>
<!-- ##### FUNCTION g_mem_chunk_info ##### -->
<para>
-Outputs debugging information for all #GMemChunk objects currently in use.
-It outputs the number of #GMemChunk objects currently allocated,
-and calls g_mem_chunk_print() to output information on each one.
+
</para>
<!-- ##### FUNCTION g_mem_chunk_print ##### -->
<para>
-Outputs debugging information for a #GMemChunk.
-It outputs the name of the #GMemChunk (set with g_mem_chunk_new()),
-the number of bytes used, and the number of blocks of memory allocated.
+
</para>
-@mem_chunk: a #GMemChunk.
+@mem_chunk:
Message Logging
<!-- ##### SECTION Short_Description ##### -->
-versatile support for logging messages with different levels of importance.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These functions provide support for logging error messages or messages
-used for debugging.
-</para>
-<para>
-There are several built-in levels of messages, defined in #GLogLevelFlags.
-These can be extended with user-defined levels.
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### MACRO G_LOG_DOMAIN ##### -->
<para>
-Defines the log domain.
-For applications, this is typically left as the default NULL (or "") domain.
-Libraries should define this so that any messages which they log can
-be differentiated from messages from other libraries and application code.
-But be careful not to define it in any public header files.
-</para>
-<para>
-For example, GTK uses this in its Makefile.am:
-<informalexample><programlisting>
-INCLUDES = \
- -DG_LOG_DOMAIN=\"Gtk\"
-</programlisting></informalexample>
+
</para>
<!-- ##### MACRO G_LOG_FATAL_MASK ##### -->
<para>
-GLib log levels that are considered fatal by default.
+
</para>
<!-- ##### MACRO G_LOG_LEVEL_USER_SHIFT ##### -->
<para>
-Log level shift offset for user defined log levels (0-7 are used by GLib).
+
</para>
<!-- ##### USER_FUNCTION GLogFunc ##### -->
<para>
-Specifies the prototype of log handler functions.
+
</para>
-@log_domain: the log domain of the message.
-@log_level: the log level of the message (including the fatal and recursion
-flags).
-@message: the message to process.
-@user_data: user data, set in g_log_set_handler().
+@log_domain:
+@log_level:
+@message:
+@user_data:
<!-- ##### ENUM GLogLevelFlags ##### -->
<para>
-Flags specifying the level of log messages.
+
</para>
@G_LOG_FLAG_RECURSION:
<!-- ##### FUNCTION g_log ##### -->
<para>
-Logs an error or debugging message.
-If the log level has been set as fatal, the <function>abort()</function>
-function is called to terminate the program.
+
</para>
-@log_domain: the log domain, usually #G_LOG_DOMAIN.
-@log_level: the log level, either from #GLogLevelFlags or a user-defined level.
-@format: the message format. See the <function>printf()</function>
-documentation.
-@Varargs: the parameters to insert into the format string.
+@log_domain:
+@log_level:
+@format:
+@Varargs:
<!-- ##### FUNCTION g_logv ##### -->
<para>
-Logs an error or debugging message.
-If the log level has been set as fatal, the <function>abort()</function>
-function is called to terminate the program.
+
</para>
-@log_domain: the log domain.
-@log_level: the log level.
-@format: the message format. See the <function>printf()</function>
-documentation.
-@args: the parameters to insert into the format string.
+@log_domain:
+@log_level:
+@format:
+@args:
<!-- ##### MACRO g_message ##### -->
<para>
-A convenience function/macro to log a normal message.
+
</para>
-@format: the message format. See the <function>printf()</function>
-documentation.
-@args...: the parameters to insert into the format string.
+@...:
<!-- ##### MACRO g_warning ##### -->
<para>
-A convenience function/macro to log a warning message.
+
</para>
-@format: the message format. See the <function>printf()</function>
-documentation.
-@args...: the parameters to insert into the format string.
+@...:
-<!-- ##### MACRO g_error ##### -->
+<!-- ##### MACRO g_critical ##### -->
<para>
-A convenience function/macro to log an error message.
-Error messages are always fatal, resulting in a call to
-<function>abort()</function> to terminate the application.
+
</para>
-@format: the message format. See the <function>printf()</function>
-documentation.
-@args...: the parameters to insert into the format string.
+@...:
-<!-- ##### FUNCTION g_log_set_handler ##### -->
+<!-- ##### MACRO g_error ##### -->
<para>
-Sets the log handler for a domain and a set of log levels.
-To handle fatal and recursive messages the @log_levels parameter
-must be combined with the G_LOG_FLAG_FATAL and G_LOG_FLAG_RECURSIVE bit flags.
+
</para>
+
+@...:
+
+
+<!-- ##### FUNCTION g_log_set_handler ##### -->
<para>
-Note that since the G_LOG_LEVEL_ERROR log level is always fatal, if you want
-to set a handler for this log level you must combine it with G_LOG_FLAG_FATAL.
-</para>
-<example>
-<title>Adding a log handler for all warning messages</title>
-<programlisting>
- g_log_set_handler (NULL, G_LOG_LEVEL_WARNING | G_LOG_FLAG_FATAL
- | G_LOG_FLAG_RECURSIVE, my_log_handler, NULL);
-</programlisting>
-</example>
</para>
-@log_domain: the log domain, or NULL for the default "" application domain.
-@log_levels: the log levels to apply the log handler for. To handle fatal
-and recursive messages as well, combine the log levels with the
-G_LOG_FLAG_FATAL and G_LOG_FLAG_RECURSIVE bit flags.
-@log_func: the log handler function.
-@user_data: data passed to the log handler.
-@Returns: the id of the new handler.
+@log_domain:
+@log_levels:
+@log_func:
+@user_data:
+@Returns:
<!-- ##### FUNCTION g_log_remove_handler ##### -->
<para>
-Removes the log handler.
+
</para>
-@log_domain: the log domain.
-@handler_id: the id of the handler, which was returned in g_log_set_handler().
+@log_domain:
+@handler_id:
<!-- ##### FUNCTION g_log_set_always_fatal ##### -->
<para>
-Sets the message levels which are always fatal, in any log domain.
-When a message with any of these levels is logged the program terminates.
-You can only set the levels defined by GLib to be fatal.
-%G_LOG_LEVEL_ERROR is always fatal.
+
</para>
-@fatal_mask: the mask containing bits set for each level of error which is
-to be fatal.
-@Returns: the old fatal mask.
+@fatal_mask:
+@Returns:
<!-- ##### FUNCTION g_log_set_fatal_mask ##### -->
<para>
-Sets the log levels which are fatal in the given domain.
-%G_LOG_LEVEL_ERROR is always fatal.
+
</para>
-@log_domain: the log domain.
-@fatal_mask: the new fatal mask.
-@Returns: the old fatal mask for the log domain.
+@log_domain:
+@fatal_mask:
+@Returns:
<!-- ##### FUNCTION g_log_default_handler ##### -->
<para>
-The default log handler.
-This is used if no log handler has been set for the particular log domain
-and log level combination. It outputs the message to stderr or stdout
-and if the log level is fatal it calls <function>abort()</function>.
-</para>
-<para>
-stderr is used for levels %G_LOG_LEVEL_ERROR, %G_LOG_LEVEL_CRITICAL, and
-%G_LOG_LEVEL_WARNING. stdout is used for the rest.
-(On the Windows platform, stdout is always used.)
+
</para>
-@log_domain: the log domain of the message.
-@log_level: the level of the message.
-@message: the message.
-@unused_data: data passed from g_log which is unused.
+@log_domain:
+@log_level:
+@message:
+@unused_data:
<!-- ##### FUNCTION g_set_error_handler ##### -->
<para>
-Sets the function to be called to handle error messages.
-This function is deprecated in favour of the new logging facilities.
+
</para>
-@func: the function to be called to handle error messages.
-@Returns: the old error handler.
+@func:
+@Returns:
<!-- ##### USER_FUNCTION GErrorFunc ##### -->
<para>
-Specifies the type of function passed to g_set_error_handler().
+
</para>
-@str: the error message.
+@str:
<!-- ##### FUNCTION g_set_warning_handler ##### -->
<para>
-Sets the function to be called to handle warning messages.
-This function is deprecated in favour of the new logging facilities.
+
</para>
-@func: the function to be called to handle warning messages.
-@Returns: the old warning handler.
+@func:
+@Returns:
<!-- ##### USER_FUNCTION GWarningFunc ##### -->
<para>
-Specifies the type of function passed to g_set_warning_handler().
+
</para>
-@str: the warning message.
+@str:
<!-- ##### FUNCTION g_set_message_handler ##### -->
<para>
-Sets the function to be called to handle messages.
-This function is deprecated in favour of the new logging facilities.
+
</para>
-@func: the function to be called to handle normal messages.
-@Returns: the old message handler.
+@func:
+@Returns:
Miscellaneous Utility Functions
<!-- ##### SECTION Short_Description ##### -->
-a selection of portable utility functions.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These are portable utility functions.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### FUNCTION g_get_prgname ##### -->
<para>
-Gets the name of the program.
-(If you are using GDK or GTK the program name is set in gdk_init(), which
-is called by gtk_init(). The program name is found by taking the last
-component of argv[0].)
+
</para>
-@Returns: the name of the program.
+@Returns:
<!-- ##### FUNCTION g_set_prgname ##### -->
<para>
-Sets the name of the program.
+
</para>
-@prgname: the name of the program.
+@prgname:
<!-- ##### FUNCTION g_getenv ##### -->
<para>
-Returns an environment variable.
-On windows systems the returned value is only valid until the next call to
-g_getenv().
+
</para>
-@variable: the environment variable to get.
-@Returns: the value of the environment variable, or NULL if the environment
-variable is not found.
+@variable:
+@Returns:
<!-- ##### FUNCTION g_get_user_name ##### -->
<para>
-Gets the user name of the current user.
+
</para>
-@Returns: the user name of the current user.
+@Returns:
<!-- ##### FUNCTION g_get_real_name ##### -->
<para>
-Gets the real name of the user. This comes from the user's entry in the
-passwd file.
+
</para>
-@Returns: the user's real name.
+@Returns:
<!-- ##### FUNCTION g_get_home_dir ##### -->
<para>
-Gets the current user's home directory.
+
</para>
-@Returns: the current user's home directory.
+@Returns:
<!-- ##### FUNCTION g_get_tmp_dir ##### -->
<para>
-Gets the directory to use for temporary files.
-This is found from inspecting the environment variables TMPDIR, TMP, and TEMP
-in that order. If none of those are defined "/tmp" is returned.
+
</para>
-@Returns: the directory to use for temporary files.
+@Returns:
<!-- ##### FUNCTION g_get_current_dir ##### -->
<para>
-Gets the current directory.
-The returned string should be freed when no longer needed.
+
</para>
-@Returns: the current directory.
+@Returns:
<!-- ##### FUNCTION g_basename ##### -->
<para>
-Gets the name of the file without any leading directory components.
-It returns a pointer into the given file name string.
+
</para>
-@file_name: the name of the file.
-@Returns: the name of the file without any leading directory components.
+@file_name:
+@Returns:
<!-- ##### FUNCTION g_dirname ##### -->
<para>
-Gets the directory components of a file name.
-If the file name has no directory components "." is returned.
-The returned string should be freed when no longer needed.
+
</para>
-@file_name: the name of the file.
-@Returns: the directory components of the file.
+@file_name:
+@Returns:
<!-- ##### FUNCTION g_path_is_absolute ##### -->
<para>
-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 '/usr/local'
-or 'C:/windows' on windows systems.
+
</para>
-@file_name: a file name.
-@Returns: TRUE if @file_name is an absolute path.
+@file_name:
+@Returns:
<!-- ##### FUNCTION g_path_skip_root ##### -->
<para>
-Returns a pointer into @file_name after the root component, i.e. after
-the '/' in Unix or 'C:/' under Windows. If @file_name is not an absolute
-path it returns NULL.
+
</para>
-@file_name: a file name.
-@Returns: a pointer into @file_name after the root component.
+@file_name:
+@Returns:
+
+
+<!-- ##### FUNCTION g_path_get_dirname ##### -->
+<para>
+
+</para>
+
+@file_name:
+@Returns:
+
+
+<!-- ##### FUNCTION g_path_get_basename ##### -->
+<para>
+
+</para>
+
+@file_name:
+@Returns:
+
+
+<!-- ##### FUNCTION g_filename_to_utf8 ##### -->
+<para>
+
+</para>
+
+@opsysstring:
+@Returns:
+
+
+<!-- ##### FUNCTION g_filename_from_utf8 ##### -->
+<para>
+
+</para>
+
+@utf8string:
+@Returns:
<!-- ##### FUNCTION g_bit_nth_lsf ##### -->
<para>
-Find the position of the first bit set in @mask, searching from (but not
-including) @nth_bit upwards. Bits are numbered from 0 (least significant)
-to 31. To start searching from the 0th bit, set @nth_bit to -1.
+
</para>
-@mask: a #guint32 containing up to 32 bit flags.
-@nth_bit: the index of the bit to start the search from.
-@Returns: the index of the first bit set which is higher than @nth_bit.
+@mask:
+@nth_bit:
+@Returns:
<!-- ##### FUNCTION g_bit_nth_msf ##### -->
<para>
-Find the position of the first bit set in @mask, searching from (but not
-including) @nth_bit downwards. Bits are numbered from 0 (least significant)
-to 31. To start searching from the 31st bit, set @nth_bit to 32 or -1.
+
</para>
-@mask: a #guint32 containing up to 32 bit flags.
-@nth_bit: the index of the bit to start the search from.
-@Returns: the index of the first bit set which is lower than @nth_bit.
+@mask:
+@nth_bit:
+@Returns:
<!-- ##### FUNCTION g_bit_storage ##### -->
<para>
-Gets the number of bits used to hold @number,
-e.g. if @number is 4, 3 bits are needed.
+
</para>
-@number: a guint.
-@Returns: the number of bits used to hold @number.
+@number:
+@Returns:
<!-- ##### FUNCTION g_spaced_primes_closest ##### -->
<para>
-Gets the smallest prime number from a built-in array of primes which
-is larger than @num. This is used within GLib to calculate the optimum
-size of a #GHashTable.
-</para>
-<para>
-The built-in array of primes ranges from 11 to 13845163 such that
-each prime is approximately 1.5-2 times the previous prime.
+
</para>
-@num: a guint.
-@Returns: the smallest prime number from a built-in array of primes which is
-larger than @num.
+@num:
+@Returns:
<!-- ##### FUNCTION g_atexit ##### -->
<para>
-Specifies a function to be called at normal program termination.
+
</para>
-@func: the function to call on normal program termination.
+@func:
<!-- ##### FUNCTION g_parse_debug_string ##### -->
<para>
-Parses a string containing debugging options separated by ':' into a guint
-containing bit flags.
-This is used within GDK and GTK to parse the debug options passed on the
-command line or through environment variables.
+
</para>
-@string: a list of debug options separated by ':' or "all" to set all flags.
-@keys: pointer to an array of #GDebugKey which associate strings with
-bit flags.
-@nkeys: the number of #GDebugKey in the array.
-@Returns: the combined set of bit flags.
+@string:
+@keys:
+@nkeys:
+@Returns:
<!-- ##### STRUCT GDebugKey ##### -->
<para>
-Associates a string with a bit flag.
-Used in g_parse_debug_string().
+
</para>
@key:
<!-- ##### USER_FUNCTION GVoidFunc ##### -->
<para>
-Declares a type of function which takes no arguments and has no return value.
-It is used to specify the type function passed to g_atexit().
+
</para>
<!-- ##### USER_FUNCTION GFreeFunc ##### -->
<para>
-Declares a type of function which takes an arbitrary data pointer argument
-and has no return value. It is not currently used in GLib or GTK+.
+
</para>
@data:
Dynamic Loading of Modules
<!-- ##### SECTION Short_Description ##### -->
-portable method for dynamically loading 'plug-ins'.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These functions provide a portable way to dynamically load object files
-(commonly known as 'plug-ins').
-The current implementation supports all systems that provide
-an implementation of dlopen() (e.g. Linux/Sun), as well as HP-UX via its
-shl_load() mechanism, and Windows platforms via DLLs.
-</para>
-<para>
-To use them you must first determine whether dynamic loading
-is supported on the platform by calling g_module_supported().
-If it is, you can open a module with g_module_open(),
-find the module's symbols (e.g. function names) with g_module_symbol(),
-and later close the module with g_module_close().
-g_module_name() will return the file name of a currently opened module.
-</para>
-<para>
-If any of the above functions fail, the error status can be found with
-g_module_error().
-</para>
-<para>
-The gmodule implementation features reference counting for opened modules,
-and supports hook functions within a module which are called when the
-module is loaded and unloaded (see #GModuleCheckInit and #GModuleUnload).
-</para>
-<para>
-If your module introduces static data to common subsystems in the running
-program, e.g. through calling g_quark_from_static_string ("my-module-stuff"),
-it must ensure that it is never unloaded, by calling g_module_make_resident().
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GModule ##### -->
<para>
-The #GModule struct is an opaque data structure to represent a
-<link linkend="glib-Dynamic-Loading-of-Modules">Dynamically-Loaded Module</link>.
-It should only be accessed via the following functions.
+
</para>
<!-- ##### FUNCTION g_module_supported ##### -->
<para>
-Checks if modules are supported on the current platform.
+
</para>
-@Returns: TRUE if modules are supported.
+@Returns:
<!-- ##### FUNCTION g_module_build_path ##### -->
<para>
-A portable way to build the filename of a module. The platform-specific
-prefix and suffix are added to the filename, if needed, and the result is
-added to the directory, using the correct separator character.
-</para>
-<para>
-The directory should specify the directory where the module can be found.
-It can be NULL or an empty string to indicate that the module is in a standard
-operating-system specific directory, though this is not recommended since the
-wrong module may be found.
-</para>
-<para>
-For example, calling g_module_build_path() on a Linux system with a directory
-of "/lib" and a module_name of "mylibrary" will return "/lib/libmylibrary.so".
-On a Windows system, using "\Windows" as the directory it will return
-"\Windows\mylibrary.dll".
+
</para>
-@directory: the directory where the module is. This can be NULL or the empty
-string to indicate that the standard operating system-specific directories
-will be used, though that is not recommended.
-@module_name: the name of the module.
-@Returns: the complete path of the module, including the standard library
-prefix and suffix. This should be freed when no longer needed.
+@directory:
+@module_name:
+@Returns:
<!-- ##### FUNCTION g_module_open ##### -->
<para>
-Opens a module.
-If the module has already been opened, its reference count is incremented.
+
</para>
-@file_name: the name of the file containing the module.
-@flags: the flags used for opening the module. Currently this can be 0 or
-G_MODULE_BIND_LAZY for lazy binding, where symbols are only bound when needed.
-@Returns: a #GModule on success, or NULL on failure.
+@file_name:
+@flags:
+@Returns:
<!-- ##### ENUM GModuleFlags ##### -->
<para>
-Flags passed to g_module_open().
-G_MODULE_BIND_LAZY specifies that symbols are only resolved when needed.
-The default action is to bind all symbols when the module is loaded.
-(G_MODULE_BIND_LAZY is not supported on all platforms.)
+
</para>
@G_MODULE_BIND_LAZY:
<!-- ##### FUNCTION g_module_symbol ##### -->
<para>
-Gets a symbol pointer from a module.
+
</para>
-@module: the module.
-@symbol_name: the name of the symbol to find.
-@symbol: returns the pointer to the symbol value.
-@Returns: TRUE on success.
+@module:
+@symbol_name:
+@symbol:
+@Returns:
<!-- ##### FUNCTION g_module_name ##### -->
<para>
-Gets the file name from a #GModule.
+
</para>
-@module: the module.
-@Returns: the file name of the module, or "main" if the module is the main
-program itself.
+@module:
+@Returns:
<!-- ##### FUNCTION g_module_make_resident ##### -->
<para>
-Ensures that a module will never be unloaded.
-Any future g_module_close() calls on the module will be ignored.
+
</para>
-@module: a module to make permanently resident.
+@module:
<!-- ##### FUNCTION g_module_close ##### -->
<para>
-Closes a module.
+
</para>
-@module: the module to close.
-@Returns: TRUE on success.
+@module:
+@Returns:
<!-- ##### FUNCTION g_module_error ##### -->
<para>
-Gets a string describing the last module error.
+
</para>
-@Returns: a string describing the last module error.
+@Returns:
<!-- ##### USER_FUNCTION GModuleCheckInit ##### -->
<para>
-Specifies the type of the module initialization function.
-If a module contains a function named g_module_check_init() it is called
-automatically when the module is loaded. It is passed the #GModule structure
-and should return NULL on success or a string describing the initialization
-error.
+
</para>
-@module: the #GModule corresponding to the module which has just been loaded.
-@Returns: NULL on success, or a string describing the initialization error.
+@module:
+@Returns:
<!-- ##### USER_FUNCTION GModuleUnload ##### -->
<para>
-Specifies the type of the module function called when it is unloaded.
-If a module contains a function named g_module_unload() it is called
-automatically when the module is unloaded.
-It is passed the #GModule structure.
+
</para>
-@module: the module about to be unloaded.
+@module:
<!-- ##### MACRO G_MODULE_EXPORT ##### -->
<para>
-Used to declare functions exported by modules.
+
</para>
<!-- ##### MACRO G_MODULE_IMPORT ##### -->
<para>
-Used to declare functions imported from modules.
+
</para>
Quarks
<!-- ##### SECTION Short_Description ##### -->
-a 2-way association between a string and a unique integer identifier.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-Quarks are associations between strings and integer identifiers.
-Given either the string or the #GQuark identifier it is possible to
-retrieve the other.
-</para>
-<para>
-Quarks are used for both
-<link linkend="glib-datasets">Datasets</link> and
-<link linkend="glib-keyed-data-lists">Keyed Data Lists</link>.
-</para>
-<para>
-To create a new quark from a string, use g_quark_from_string() or
-g_quark_from_static_string().
-</para>
-<para>
-To find the string corresponding to a given #GQuark, use g_quark_to_string().
-</para>
-<para>
-To find the #GQuark corresponding to a given string, use g_quark_try_string().
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### TYPEDEF GQuark ##### -->
<para>
-A GQuark is an integer which uniquely identifies a particular string.
+
</para>
<!-- ##### FUNCTION g_quark_from_string ##### -->
<para>
-Gets the #GQuark identifying the given string.
-If the string does not currently have an associated #GQuark, a new
-#GQuark is created, using a copy of the string.
+
</para>
-@string: a string.
-@Returns: the #GQuark identifying the string.
+@string:
+@Returns:
<!-- ##### FUNCTION g_quark_from_static_string ##### -->
<para>
-Gets the #GQuark identifying the given (static) string.
-If the string does not currently have an associated #GQuark, a new
-#GQuark is created, linked to the given string.
-</para>
-<para>
-Note that this function is identical to g_quark_from_string() except
-that if a new #GQuark is created the string itself is used rather than
-a copy. This saves memory, but can only be used if the string will
-always exist (if, for example, it is a statically-allocated string).
+
</para>
-@string: a string.
-@Returns: the #GQuark identifying the string.
+@string:
+@Returns:
<!-- ##### FUNCTION g_quark_to_string ##### -->
<para>
-Gets the string associated with the given #GQuark.
+
</para>
-@quark: a #GQuark.
-@Returns: the string associated with the #GQuark.
+@quark:
+@Returns:
<!-- ##### FUNCTION g_quark_try_string ##### -->
<para>
-Gets the #GQuark associated with the given string, or 0 if the string has
-no associated #GQuark.
-</para>
-<para>
-If you want the GQuark to be created if it doesn't already exist, use
-g_quark_from_string() or g_quark_from_static_string().
+
</para>
-@string: a string.
-@Returns: the #GQuark associated with the string, or 0 if there is no
-#GQuark associated with the string.
+@string:
+@Returns:
Relations and Tuples
<!-- ##### SECTION Short_Description ##### -->
-tables of data which can be indexed on any number of fields.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-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.
-</para>
-<para>
-Note that #GRelation tables are currently limited to 2 fields.
-</para>
-<para>
-To create a GRelation, use g_relation_new().
-</para>
-<para>
-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.
-</para>
-<para>
-To add records to a #GRelation use g_relation_insert().
-</para>
-<para>
-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.)
-</para>
-<para>
-To count the number of records which have a particular value in a given
-field, use g_relation_count().
-</para>
-<para>
-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().
-</para>
-<para>
-To delete all records which have a particular value in a given field,
-use g_relation_delete().
-</para>
-<para>
-To destroy the #GRelation, use g_relation_destroy().
-</para>
-<para>
-To help debug #GRelation objects, use g_relation_print().
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GRelation ##### -->
<para>
-The #GRelation struct is an opaque data structure to represent a
-<link linkend="glib-Relations-and-Tuples">Relation</link>.
-It should only be accessed via the following functions.
+
</para>
<!-- ##### FUNCTION g_relation_new ##### -->
<para>
-Creates a new #GRelation with the given number of fields.
-Note that currently the number of fields must be 2.
+
</para>
-@fields: the number of fields.
-@Returns: a new #GRelation.
+@fields:
+@Returns:
<!-- ##### FUNCTION g_relation_index ##### -->
<para>
-Creates an index on the given field.
-Note that this must be called before any records are added to the #GRelation.
+
</para>
-@relation: a #GRelation.
-@field: the field to index, counting from 0.
-@hash_func: a function to produce a hash value from the field data.
-@key_compare_func: a function to compare two values of the given field.
+@relation:
+@field:
+@hash_func:
+@key_compare_func:
<!-- ##### FUNCTION g_relation_insert ##### -->
<para>
-Inserts a record into a #GRelation.
+
</para>
-@relation: a #GRelation.
-@Varargs: the fields of the record to add. This must match the number of
-fields in the #GRelation.
+@relation:
+@Varargs:
<!-- ##### FUNCTION g_relation_exists ##### -->
<para>
-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.
+
</para>
-@relation: a #GRelation.
-@Varargs: the fields of the record to compare. The number must match the
-number of fields in the #GRelation.
-@Returns: TRUE if a record matches.
+@relation:
+@Varargs:
+@Returns:
<!-- ##### FUNCTION g_relation_count ##### -->
<para>
-Returns the number of tuples in a #GRelation that have the given value
-in the given field.
+
</para>
-@relation: a #GRelation.
-@key: the value to compare with.
-@field: the field of each record to match.
-@Returns: the number of matches.
+@relation:
+@key:
+@field:
+@Returns:
<!-- ##### FUNCTION g_relation_select ##### -->
<para>
-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().
+
</para>
-@relation: a #GRelation.
-@key: the value to compare with.
-@field: the field of each record to match.
-@Returns: the records (tuples) that matched.
+@relation:
+@key:
+@field:
+@Returns:
<!-- ##### FUNCTION g_relation_delete ##### -->
<para>
-Deletes any records from a GRelation that have the given key value in
-the given field.
+
</para>
-@relation: a #GRelation.
-@key: the value to compare with.
-@field: the field of each record to match.
-@Returns: the number of records deleted.
+@relation:
+@key:
+@field:
+@Returns:
<!-- ##### FUNCTION g_relation_destroy ##### -->
<para>
-Destroys the #GRelation, freeing all memory allocated.
-However, it does not free memory allocated for the
-tuple data, so you should free that first if appropriate.
+
</para>
-@relation: a #GRelation.
+@relation:
<!-- ##### FUNCTION g_relation_print ##### -->
<para>
-Outputs information about all records in a #GRelation, as well as the indexes.
-It is for debugging.
+
</para>
-@relation: a #GRelation.
+@relation:
<!-- ##### STRUCT GTuples ##### -->
<para>
-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().
+
</para>
@len:
<!-- ##### FUNCTION g_tuples_destroy ##### -->
<para>
-Frees the records which were returned by g_relation_select().
-This should always be called after g_relation_select() when you are
-finished with the records.
-The records are not removed from the #GRelation.
+
</para>
-@tuples: the tuple data to free.
+@tuples:
<!-- ##### FUNCTION g_tuples_index ##### -->
<para>
-Gets a field from the records returned by g_relation_select().
-It returns the given field of the record at the given index.
-The returned value should not be changed.
+
</para>
-@tuples: the tuple data, returned by g_relation_select().
-@index: the index of the record.
-@field: the field to return.
-@Returns: the field of the record.
+@tuples:
+@index:
+@field:
+@Returns:
Lexical Scanner
<!-- ##### SECTION Short_Description ##### -->
-a general purpose lexical scanner.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-The #GScanner and its associated functions provide a general purpose
-lexical scanner.
-</para>
-<para>
-FIXME: really needs an example and more detail, but I don't completely
-understand it myself. Look at gtkrc.c for some code using the scanner.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GScanner ##### -->
<para>
-The data structure representing a lexical scanner.
-</para>
-<para>
-You should set input_name after creating the scanner, since it is used
-by the default message handler when displaying warnings and errors.
-If you are scanning a file, the file name would be a good choice.
-</para>
-<para>
-The <structfield>user_data</structfield> and
-<structfield>derived_data</structfield> fields are not used.
-If you need to associate extra data with the scanner you can place them here.
-</para>
-<para>
-If you want to use your own message handler you can set the
-<structfield>msg_handler</structfield> field. The type of the message
-handler function is declared by #GScannerMsgFunc.
+
</para>
@user_data:
<!-- ##### FUNCTION g_scanner_new ##### -->
<para>
-Creates a new #GScanner.
-The @config_templ structure specifies the initial settings of the scanner,
-which are copied into the #GScanner <structfield>config</structfield> field.
-If you pass NULL then the default settings are used.
-(See g_scanner_config_template in gscanner.c for the defaults.)
+
</para>
-@config_templ: the initial scanner settings.
-@Returns: the new #GScanner.
+@config_templ:
+@Returns:
<!-- ##### STRUCT GScannerConfig ##### -->
<para>
-Specifies the #GScanner settings.
-</para>
-<para>
-<structfield>cset_skip_characters</structfield> specifies which characters
-should be skipped by the scanner (the default is the whitespace characters:
-space, tab, carriage-return and line-feed).
-</para>
-<para>
-<structfield>cset_identifier_first</structfield> specifies the characters
-which can start identifiers.
-(the default is #G_CSET_a_2_z, "_", and #G_CSET_A_2_Z).
-</para>
-<para>
-<structfield>cset_identifier_nth</structfield> specifies the characters
-which can be used in identifiers, after the first character.
-The default is #G_CSET_a_2_z, "_0123456789", #G_CSET_A_2_Z, #G_CSET_LATINS,
-#G_CSET_LATINC.
-</para>
-<para>
-<structfield>cpair_comment_single</structfield> specifies the characters
-at the start and end of single-line comments. The default is "#\n" which
-means that single-line comments start with a '#' and continue until a '\n'
-(end of line).
-</para>
-<para>
-<structfield>case_sensitive</structfield> specifies if symbols are
-case sensitive.
-</para>
-<para>
-The rest of the fields are flags which turn features on or off.
-FIXME: should describe these.
+
</para>
@cset_skip_characters:
<!-- ##### FUNCTION g_scanner_input_file ##### -->
<para>
-Prepares to scan a file.
+
</para>
-@scanner: a #GScanner.
-@input_fd: a file descriptor.
+@scanner:
+@input_fd:
<!-- ##### FUNCTION g_scanner_sync_file_offset ##### -->
<!-- ##### FUNCTION g_scanner_stat_mode ##### -->
<para>
-Gets the file attributes.
-This is the <structfield>st_mode</structfield> field from the
-<structname>stat</structname> structure. See the <function>stat()</function>
-documentation.
+
</para>
-@filename: the file name.
-@Returns: the file attributes.
+@filename:
+@Returns:
<!-- ##### FUNCTION g_scanner_input_text ##### -->
<para>
-Prepares to scan a text buffer.
+
</para>
-@scanner: a #GScanner.
-@text: the text buffer to scan.
-@text_len: the length of the text buffer.
+@scanner:
+@text:
+@text_len:
<!-- ##### FUNCTION g_scanner_peek_next_token ##### -->
<para>
-Gets the next token, without removing it from the input stream.
-The token data is placed in the
-<structfield>next_token</structfield>,
-<structfield>next_value</structfield>,
-<structfield>next_line</structfield>, and
-<structfield>next_position</structfield> fields of the #GScanner structure.
+
</para>
-@scanner: a #GScanner.
-@Returns: the type of the token.
+@scanner:
+@Returns:
<!-- ##### FUNCTION g_scanner_get_next_token ##### -->
<para>
-Gets the next token, removing it from the input stream.
-The token data is placed in the
-<structfield>token</structfield>,
-<structfield>value</structfield>,
-<structfield>line</structfield>, and
-<structfield>position</structfield> fields of the #GScanner structure.
+
</para>
-@scanner: a #GScanner.
-@Returns: the type of the token.
+@scanner:
+@Returns:
<!-- ##### FUNCTION g_scanner_cur_line ##### -->
<para>
-Gets the current line in the input stream (counting from 1).
+
</para>
-@scanner: a #GScanner.
-@Returns: the current line.
+@scanner:
+@Returns:
<!-- ##### FUNCTION g_scanner_cur_position ##### -->
<para>
-Gets the current position in the current line (counting from 0).
+
</para>
-@scanner: a #GScanner.
-@Returns: the current position on the line.
+@scanner:
+@Returns:
<!-- ##### FUNCTION g_scanner_cur_token ##### -->
<para>
-Gets the current token type.
-This is simply the <structfield>token</structfield> field in the #GScanner
-structure.
+
</para>
-@scanner: a #GScanner.
-@Returns: the current token type.
+@scanner:
+@Returns:
<!-- ##### FUNCTION g_scanner_cur_value ##### -->
<para>
-Gets the current token value.
-This is simply the <structfield>value</structfield> field in the #GScanner
-structure.
+
</para>
-@scanner: a #GScanner.
-@Returns: the current token value.
+@scanner:
+@Returns:
<!-- ##### FUNCTION g_scanner_eof ##### -->
<para>
-Returns TRUE if the scanner has reached the end of the file or text buffer.
+
</para>
-@scanner: a #GScanner.
-@Returns: TRUE if the scanner has reached the end of the file or text buffer.
+@scanner:
+@Returns:
<!-- ##### FUNCTION g_scanner_set_scope ##### -->
<para>
-Sets the current scope.
+
</para>
-@scanner: a #GScanner.
-@scope_id: the new scope id.
-@Returns: the old scope id.
+@scanner:
+@scope_id:
+@Returns:
<!-- ##### FUNCTION g_scanner_scope_add_symbol ##### -->
<para>
-Adds a symbol to the given scope.
+
</para>
-@scanner: a #GScanner.
-@scope_id: the scope id.
-@symbol: the symbol to add.
-@value: the value of the symbol.
+@scanner:
+@scope_id:
+@symbol:
+@value:
<!-- ##### FUNCTION g_scanner_scope_foreach_symbol ##### -->
@scope_id:
@func:
@user_data:
-<!-- # Unused Parameters # -->
-@func_data:
<!-- ##### FUNCTION g_scanner_scope_lookup_symbol ##### -->
<!-- ##### FUNCTION g_scanner_warn ##### -->
<para>
-Outputs a warning message, via the #GScanner message handler.
+
</para>
-@scanner: a #GScanner.
-@format: the message format. See the <function>printf()</function>
-documentation.
-@Varargs: the parameters to insert into the format string.
+@scanner:
+@format:
+@Varargs:
<!-- ##### FUNCTION g_scanner_error ##### -->
<para>
-Outputs an error message, via the #GScanner message handler.
+
</para>
-@scanner: a #GScanner.
-@format: the message format. See the <function>printf()</function>
-documentation.
-@Varargs: the parameters to insert into the format string.
+@scanner:
+@format:
+@Varargs:
<!-- ##### FUNCTION g_scanner_unexp_token ##### -->
<para>
-Outputs a message resulting from an unexpected token in the input stream.
-FIXME: I don't understand the arguments here.
+
</para>
-@scanner: a #GScanner.
-@expected_token: the expected token.
-@identifier_spec: a string describing the expected type of identifier,
-or NULL to use the default "identifier" string.
-@symbol_spec: a string describing the expected type of identifier,
-or NULL to use the default "symbol" string.
+@scanner:
+@expected_token:
+@identifier_spec:
+@symbol_spec:
@symbol_name:
-@message: a message string to output at the end of the warning/error, or NULL.
-@is_error: if TRUE it is output as an error. If False it is output as a
-warning.
+@message:
+@is_error:
<!-- ##### USER_FUNCTION GScannerMsgFunc ##### -->
<!-- ##### FUNCTION g_scanner_destroy ##### -->
<para>
-Frees all memory used by the #GScanner.
+
</para>
-@scanner: a #GScanner.
+@scanner:
<!-- ##### ENUM GTokenType ##### -->
<para>
-The possible types of token returned from each g_scanner_get_next_token() call.
+
</para>
@G_TOKEN_EOF:
@G_TOKEN_LEFT_PAREN:
-@G_TOKEN_RIGHT_PAREN:
@G_TOKEN_LEFT_CURLY:
@G_TOKEN_RIGHT_CURLY:
<!-- ##### UNION GTokenValue ##### -->
<para>
-A union holding the value of the token.
+
</para>
<!-- ##### ENUM GErrorType ##### -->
<para>
-The possible errors, used in the <structfield>v_error</structfield> field
-of #GTokenValue, when the token is a G_TOKEN_ERROR.
+
</para>
@G_ERR_UNKNOWN:
<!-- ##### MACRO G_CSET_a_2_z ##### -->
<para>
-The set of lower-case ASCII alphabet characters.
-Used for specifying valid identifier characters in #GScannerConfig.
+
</para>
<!-- ##### MACRO G_CSET_A_2_Z ##### -->
<para>
-The set of upper-case ASCII alphabet characters.
-Used for specifying valid identifier characters in #GScannerConfig.
+
+</para>
+
+
+
+<!-- ##### MACRO G_CSET_DIGITS ##### -->
+<para>
+
</para>
<!-- ##### MACRO G_CSET_LATINC ##### -->
<para>
-Part of the set of extended characters in the Latin character sets.
-FIXME: lower case?
-Used for specifying valid identifier characters in #GScannerConfig.
+
</para>
<!-- ##### MACRO G_CSET_LATINS ##### -->
<para>
-Part of the set of extended characters in the Latin character sets.
-FIXME: upper case?
-Used for specifying valid identifier characters in #GScannerConfig.
+
</para>
<!-- ##### MACRO g_scanner_add_symbol ##### -->
<para>
-Adds a symbol to the default scope.
-Deprecated in favour of g_scanner_scope_add_symbol().
+
</para>
-@scanner: a #GScanner.
-@symbol: the symbol to add.
-@value: the value of the symbol.
+@scanner:
+@symbol:
+@value:
<!-- ##### MACRO g_scanner_remove_symbol ##### -->
<para>
-Removes a symbol from the default scope.
-Deprecated in favour of g_scanner_scope_remove_symbol().
+
</para>
-@scanner: a #GScanner.
-@symbol: the symbol to remove.
+@scanner:
+@symbol:
<!-- ##### MACRO g_scanner_foreach_symbol ##### -->
<para>
-Calls a function for each symbol in the default scope.
-Deprecated in favour of g_scanner_scope_foreach_symbol().
+
</para>
-@scanner: a #GScanner.
-@func: the function to call with each symbol.
-@data: data to pass to the function.
+@scanner:
+@func:
+@data:
String Chunks
<!-- ##### SECTION Short_Description ##### -->
-efficient storage of groups of strings.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-String chunks are used to store groups of strings.
-Memory is allocated in blocks, and as strings are added to the #GStringChunk
-they are copied into the next free position in a block. When a block is
-full a new block is allocated.
-</para>
-<para>
-When storing a large number of strings, string chunks are more efficient
-than using g_strdup() since fewer calls to <function>malloc()</function>
-are needed, and less memory is wasted in memory allocation overheads.
-</para>
-<para>
-By adding strings with g_string_chunk_insert_const() it is also possible
-to remove duplicates.
-</para>
-<para>
-To create a new #GStringChunk use g_string_chunk_new().
-</para>
-<para>
-To add strings to a #GStringChunk use g_string_chunk_insert().
-</para>
-<para>
-To add strings to a #GStringChunk, but without duplicating strings which are
-already in the #GStringChunk, use g_string_chunk_insert_const().
-</para>
-<para>
-To free the entire #GStringChunk use g_string_chunk_free().
-It is not possible to free individual strings.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GStringChunk ##### -->
<para>
-An opaque data structure representing String Chunks.
-It should only be accessed by using the following functions.
+
</para>
<!-- ##### FUNCTION g_string_chunk_new ##### -->
<para>
-Creates a new #GStringChunk.
+
</para>
-@size: the default size of the blocks of memory which are allocated to store
-the strings. If a particular string is larger than this default size, a larger
-block of memory will be allocated for it.
-@Returns: a new #GStringChunk.
+@size:
+@Returns:
<!-- ##### FUNCTION g_string_chunk_insert ##### -->
<para>
-Adds a copy of @string to the #GStringChunk.
-It returns a pointer to the new copy of the string in the #GStringChunk.
-The characters in the string can be changed, if necessary, though you
-should not change anything after the end of the string.
-</para>
-<para>
-Unlike g_string_chunk_insert_const(), this function does not check for
-duplicates. Also strings added with g_string_chunk_insert() will not be
-searched by g_string_chunk_insert_const() when looking for duplicates.
+
</para>
-@chunk: a #GStringChunk.
-@string: the string to add.
-@Returns: a pointer to the copy of @string within the #GStringChunk.
+@chunk:
+@string:
+@Returns:
<!-- ##### FUNCTION g_string_chunk_insert_const ##### -->
<para>
-Adds a copy of @string to the #GStringChunk, unless the same string has
-already been added to the #GStringChunk with g_string_chunk_insert_const().
-</para>
-<para>
-This function is useful if you need to copy a large number of strings
-but do not want to waste space storing duplicates. But you must remember
-that there may be several pointers to the same string, and so any changes
-made to the strings should be done very carefully.
-</para>
-<para>
-Note that g_string_chunk_insert_const() will not return a pointer to a string
-added with g_string_chunk_insert(), even if they do match.
+
</para>
-@chunk: a #GStringChunk.
-@string: the string to add.
-@Returns: a pointer to the new or existing copy of @string within the
-#GStringChunk.
+@chunk:
+@string:
+@Returns:
<!-- ##### FUNCTION g_string_chunk_free ##### -->
<para>
-Frees all memory allocated by the #GStringChunk.
-After calling g_string_chunk_free() it is not safe to
-access any of the strings which were contained within it.
+
</para>
-@chunk: a #GStringChunk.
+@chunk:
String Utility Functions
<!-- ##### SECTION Short_Description ##### -->
-various string-related functions.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-This section describes a number of utility functions for creating,
-duplicating, and manipulating strings.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### FUNCTION g_strdup ##### -->
<para>
-Duplicates a string.
-The returned string should be freed when no longer needed.
+
</para>
-@str: the string to duplicate.
-@Returns: a newly-allocated copy of @str.
+@str:
+@Returns:
<!-- ##### FUNCTION g_strndup ##### -->
<para>
-Duplicates the first @n characters of a string, returning a newly-allocated
-buffer @n + 1 characters long which will always be null-terminated.
-If @str is less than @n characters long the buffer is padded with nulls.
-The returned value should be freed when no longer needed.
+
</para>
-@str: the string to duplicate part of.
-@n: the maximum number of characters to copy from @str.
-@Returns: a newly-allocated buffer containing the first @n characters of @str,
-null-terminated.
+@str:
+@n:
+@Returns:
<!-- ##### FUNCTION g_strnfill ##### -->
<para>
-Creates a new string @length characters long filled with @fill_char.
-The returned string should be freed when no longer needed.
+
</para>
-@length: the length of the new string.
-@fill_char: the character to fill the string with.
-@Returns: a newly-allocated string filled the @fill_char.
+@length:
+@fill_char:
+@Returns:
-<!-- ##### FUNCTION g_strdup_printf ##### -->
+<!-- ##### FUNCTION g_strlcpy ##### -->
<para>
-Similar to the standard C <function>sprintf()</function> function
-but safer, since it calculates the maximum space required and allocates
-memory to hold the result.
-The returned string should be freed when no longer needed.
+
</para>
-@format: the standard <function>sprintf()</function> format string.
-@Varargs: the parameters to insert into the format string.
-@Returns: a newly-allocated string holding the result.
+@dest:
+@src:
+@dest_size:
+@Returns:
-<!-- ##### FUNCTION g_strdup_vprintf ##### -->
+<!-- ##### FUNCTION g_strlcat ##### -->
<para>
-Similar to the standard C <function>vsprintf()</function> function
-but safer, since it calculates the maximum space required and allocates
-memory to hold the result.
-The returned string should be freed when no longer needed.
+
</para>
-@format: the standard <function>sprintf()</function> format string.
-@args: the list of parameters to insert into the format string.
-@Returns: a newly-allocated string holding the result.
+@dest:
+@src:
+@dest_size:
+@Returns:
-<!-- ##### FUNCTION g_snprintf ##### -->
+<!-- ##### FUNCTION g_strdup_printf ##### -->
<para>
-A safer form of the standard <function>sprintf()</function> function.
-The output is guaranteed to not exceed @n characters (including the
-terminating NULL character), so it is easy to ensure that a buffer overflow
-cannot occur.
+
</para>
+
+@format:
+@Varargs:
+@Returns:
+
+
+<!-- ##### FUNCTION g_strdup_vprintf ##### -->
<para>
-See also g_strdup_printf().
+
</para>
-<note>
+
+@format:
+@args:
+@Returns:
+
+
+<!-- ##### FUNCTION g_snprintf ##### -->
<para>
-In versions of GLib prior to 1.2.3, this function may return -1 if the output
-was truncated, and the truncated string may not be NULL-terminated.
+
</para>
-</note>
-@string: the buffer to hold the output.
-@n: the maximum number of characters to produce (including the terminating null
-character).
-@format: the format string. See the <function>sprintf()</function>
-documentation.
-@Varargs: the arguments to insert in the output.
-@Returns: the length of the output string.
+@string:
+@n:
+@format:
+@Varargs:
+@Returns:
<!-- ##### FUNCTION g_vsnprintf ##### -->
<para>
-A safer form of the standard <function>vsprintf()</function> function.
-The output is guaranteed to not exceed @n characters (including the
-terminating NULL character), so it is easy to ensure that a buffer overflow
-cannot occur.
-</para>
-<para>
-See also g_strdup_vprintf().
-</para>
-<note>
-<para>
-In versions of GLib prior to 1.2.3, this function may return -1 if the output
-was truncated, and the truncated string may not be NULL-terminated.
+
</para>
-</note>
-@string: the buffer to hold the output.
-@n: the maximum number of characters to produce (including the terminating null
-character).
-@format: the format string. See the <function>sprintf()</function>
-documentation.
-@args: the list of arguments to insert in the output.
-@Returns: the length of the output string.
+@string:
+@n:
+@format:
+@args:
+@Returns:
<!-- ##### FUNCTION g_printf_string_upper_bound ##### -->
<para>
-Calculates the maximum space needed to store the output of the
-<function>sprintf()</function> function.
+
</para>
-@format: the format string. See the <function>printf()</function>
-documentation.
-@args: the parameters to be inserted into the format string.
-@Returns: the maximum space needed to store the formatted string.
+@format:
+@args:
+@Returns:
<!-- ##### FUNCTION g_strup ##### -->
<para>
-Converts a string to upper case.
+
</para>
-@string: the string to convert.
+@string:
+@Returns:
<!-- ##### FUNCTION g_strdown ##### -->
<para>
-Converts a string to lower case.
+
</para>
-@string: the string to convert.
+@string:
+@Returns:
<!-- ##### FUNCTION g_strcasecmp ##### -->
<para>
-A case-insensitive string comparison, corresponding to the standard
-<function>strcasecmp()</function> function on platforms which support it.
+
</para>
-@s1: a string.
-@s2: a string to compare with @s1.
-@Returns: 0 if the strings match, a negative value if @s1 < @s2, or a positive
-value if @s1 > @s2.
+@s1:
+@s2:
+@Returns:
<!-- ##### FUNCTION g_strncasecmp ##### -->
<para>
-A case-insensitive string comparison, corresponding to the standard
-<function>strncasecmp()</function> function on platforms which support it.
-It is similar to g_strcasecmp() except it only compares the first @n characters
-of the strings.
+
</para>
-@s1: a string.
-@s2: a string to compare with @s1.
-@n: the maximum number of characters to compare.
-@Returns: 0 if the strings match, a negative value if @s1 < @s2, or a positive
-value if @s1 > @s2.
+@s1:
+@s2:
+@n:
+@Returns:
<!-- ##### FUNCTION g_strreverse ##### -->
<para>
-Reverses all of the characters in a string.
-For example, g_strreverse ("abcdef") would be "fedcba".
+
</para>
-@string: the string to reverse.
+@string:
+@Returns:
<!-- ##### FUNCTION g_strtod ##### -->
<para>
-Converts a string to a gdouble value.
-It calls the standard <function>strtod()</function> function
-to handle the conversion, but if the string is not completely converted
-it attempts the conversion again in the "C" locale, and returns the best
-match.
+
</para>
-@nptr: the string to convert to a numeric value.
-@endptr: if non-NULL, it returns the character after the last character used
-in the conversion.
-@Returns: the gdouble value.
+@nptr:
+@endptr:
+@Returns:
<!-- ##### FUNCTION g_strchug ##### -->
<para>
-Removes leading whitespace from a string, by moving the rest of the
-characters forward.
+
</para>
-@string: a string to remove the leading whitespace from.
-@Returns: @string.
+@string:
+@Returns:
<!-- ##### FUNCTION g_strchomp ##### -->
<para>
-Removes trailing whitespace from a string.
+
</para>
-@string: a string to remove the trailing whitespace from.
-@Returns: @string.
+@string:
+@Returns:
<!-- ##### MACRO g_strstrip ##### -->
<para>
-Removes leading and trailing whitespace from a string.
+
</para>
-@string: a string to remove the leading and trailing whitespace from.
+@string:
<!-- ##### FUNCTION g_strdelimit ##### -->
<para>
-Converts any delimiter characters in @string to @new_delimiter.
-Any characters in @string which are found in @delimiters are changed
-to the @new_delimiter character.
+
</para>
-@string: the string to convert.
-@delimiters: a string containing the current delimiters, or NULL to use the
-standard delimiters defined in #G_STR_DELIMITERS.
-@new_delimiter: the new delimiter character.
+@string:
+@delimiters:
+@new_delimiter:
@Returns:
<!-- ##### MACRO G_STR_DELIMITERS ##### -->
<para>
-The standard delimiters, used in #g_strdelimit.
+
</para>
<!-- ##### FUNCTION g_strescape ##### -->
<para>
-Escapes all backslash characters, '\' in a string, by inserting a second '\'.
+
+</para>
+
+@source:
+@exceptions:
+@Returns:
+
+
+<!-- ##### FUNCTION g_strcompress ##### -->
+<para>
+
</para>
-@string: a string to escape the backslashes in.
-@Returns: a newly allocated copy of @string, with all backslash characters
-escaped using a second backslash.
+@source:
+@Returns:
+
+
+<!-- ##### FUNCTION g_strcanon ##### -->
+<para>
+
+</para>
+
+@string:
+@valid_chars:
+@subsitutor:
+@Returns:
<!-- ##### FUNCTION g_strsplit ##### -->
<para>
-Splits a string into a maximum of @max_tokens pieces, using the given
-@delimiter. If @max_tokens is reached, the final string in the returned
-string array contains the remainder of @string.
+
</para>
-@string: a string to split.
-@delimiter: a string which specifies the places at which to split the string.
-The delimiter is not included in any of the resulting strings, unless
-max_tokens is reached.
-@max_tokens: the maximum number of strings to split @string into. If this is
-less than 1, the string is split completely.
-@Returns: a newly-allocated array of strings. Use g_strfreev() to free it.
+@string:
+@delimiter:
+@max_tokens:
+@Returns:
<!-- ##### FUNCTION g_strfreev ##### -->
<para>
-Frees a NULL-terminated array of strings, and the array itself.
+
</para>
-@str_array: a NULL-terminated array of strings to free.
+@str_array:
<!-- ##### FUNCTION g_strconcat ##### -->
<para>
-Concatenates all of the given strings into one long string.
-The returned string should be freed when no longer needed.
+
</para>
-@string1: The first string to add, which must not be NULL.
-@Varargs: a NULL-terminated list of strings to append to the string.
-@Returns: a newly-allocated string containing all the string arguments.
+@string1:
+@Varargs:
+@Returns:
<!-- ##### FUNCTION g_strjoin ##### -->
<para>
-Joins a number of strings together to form one long string, with the optional
-@separator inserted between each of them.
+
</para>
-@separator: a string to insert between each of the strings, or NULL.
-@Varargs: a NULL-terminated list of strings to join.
-@Returns: a newly-allocated string containing all of the strings joined
-together, with @separator between them.
+@separator:
+@Varargs:
+@Returns:
<!-- ##### FUNCTION g_strjoinv ##### -->
<para>
-Joins a number of strings together to form one long string, with the optional
-@separator inserted between each of them.
+
</para>
-@separator: a string to insert between each of the strings, or NULL.
-@str_array: a NULL-terminated array of strings to join.
-@Returns: a newly-allocated string containing all of the strings joined
-together, with @separator between them.
+@separator:
+@str_array:
+@Returns:
<!-- ##### FUNCTION g_strerror ##### -->
<para>
-Returns a string corresponding to the given error code, e.g. "no such process".
-This function is included since not all platforms support the
-<function>strerror()</function> function.
+
</para>
-@errnum: the system error number. See the standard C %errno
-documentation.
-@Returns: a string describing the error code.
-If the error code is unknown, it returns "unknown error (<code>)".
-The string can only be used until the next call to g_strerror.
+@errnum:
+@Returns:
<!-- ##### FUNCTION g_strsignal ##### -->
<para>
-Returns a string describing the given signal, e.g. "Segmentation fault".
-This function is included since not all platforms support the
-<function>strsignal()</function> function.
+
</para>
-@signum: the signal number. See the <literal>signal</literal>
-documentation.
-@Returns: a string describing the signal.
-If the signal is unknown, it returns "unknown signal (<signum>)".
-The string can only be used until the next call to g_strsignal.
+@signum:
+@Returns:
Strings
<!-- ##### SECTION Short_Description ##### -->
-text buffers which grow automatically as text is added.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-A #GString is similar to a standard C string, except that it grows
-automatically as text is appended or inserted.
-</para>
-<para>
-The space allocated for the string is always a power of two, so as the
-string grows it will occupy 2, 4, 8, 16, 32, 64, 128 etc. characters.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GString ##### -->
<para>
-The #GString struct contains the public fields of a #GString.
-The <structfield>str</structfield> field points to the character data.
-It may move as text is added.
-The <structfield>len</structfield> field contains the length of the string,
-not including the terminating null character.
-</para>
-<para>
-The str field is zero-terminated and so can be used as an ordinary C
-string. But it may be moved when text is appended or inserted into the
-string.
+
</para>
@str:
<!-- ##### FUNCTION g_string_new ##### -->
<para>
-Creates a new #GString, initialized with the given string.
+
</para>
-@init: the initial text to copy into the string.
-@Returns: the new #GString.
+@init:
+@Returns:
<!-- ##### FUNCTION g_string_sized_new ##### -->
<para>
-Creates a new GString, with enough space for @dfl_size characters.
-This is useful if you are going to add a lot of text to the string and
-don't want it to be reallocated too often.
+
</para>
-@dfl_size: the default size of the space allocated to hold the string.
-@Returns: the new #GString.
+@dfl_size:
+@Returns:
<!-- ##### FUNCTION g_string_assign ##### -->
<para>
-Copies the characters from one #GString into another, destroying any previous
-contents. It is rather like the standard strcpy() function, except that
-you do not have to worry about having enough space to copy the string.
+
</para>
-@lval: the destination #GString. Its current contents are destroyed.
-@rval: the source #GString.
-@Returns: the destination #GString.
+@string:
+@rval:
+@Returns:
<!-- ##### FUNCTION g_string_sprintf ##### -->
<para>
-Writes a formatted string into a #GString.
-This is similar to the standard <function>sprintf()</function> function,
-except that the GString buffer automatically expands to contain the results.
-The previous contents of the GString are destroyed.
+
</para>
-@string: a #GString.
-@format: the string format. See the <function>sprintf()</function>
-documentation.
-@Varargs: the parameters to insert into the format string.
+@string:
+@format:
+@Varargs:
<!-- ##### FUNCTION g_string_sprintfa ##### -->
<para>
-Appends a formatted string onto the end of a #GString.
-This function is is similar to g_string_sprintf() except that
-the text is appended to the GString.
+
</para>
-@string: a #GString.
-@format: the string format. See the <function>sprintf()</function>
-documentation.
-@Varargs: the parameters to insert into the format string.
+@string:
+@format:
+@Varargs:
<!-- ##### FUNCTION g_string_append ##### -->
<para>
-Adds a string onto the end of a #GString, expanding it if necessary.
+
</para>
-@string: a #GString.
-@val: the string to append onto the end of the #GString.
-@Returns: the #GString.
+@string:
+@val:
+@Returns:
<!-- ##### FUNCTION g_string_append_c ##### -->
<para>
-Adds a character onto the end of a #GString, expanding it if necessary.
+
</para>
-@string: a #GString.
-@c: the character to append onto the end of the #GString.
-@Returns: the #GString.
+@string:
+@c:
+@Returns:
+
+
+<!-- ##### FUNCTION g_string_append_len ##### -->
+<para>
+
+</para>
+
+@string:
+@val:
+@len:
+@Returns:
<!-- ##### FUNCTION g_string_prepend ##### -->
<para>
-Adds a string on to the start of a #GString, expanding it if necessary.
+
</para>
-@string: a #GString.
-@val: the string to prepend on the start of the #GString.
-@Returns: the #GString.
+@string:
+@val:
+@Returns:
<!-- ##### FUNCTION g_string_prepend_c ##### -->
<para>
-Adds a character onto the start of a #GString, expanding it if necessary.
+
</para>
-@string: a #GString.
-@c: the character to prepend on the start of the #GString.
-@Returns: the #GString.
+@string:
+@c:
+@Returns:
+
+
+<!-- ##### FUNCTION g_string_prepend_len ##### -->
+<para>
+
+</para>
+
+@string:
+@val:
+@len:
+@Returns:
<!-- ##### FUNCTION g_string_insert ##### -->
<para>
-Inserts a copy of a string into a #GString, expanding it if necessary.
+
</para>
-@string: a #GString.
-@pos: the position to insert the copy of the string.
-@val: the string to insert.
-@Returns: the #GString.
+@string:
+@pos:
+@val:
+@Returns:
<!-- ##### FUNCTION g_string_insert_c ##### -->
<para>
-Inserts a character into a #GString, expanding it if necessary.
+
</para>
-@string: a #GString.
-@pos: the position to insert the character.
-@c: the character to insert.
-@Returns: the #GString.
+@string:
+@pos:
+@c:
+@Returns:
+
+
+<!-- ##### FUNCTION g_string_insert_len ##### -->
+<para>
+
+</para>
+
+@string:
+@pos:
+@val:
+@len:
+@Returns:
<!-- ##### FUNCTION g_string_erase ##### -->
<para>
-Removes @len characters from a #GString, starting at position @pos.
-The rest of the #GString is shifted down to fill the gap.
+
</para>
-@string: a #GString.
-@pos: the position of the characters to remove.
-@len: the number of characters to remove.
-@Returns: the #GString.
+@string:
+@pos:
+@len:
+@Returns:
<!-- ##### FUNCTION g_string_truncate ##### -->
<para>
-Cuts off the end of the GString, leaving the first @len characters.
+
</para>
-@string: a #GString.
-@len: the new size of the #GString.
-@Returns: the #GString.
+@string:
+@len:
+@Returns:
<!-- ##### FUNCTION g_string_free ##### -->
<para>
-Frees the memory allocated for the #GString.
-If free_segment is TRUE it also frees the character data.
+
</para>
-@string: a #GString.
-@free_segment: if TRUE the actual character data is freed as well.
+@string:
+@free_segment:
+@Returns:
<!-- ##### FUNCTION g_string_up ##### -->
<para>
-Converts a #GString to upper case.
+
</para>
-@string: a #GString.
-@Returns: the #GString.
+@string:
+@Returns:
<!-- ##### FUNCTION g_string_down ##### -->
<para>
-Converts a #GString to lower case.
+
+</para>
+
+@string:
+@Returns:
+
+
+<!-- ##### FUNCTION g_string_hash ##### -->
+<para>
+
+</para>
+
+@str:
+@Returns:
+
+
+<!-- ##### FUNCTION g_string_equal ##### -->
+<para>
+
</para>
-@string: a #GString.
-@Returns: the #GString.
+@v:
+@v2:
+@Returns:
<!-- ##### SECTION Title ##### -->
-
Threads
<!-- ##### SECTION Short_Description ##### -->
-thread abstraction; including mutexes, conditions and thread private data.
<!-- ##### SECTION Long_Description ##### -->
-
<para>
-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 Heisenbugs) might happen,
-when the program is not carefully designed. Especially bad is, that due
-to the concurrent nature of threads no assumptions on the order of
-execution of different threads can be done unless explictly forced by
-the programmer through synchronization primitives.
-</para>
-<para>
-The aim of the thread related functions in GLib is to provide a
-portable means for writing multithread safe software. There are
-primitives for mutexes to protect the access to portions of memory
-(#GMutex, #GStaticMutex, #G_LOCK_DEFINE and friends), there are
-primitives for condition variables to allow synchronization of threads
-(#GCond) and finally there are primitives for thread-private data,
-that every thread has a private instance of (#GPrivate,
-#GStaticPrivate).
</para>
-<para>
-Currently there is only as much thread support included in GLib as is
-necessary to make GLib itself multithread safe. Version 1.4 of GLib
-will contain full thread support. For now the most portable way to
-create threads is to require the macro #G_THREADS_IMPL_POSIX to be
-defined and use POSIX threads then. This will work on almost all
-platforms (except most notably Solaris and DCE threads.).
-</para>
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
-<!-- ##### MACRO G_THREADS_ENABLED ##### -->
+<!-- ##### MACRO G_THREADS_ENABLED ##### -->
<para>
-This macro is defined, if GLib was compiled with thread support. This
-does not necessarily mean, that there is a thread implementation
-available, but the infrastructure is in place and once you provide a
-thread implementation to g_thread_init(), GLib will be multithread
-safe. It isn't and can't be, if #G_THREADS_ENABLED is not defined.
+
</para>
<!-- ##### MACRO G_THREADS_IMPL_POSIX ##### -->
-
<para>
-This macro is defined, if POSIX style threads are used.
+
</para>
<!-- ##### MACRO G_THREADS_IMPL_SOLARIS ##### -->
-
<para>
-This macro is defined, if the SOLARIS thread system is used.
+
</para>
<!-- ##### MACRO G_THREADS_IMPL_NONE ##### -->
-
<para>
-This macro is defined, if no thread implementation is used. You can
-however provide one to g_thread_init() to make GLib multithread safe.
+
</para>
-<!-- ##### STRUCT GThreadFunctions ##### -->
+<!-- ##### MACRO G_THREAD_ERROR ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### ENUM GThreadError ##### -->
<para>
-This function table is used by g_thread_init() to initialize the
-thread system. The functions in that table are directly used by their
-g_* prepended counterparts, that are described here, e.g. if you call
-g_mutex_new() then mutex_new() from the table provided to
-g_thread_init() will be called.
+
</para>
-<note>
+@G_THREAD_ERROR_AGAIN:
+
+<!-- ##### STRUCT GThreadFunctions ##### -->
<para>
-This struct should only be used, if you know, what you are doing.
+
</para>
-</note>
@mutex_new:
@mutex_lock:
@private_new:
@private_get:
@private_set:
+@thread_create:
+@thread_yield:
+@thread_join:
+@thread_exit:
+@thread_set_priority:
+@thread_self:
<!-- ##### FUNCTION g_thread_init ##### -->
-
-<para>
-Before you use a thread related function in GLib, you should
-initialize the thread system. This is done by calling
-g_thread_init(). Most of the time you will only have to call
-g_thread_init(NULL).
-</para>
-
-<note>
-<para>
-You should only call g_thread_init() with a non-NULL parameter, if you
-really know, what you are doing.
-</para>
-</note>
-
-<note>
<para>
-g_thread_init() must not be called directly or indirectly as a
-callback from GLib.
-</para>
-</note>
-<para>
-g_thread_init() might only be called once. On the second call
-it will abort with an error. If you want to make sure, that the thread
-system is initialized, you can do that too:
</para>
-<para>
-<informalexample>
-<programlisting>
-if (!g_thread_supported ()) g_thread_init (NULL);
-</programlisting>
-</informalexample>
-</para>
+@vtable:
-<para>
-After that line either the thread system is initialized or the program
-will abort, if no thread system is available in GLib, i.e. either
-#G_THREADS_ENABLED is not defined or #G_THREADS_IMPL_NONE is defined.
-</para>
+<!-- ##### FUNCTION g_thread_supported ##### -->
<para>
-If no thread system is available and @vtable is NULL or if not all
-elements of @vtable are non-NULL, then g_thread_init() will abort.
-</para>
-<note>
-<para>
-To use g_thread_init() in your program, you have to link with the
-libraries, that the command "glib-config --libs gthread" outputs. This
-is not the case for all the other thread related functions of
-GLib. Those can be used without having to link with the thread
-libraries.
</para>
-</note>
-@vtable: a function table of type #GThreadFunctions, that provides the
-entry points to the thread system to be used.
+@Returns:
-<!-- ##### MACRO g_thread_supported ##### -->
+<!-- ##### USER_FUNCTION GThreadFunc ##### -->
<para>
-This function returns, whether the thread system is initialized or
-not.
-</para>
-<note>
-<para>
-This function is actually a macro. Apart from taking the address of it
-you can however use it as if it was a function.
</para>
-</note>
-
-@Returns: TRUE, if the thread system is initialized.
+@value:
-<!-- ##### STRUCT GMutex ##### -->
+<!-- ##### ENUM GThreadPriority ##### -->
<para>
-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:
-<example>
-<title>A function which will not work in a threaded environment</title>
-<programlisting>
- int give_me_next_number ()
- {
- static int current_number = 0;
-
- /* now do a very complicated calculation to calculate the new number,
- this might for example be a random number generator */
- current_number = calc_next_number (current_number);
- return current_number;
- }
-</programlisting>
-</example>
</para>
-<para>
-It is easy to see, that this won't work in a multithreaded
-application. There current_number must be protected against shared
-access. A first naive implementation would be:
-</para>
+@G_THREAD_PRIORITY_LOW:
+@G_THREAD_PRIORITY_NORMAL:
+@G_THREAD_PRIORITY_HIGH:
+@G_THREAD_PRIORITY_URGENT:
+<!-- ##### STRUCT GThread ##### -->
<para>
-<example>
-<title>The wrong way to write a thread-safe function</title>
-<programlisting>
- int give_me_next_number ()
- {
- static int current_number = 0;
- int ret_val;
- static GMutex * mutex = NULL;
- if (!mutex)
- mutex = g_mutex_new ();
- g_mutex_lock (mutex);
- ret_val = current_number = calc_next_number (current_number);
- g_mutex_unlock (mutex);
- return ret_val;
- }
-</programlisting>
-</example>
</para>
-<para>
-This looks like it would work, but there is a race condition while
-constructing the mutex and this code can't work reliable. So please do
-not use such constructs in your own programs. One working solution is:
-</para>
+@priority:
+@bound:
+@joinable:
+<!-- ##### FUNCTION g_thread_create ##### -->
<para>
-<example>
-<title>A correct thread-safe function</title>
-<programlisting>
- static GMutex *give_me_next_number_mutex = NULL;
- /* this function must be called before any call to give_me_next_number ()
- it must be called exactly once. */
- void init_give_me_next_number ()
- {
- g_assert (give_me_next_number_mutex == NULL);
- give_me_next_number_mutex = g_mutex_new ();
- }
+</para>
- int give_me_next_number ()
- {
- static int current_number = 0;
- int ret_val;
+@thread_func:
+@arg:
+@stack_size:
+@joinable:
+@bound:
+@priority:
+@error:
+@Returns:
- 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;
- }
-</programlisting>
-</example>
-</para>
+<!-- ##### FUNCTION g_thread_self ##### -->
<para>
-#GStaticMutex provides a simpler and safer way of doing this.
-</para>
-<para>
-A #GMutex should only be accessed via the following functions.
</para>
-<note>
+@Returns:
+
+
+<!-- ##### FUNCTION g_thread_join ##### -->
<para>
-All of the g_mutex_* functions are actually macros. Apart from taking
-the addresses of them, you can however use them as if they were functions.
+
</para>
-</note>
+@thread:
-<!-- ##### MACRO g_mutex_new ##### -->
+<!-- ##### FUNCTION g_thread_set_priority ##### -->
<para>
-Creates a new #GMutex.
-</para>
-<note>
-<para>
-This function will abort, if g_thread_init() has not been called yet.
</para>
-</note>
-
-@Returns: a new #GMutex.
+@thread:
+@priority:
-<!-- ##### MACRO g_mutex_lock ##### -->
+<!-- ##### MACRO g_thread_yield ##### -->
<para>
-Locks the #GMutex. If the #GMutex is already locked by another thread,
-the current thread will block until the #GMutex is unlocked by the
-other thread.
-</para>
-<para>
-This function can also be used, if g_thread_init() has not yet been
-called and will do nothing then.
</para>
-<note>
+
+
+<!-- ##### MACRO g_thread_exit ##### -->
<para>
-#GMutex is not guaranteed to be recursive, i.e. a thread might block,
-if it already has locked the #GMutex. It will deadlock then, of
-course.
-</para>
-</note>
-@mutex: a #GMutex.
+</para>
-<!-- ##### MACRO g_mutex_trylock ##### -->
+<!-- ##### STRUCT GMutex ##### -->
<para>
-Tries to lock the #GMutex. If the #GMutex is already locked by another
-thread, it immediately returns FALSE. Otherwise it locks the #GMutex
-and returns TRUE.
+
</para>
+
+<!-- ##### FUNCTION g_mutex_new ##### -->
<para>
-This function can also be used, if g_thread_init() has not yet been
-called and will immediately return TRUE then.
-</para>
-@mutex: a #GMutex.
-@Returns: TRUE, if the #GMutex could be locked.
+</para>
+@Returns:
-<!-- ##### MACRO g_mutex_unlock ##### -->
+<!-- ##### FUNCTION g_mutex_lock ##### -->
<para>
-Unlocks the #GMutex. If another thread is blocked in a g_mutex_lock()
-call, it will be woken and can lock the #GMutex itself. This function
-can also be used, if g_thread_init() has not yet been called and will
-do nothing then.
-</para>
-@mutex: a #GMutex.
+</para>
+@mutex:
-<!-- ##### MACRO g_mutex_free ##### -->
+<!-- ##### FUNCTION g_mutex_trylock ##### -->
<para>
-Destroys the #GMutex.
-</para>
-@mutex: a #GMutex.
+</para>
+@mutex:
+@Returns:
-<!-- ##### STRUCT GStaticMutex ##### -->
+<!-- ##### FUNCTION g_mutex_unlock ##### -->
<para>
-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 give_me_next_number() example:
+
</para>
-<para>
-<example>
-<title>Using GStaticMutex to simplify thread-safe programming</title>
-<programlisting>
- int give_me_next_number ()
- {
- static int current_number = 0;
- int ret_val;
- static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
+@mutex:
- g_static_mutex_lock (&mutex);
- ret_val = current_number = calc_next_number (current_number);
- g_static_mutex_unlock (&mutex);
- return ret_val;
- }
-</programlisting>
-</example>
-</para>
+<!-- ##### FUNCTION g_mutex_free ##### -->
<para>
-Even though #GStaticMutex is not opaque, it should only be used with
-the following functions, as it is defined differently on different
-platforms.
-</para>
-<para>All of the g_static_mutex_* functions can also be used, if
-g_thread_init() has not yet.
</para>
-<note>
+@mutex:
+
+
+<!-- ##### STRUCT GStaticMutex ##### -->
<para>
-All of the g_static_mutex_* functions are actually macros. Apart from
-taking the addresses of them, you can however use them as if they were
-functions.
+
</para>
-</note>
-@runtime_mutex:
<!-- ##### MACRO G_STATIC_MUTEX_INIT ##### -->
-
<para>
-Every #GStaticMutex must be initialized with this macro, before it can
-be used.
-</para>
-<para>
-<example>
-<title>Initializing a GStaticMutext</title>
-<programlisting>
-GStaticMutex my_mutex = G_STATIC_MUTEX_INIT;
-</programlisting>
-</example>
</para>
-<!-- ##### MACRO g_static_mutex_lock ##### -->
+<!-- ##### FUNCTION g_static_mutex_lock ##### -->
<para>
-works like g_mutex_lock(), but for a #GStaticMutex.
-</para>
-@mutex: a #GStaticMutex.
+</para>
+@mutex:
-<!-- ##### MACRO g_static_mutex_trylock ##### -->
+<!-- ##### FUNCTION g_static_mutex_trylock ##### -->
<para>
-works like g_mutex_trylock(), but for a #GStaticMutex.
-</para>
-@mutex: a #GStaticMutex.
-@Returns: TRUE, if the #GStaticMutex could be locked.
+</para>
+@mutex:
+@Returns:
-<!-- ##### MACRO g_static_mutex_unlock ##### -->
+<!-- ##### FUNCTION g_static_mutex_unlock ##### -->
<para>
-works like g_mutex_unlock(), but for a #GStaticMutex.
-</para>
-@mutex: a #GStaticMutex.
+</para>
+@mutex:
-<!-- ##### MACRO g_static_mutex_get_mutex ##### -->
+<!-- ##### FUNCTION g_static_mutex_get_mutex ##### -->
<para>
-For some operations (like g_cond_wait()) you must have a #GMutex
-instead of a #GStaticMutex. This function will return the
-corresponding #GMutex for every #GStaticMutex.
+
</para>
-@mutex: a #GStaticMutex.
-@Returns: the corresponding #GMutex.
+@mutex:
+@Returns:
<!-- ##### MACRO G_LOCK_DEFINE ##### -->
-
<para>
-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 occur, where variable
-definitions may occur 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
-give_me_next_number() example using the G_LOCK_* macros:
-</para>
-<para>
-<example>
-<title>Using the G_LOCK_* convenience macros</title>
-<programlisting>
-G_LOCK_DEFINE (current_number);
-
-int give_me_next_number ()
- {
- 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;
- }
-</programlisting>
-</example>
</para>
-@name: the name of the lock.
+@name:
<!-- ##### MACRO G_LOCK_DEFINE_STATIC ##### -->
-
<para>
-This works like #G_LOCK_DEFINE, but it creates a static object.
+
</para>
-@name: the name of the lock.
+@name:
<!-- ##### MACRO G_LOCK_EXTERN ##### -->
-
<para>
-This declares a lock, that is defined with #G_LOCK_DEFINE in another module.
+
</para>
-@name: the name of the lock.
+@name:
<!-- ##### MACRO G_LOCK ##### -->
-
<para>
-works like g_mutex_lock(), but for a lock defined with #G_LOCK_DEFINE.
+
</para>
-@name: the name of the lock.
+@name:
<!-- ##### MACRO G_TRYLOCK ##### -->
-
<para>
-works like g_mutex_trylock(), but for a lock defined with #G_LOCK_DEFINE.
+
</para>
-@name: the name of the lock.
-@Returns: TRUE, if the lock could be locked.
+@name:
<!-- ##### MACRO G_UNLOCK ##### -->
-
<para>
-works like g_mutex_unlock(), but for a lock defined with #G_LOCK_DEFINE.
-</para>
-@name: the name of the lock.
+</para>
+@name:
-<!-- ##### STRUCT GCond ##### -->
+<!-- ##### STRUCT GStaticRecMutex ##### -->
<para>
-The #GCond struct is an opaque data structure to represent a
-condition. A #GCond is an object, that threads can block on, if they
-find a certain condition to be false. If other threads change the
-state of this condition they can signal the #GCond, such that the
-waiting thread is woken up.
+
</para>
+@mutex:
+@depth:
+@owner:
+
+<!-- ##### MACRO G_STATIC_REC_MUTEX_INIT ##### -->
<para>
-<example>
-<title>Using GCond to block a thread until a condition is satisfied</title>
-<programlisting>
-GCond* data_cond = NULL; /* Must be initialized somewhere */
-GMutex* data_mutex = NULL; /* Must be initialized somewhere */
-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);
-}
+</para>
-gpointer pop_data ()
-{
- 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;
-}
-</programlisting>
-</example>
-</para>
+<!-- ##### FUNCTION g_static_rec_mutex_lock ##### -->
<para>
-Whenever a thread calls pop_data() now, it will wait until
-current_data is non-NULL, i.e. until some other thread has called
-push_data().
-</para>
-<note>
-<para>
-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 as it is not guaranteed that the waiting thread will find it
-fulfilled, even if the signaling thread left the condition
-in that state. This is because another thread can 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.
</para>
-</note>
-<para>
-A #GCond should only be accessed via the following functions.
-</para>
+@mutex:
+
-<note>
+<!-- ##### FUNCTION g_static_rec_mutex_trylock ##### -->
<para>
-All of the g_cond_* functions are actually macros. Apart from taking
-the addresses of them, you can however use them as if they were functions.
+
</para>
-</note>
+@mutex:
+@Returns:
-<!-- ##### MACRO g_cond_new ##### -->
+<!-- ##### FUNCTION g_static_rec_mutex_unlock ##### -->
<para>
-Creates a new #GCond. This function will abort, if g_thread_init()
-has not been called yet.
+
</para>
-@Returns: a new #GCond.
+@mutex:
-<!-- ##### MACRO g_cond_signal ##### -->
+<!-- ##### FUNCTION g_static_rec_mutex_lock_full ##### -->
<para>
-If threads are waiting for @cond, exactly one of them is woken up. It
-is good practice to hold the same lock as the waiting thread, while
-calling this function, though not required.
+
</para>
+@mutex:
+@depth:
+
+
+<!-- ##### FUNCTION g_static_rec_mutex_unlock_full ##### -->
<para>
-This function can also be used, if g_thread_init() has
-not yet been called and will do nothing then.
-</para>
-@cond: a #GCond.
+</para>
+@mutex:
+@Returns:
-<!-- ##### MACRO g_cond_broadcast ##### -->
+<!-- ##### STRUCT GStaticRWLock ##### -->
<para>
-If threads are waiting for @cond, all of them are woken up. It is good
-practice to lock the same mutex as the waiting threads, while calling
-this function, though not required.
+
</para>
+@mutex:
+@read_cond:
+@write_cond:
+@read_counter:
+@write:
+@want_to_write:
+
+<!-- ##### MACRO G_STATIC_RW_LOCK_INIT ##### -->
<para>
-This function can also be used, if g_thread_init() has
-not yet been called and will do nothing then.
-</para>
-@cond: a #GCond.
+</para>
-<!-- ##### MACRO g_cond_wait ##### -->
+<!-- ##### FUNCTION g_static_rw_lock_reader_lock ##### -->
<para>
-Waits until this thread is woken up on the #GCond. The #GMutex is
-unlocked before falling asleep and locked again before resuming.
+
</para>
+@lock:
+
+
+<!-- ##### FUNCTION g_static_rw_lock_reader_trylock ##### -->
<para>
-This function can also be used, if g_thread_init() has not yet been
-called and will immediately return then.
-</para>
-@cond: a #GCond.
-@mutex: the #GMutex, that is currently locked.
+</para>
+@lock:
+@Returns:
-<!-- ##### MACRO g_cond_timed_wait ##### -->
+<!-- ##### FUNCTION g_static_rw_lock_reader_unlock ##### -->
<para>
-Waits until this thread is woken up on the #GCond, but not longer than
-until the time, that is specified by @abs_time. The #GMutex is
-unlocked before falling asleep and locked again before resuming.
+
</para>
+@lock:
+
+
+<!-- ##### FUNCTION g_static_rw_lock_writer_lock ##### -->
<para>
-If @abs_time is NULL, g_cond_timed_wait() acts like g_cond_wait().
+
</para>
+@lock:
+
+
+<!-- ##### FUNCTION g_static_rw_lock_writer_trylock ##### -->
<para>
-This function can also be used, if g_thread_init() has not yet been
-called and will immediately return TRUE then.
-</para>
-@cond: a #GCond.
-@mutex: the #GMutex, that is currently locked.
-@abs_time: a #GTimeVal, determining the final time.
-@Returns: TRUE, if the thread is woken up in time.
+</para>
+@lock:
+@Returns:
-<!-- ##### MACRO g_cond_free ##### -->
+<!-- ##### FUNCTION g_static_rw_lock_writer_unlock ##### -->
<para>
-Destroys the #GCond.
+
</para>
-@cond: a #GCond.
+@lock:
-<!-- ##### STRUCT GPrivate ##### -->
+<!-- ##### FUNCTION g_static_rw_lock_free ##### -->
<para>
-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 give_me_next_number()
-example from above. Now we don't want current_number to be shared
-between the threads, but to be private to each thread. This can be
-done as follows:
-<example>
-<title>Using GPrivate for per-thread data</title>
-<programlisting>
- GPrivate* current_number_key = NULL; /* Must be initialized somewhere */
- /* with g_private_new (g_free); */
+</para>
- int give_me_next_number ()
- {
- int *current_number = g_private_get (current_number_key);
+@lock:
- 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;
- }
-</programlisting>
-</example>
-</para>
+<!-- ##### STRUCT GCond ##### -->
<para>
-Here the pointer belonging to the key current_number_key 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.
+
</para>
+
+<!-- ##### FUNCTION g_cond_new ##### -->
<para>
-The #GPrivate struct should only be accessed via the following functions.
+
</para>
-<note>
+@Returns:
+
+
+<!-- ##### FUNCTION g_cond_signal ##### -->
<para>
-All of the g_private_* functions are actually macros. Apart from taking
-the addresses of them, you can however use them as if they were functions.
+
</para>
-</note>
+@cond:
-<!-- ##### MACRO g_private_new ##### -->
+<!-- ##### FUNCTION g_cond_broadcast ##### -->
<para>
-Creates a new #GPrivate. If @destructor is non-NULL, it is a pointer
-to a destructor function. Whenever a thread ends and the corresponding
-pointer keyed to this instance of #GPrivate is non-NULL, the
-destructor is called with this pointer as the argument.
+
</para>
-<note>
+@cond:
+
+
+<!-- ##### FUNCTION g_cond_wait ##### -->
<para>
-The @destructor is working quite differently from @notify in
-g_static_private_set().
+
</para>
-</note>
-<note>
+@cond:
+@mutex:
+
+
+<!-- ##### FUNCTION g_cond_timed_wait ##### -->
<para>
-A #GPrivate can not be destroyed. Reuse it instead, if you can to
-avoid shortage.
+
</para>
-</note>
-<note>
+@cond:
+@mutex:
+@abs_time:
+@Returns:
+
+
+<!-- ##### FUNCTION g_cond_free ##### -->
<para>
-This function will abort, if g_thread_init() has not been called yet.
-</para>
-</note>
-@destructor: a function to handle the data keyed to #GPrivate, when a
-thread ends.
+</para>
+@cond:
-<!-- ##### MACRO g_private_get ##### -->
+<!-- ##### STRUCT GPrivate ##### -->
<para>
-Returns the pointer keyed to @private_key for the current thread. This
-pointer is NULL, when g_private_set() hasn't been called for the
-current @private_key and thread yet.
+
</para>
+
+<!-- ##### FUNCTION g_private_new ##### -->
<para>
-This function can also be used, if g_thread_init() has not yet been
-called and will return the value of @private_key casted to #gpointer then.
-</para>
-@private_key: a #GPrivate.
-@Returns: the corresponding pointer.
+</para>
+@destructor:
+@Returns:
-<!-- ##### MACRO g_private_set ##### -->
+<!-- ##### FUNCTION g_private_get ##### -->
<para>
-Sets the pointer keyed to @private_key for the current thread.
-</para>
-<para>
-This function can also be used, if g_thread_init() has not yet been
-called and will set @private_key to @data casted to #GPrivate* then.
</para>
-@private_key: a #GPrivate.
-@value:
-<!-- # Unused Parameters # -->
-@data: the new pointer.
-
+@private_key:
+@Returns:
-<!-- ##### STRUCT GStaticPrivate ##### -->
+<!-- ##### FUNCTION g_private_set ##### -->
<para>
-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
-give_me_next_number() example with #GStaticPrivate:
+
</para>
+@private_key:
+@data:
+
+
+<!-- ##### STRUCT GStaticPrivate ##### -->
<para>
-<example>
-<title>Using GStaticPrivate for per-thread data</title>
-<programlisting>
- int give_me_next_number ()
- {
- static GStaticPrivate current_number_key = G_STATIC_PRIVATE_INIT;
- int *current_number = g_static_private_get (&current_number_key);
- if (!current_number)
- {
- current_number = g_new (int,1);
- *current_number = 0;
- g_static_private_set (&current_number_key, current_number, g_free);
- }
- *current_number = calc_next_number (*current_number);
- return *current_number;
- }
-</programlisting>
-</example>
</para>
@index:
<!-- ##### MACRO G_STATIC_PRIVATE_INIT ##### -->
<para>
-Every #GStaticPrivate must be initialized with this macro, before it can
-be used.
-</para>
-<para>
-<informalexample>
-<programlisting>
-GStaticPrivate my_private = G_STATIC_PRIVATE_INIT;
-</programlisting>
-</informalexample>
</para>
<!-- ##### FUNCTION g_static_private_get ##### -->
<para>
-Works like g_private_get() only for a #GStaticPrivate.
+
</para>
+@private_key:
+@Returns:
+
+
+<!-- ##### FUNCTION g_static_private_get_for_thread ##### -->
<para>
-This function also works, if g_thread_init() has not yet been called.
+
</para>
-@private_key: a #GStaticPrivate.
-@Returns: the corresponding pointer.
+@private_key:
+@thread:
+@Returns:
<!-- ##### FUNCTION g_static_private_set ##### -->
<para>
-Sets the pointer keyed to @private_key for the current thread and the
-function @notify to be called with that pointer (NULL or non-NULL),
-whenever the pointer is set again or whenever the current thread ends.
-</para>
-<para>
-This function also works, if g_thread_init() has not yet been
-called. If g_thread_init() is called later, the @data keyed to
-@private_key will be inherited only by the main thread, i.e. the one that
-called g_thread_init().
</para>
-<note>
+@private_key:
+@data:
+@notify:
+
+
+<!-- ##### FUNCTION g_static_private_set_for_thread ##### -->
<para>
-The @notify is working quite differently from @destructor in
-g_private_new().
+
</para>
-</note>
-@private_key: a #GStaticPrivate.
-@data: the new pointer.
-@notify: a function to be called with the pointer, whenever the
-current thread ends or sets this pointer again.
+@private_key:
+@thread:
+@data:
+@notify:
Timers
<!-- ##### SECTION Short_Description ##### -->
-functions to time operations.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-Timers can be used to time operations, in a similar way to a stopwatch.
-Call g_timer_new () to create the timer, g_timer_start () to start it,
-g_timer_elapsed () to determine the time which has elapsed since the timer
-was started, and g_timer_stop () to stop the timer.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GTimer ##### -->
<para>
-An opaque data structure which holds the timer information.
+
</para>
<!-- ##### FUNCTION g_timer_new ##### -->
<para>
-Creates a new timer.
+
</para>
-@Returns: the new timer.
+@Returns:
<!-- ##### FUNCTION g_timer_start ##### -->
<para>
-Starts the timer.
+
</para>
-@timer: the timer.
+@timer:
<!-- ##### FUNCTION g_timer_stop ##### -->
<para>
-Stops the timer.
+
</para>
-@timer: the timer.
+@timer:
<!-- ##### FUNCTION g_timer_elapsed ##### -->
</para>
-@timer: the timer.
-@microseconds: if non-NULL, this will be set to the microseconds component
-of the elapsed time (it does not include the number of seconds elapsed).
-@Returns: the elapsed time in seconds, as a double.
+@timer:
+@microseconds:
+@Returns:
<!-- ##### FUNCTION g_timer_reset ##### -->
<para>
-Resets the elapsed time to 0, leaving the timer running.
+
</para>
-@timer: the timer.
+@timer:
<!-- ##### FUNCTION g_timer_destroy ##### -->
<para>
-Destroys the timer, freeing the memory allocated for it.
+
</para>
-@timer: the timer.
+@timer:
Balanced Binary Trees
<!-- ##### SECTION Short_Description ##### -->
-a sorted collection of key/value pairs optimised for searching
-and traversing in order.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-The #GTree structure and its associated functions provide a sorted collection
-of key/value pairs optimised for searching and traversing in order.
-</para>
-<para>
-To create a new #GTree use g_tree_new().
-</para>
-<para>
-To insert a key/value pair into a #GTree use g_tree_insert().
-</para>
-<para>
-To lookup the value corresponding to a given key, use g_tree_lookup().
-</para>
-<para>
-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().
-</para>
-<para>
-To traverse a #GTree, calling a function for each node visited in the
-traversal, use g_tree_traverse().
-</para>
-<para>
-To remove a key/value pair use g_tree_remove().
-</para>
-<para>
-To destroy a #GTree, use g_tree_destroy().
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GTree ##### -->
<para>
-The #GTree struct is an opaque data structure representing a
-<link linkend="glib-Balanced-Binary-Trees">Balanced Binary Tree</link>.
-It should be accessed only by using the following functions.
+
</para>
<!-- ##### FUNCTION g_tree_new ##### -->
<para>
-Creates a new GTree.
+
</para>
-@key_compare_func: the function used to order the nodes in the #GTree.
-It should return values similar to the standard <function>strcmp()</function>
-function -
-0 if the two arguments are equal, a negative value if the first argument comes
-before the second, or a positive value if the first argument comes after the
-second.
-@Returns: a new #GTree.
+@key_compare_func:
+@Returns:
<!-- ##### FUNCTION g_tree_insert ##### -->
<para>
-Inserts a key/value pair into a #GTree.
-If the given key already exists in the #GTree it is set to the new value.
-(If you are using dynamically allocated keys and values you should be careful
-to ensure that the old values are freed.)
-</para>
-<para>
-The tree is automatically 'balanced' as new key/value pairs are added,
-so that the distance from the root to every leaf is as small as possible.
+
</para>
-@tree: a #GTree.
-@key: the key to insert.
-@value: the value corresponding to the key.
+@tree:
+@key:
+@value:
<!-- ##### FUNCTION g_tree_nnodes ##### -->
<para>
-Gets the number of nodes in a #GTree.
+
</para>
-@tree: a #GTree.
-@Returns: the number of nodes in the #GTree.
+@tree:
+@Returns:
<!-- ##### FUNCTION g_tree_height ##### -->
<para>
-Gets the height of a #GTree.
-</para>
-<para>
-If the #GTree contains no nodes, the height is 0.
-If the #GTree contains only one root node the height is 1.
-If the root node has children the height is 2, etc.
+
</para>
-@tree: a #GTree.
-@Returns: the height of the #GTree.
+@tree:
+@Returns:
<!-- ##### FUNCTION g_tree_lookup ##### -->
<para>
-Gets the value corresponding to the given key.
-Since a #GTree is automatically balanced as key/value pairs are
-added, key lookup is very fast.
+
</para>
-@tree: a #GTree.
-@key: the key to look up.
-@Returns: the value corresponding to the key.
+@tree:
+@key:
+@Returns:
<!-- ##### FUNCTION g_tree_search ##### -->
<para>
-Searches a #GTree using an alternative form of the comparison function.
-</para>
-<para>
-This function is not as useful as it sounds.
-It allows you to use a different function for performing the lookup of
-a key. However, since the tree is ordered according to the @key_compare_func
-function passed to g_tree_new(), the function you pass to g_tree_search() must
-return exactly the same value as would be returned by the comparison function,
-for each pair of tree nodes, or the search will not work.
-</para>
-<para>
-To search for a specific value, you can use g_tree_traverse().
-</para>
-
-@tree: a #GTree.
-@search_func: the comparison function used to search the #GTree.
-@data: the data passed as the second argument to the @search_func function.
-@Returns: the value corresponding to the found key, or NULL if the key is
-not found.
-
-<!-- ##### USER_FUNCTION GSearchFunc ##### -->
-<para>
-Specifies the type of function passed to g_tree_search().
</para>
-@key: a key from a #GTree.
-@data: the data to compare with the key.
-@Returns: 0 if the desired key has been found, a negative number if the
-desired key comes before @key in the sort order of the #GTree, or a positive
-value if the desired key comes after @key.
+@tree:
+@search_func:
+@data:
+@Returns:
<!-- ##### FUNCTION g_tree_traverse ##### -->
<para>
-Calls the given function for each node in the GTree.
+
</para>
-@tree: a #GTree.
-@traverse_func: the function to call for each node visited. If this function
-returns TRUE, the traversal is stopped.
-@traverse_type: the order in which nodes are visited, one of %G_IN_ORDER,
-%G_PRE_ORDER and %G_POST_ORDER.
-@data: user data to pass to the traverse function.
+@tree:
+@traverse_func:
+@traverse_type:
+@data:
<!-- ##### USER_FUNCTION GTraverseFunc ##### -->
<para>
-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.
+
</para>
-@key: a key of a #GTree node.
-@value: the value corresponding to the key.
-@data: user data passed to g_tree_traverse().
-@Returns: TRUE to stop the traversal.
+@key:
+@value:
+@data:
+@Returns:
<!-- ##### ENUM GTraverseType ##### -->
<para>
-Specifies the type of traveral performed by g_tree_traverse(),
-g_node_traverse() and g_node_find().
-<itemizedlist>
-<listitem><para>
-%G_PRE_ORDER visits a node, then its children.
-</para></listitem>
-<listitem><para>
-%G_IN_ORDER 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.
-</para></listitem>
-<listitem><para>
-%G_POST_ORDER visits the node's children, then the node itself.
-</para></listitem>
-<listitem><para>
-%G_LEVEL_ORDER is not implemented for
-<link linkend="glib-Balanced-Binary-Trees">Balanced Binary Trees</link>.
-For <link linkend="glib-N-ary-Trees">N-ary Trees</link>
-it calls the function for each child of the node, then it recursively visits
-each child.
-</para></listitem>
-</itemizedlist>
+
</para>
@G_IN_ORDER:
<!-- ##### FUNCTION g_tree_remove ##### -->
<para>
-Removes a key/value pair from a #GTree.
-If the key or value is dynamically allocated you must remember to free them
-yourself.
+
</para>
-@tree: a #GTree.
-@key: the key to remove.
+@tree:
+@key:
<!-- ##### FUNCTION g_tree_destroy ##### -->
<para>
-Destroys the #GTree, freeing all of the memory allocated.
-But it doesn't free keys or values.
+
</para>
-@tree: a #GTree.
+@tree:
N-ary Trees
<!-- ##### SECTION Short_Description ##### -->
-trees of data with any number of branches.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-The #GNode struct and its associated functions provide a N-ary tree data
-structure, where nodes in the tree can contain arbitrary data.
-</para>
-<para>
-To create a new tree use g_node_new().
-</para>
-<para>
-To insert a node into a tree use g_node_insert(), g_node_insert_before(),
-g_node_append() and g_node_prepend().
-</para>
-<para>
-To create a new node and insert it into a tree use g_node_insert_data(),
-g_node_insert_data_before(), g_node_append_data() and g_node_prepend_data().
-</para>
-<para>
-To reverse the children of a node use g_node_reverse_children().
-</para>
-<para>
-To find a node use g_node_get_root(), g_node_find(), g_node_find_child(),
-g_node_child_index(), g_node_child_position(),
-g_node_first_child(), g_node_last_child(),
-g_node_nth_child(), g_node_first_sibling(), g_node_prev_sibling(),
-g_node_next_sibling() or g_node_last_sibling().
-</para>
-<para>
-To get information about a node or tree use G_NODE_IS_LEAF(),
-G_NODE_IS_ROOT(), g_node_depth(), g_node_n_nodes(), g_node_n_children(),
-g_node_is_ancestor() or g_node_max_height().
-</para>
-<para>
-To traverse a tree, calling a function for each node visited in the
-traversal, use g_node_traverse() or g_node_children_foreach().
-</para>
-<para>
-To remove a node or subtree from a tree use g_node_unlink() or
-g_node_destroy().
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### STRUCT GNode ##### -->
<para>
-The #GNode struct represents one node in a
-<link linkend="glib-N-ary-Trees">N-ary Tree</link>.
-The <structfield>data</structfield> field contains the actual data of the node.
-The <structfield>next</structfield> and <structfield>prev</structfield>
-fields point to the node's siblings (a sibling is another #GNode with the
-same parent).
-The <structfield>parent</structfield> field points to the parent of the #GNode,
-or is NULL if the #GNode is the root of the tree.
-The <structfield>children</structfield> field points to the first child of the
-#GNode. The other children are accessed by using the
-<structfield>next</structfield> pointer of each child.
+
</para>
@data:
<!-- ##### FUNCTION g_node_new ##### -->
<para>
-Creates a new #GNode containing the given data.
-Used to create the first node in a tree.
+
</para>
-@data: the data of the new node.
-@Returns: a new #GNode.
+@data:
+@Returns:
+
+
+<!-- ##### FUNCTION g_node_copy ##### -->
+<para>
+
+</para>
+
+@node:
+@Returns:
<!-- ##### FUNCTION g_node_insert ##### -->
<para>
-Inserts a #GNode beneath the parent at the given position.
+
</para>
-@parent: the #GNode to place @node under.
-@position: the position to place @node at, with respect to its siblings.
-If position is -1, @node is inserted as the last child of @parent.
-@node: the #GNode to insert.
-@Returns: the inserted #GNode.
+@parent:
+@position:
+@node:
+@Returns:
<!-- ##### FUNCTION g_node_insert_before ##### -->
<para>
-Inserts a #GNode beneath the parent before the given sibling.
+
</para>
-@parent: the #GNode to place @node under.
-@sibling: the sibling #GNode to place @node before. If sibling is NULL,
-the node is inserted as the last child of @parent.
-@node: the #GNode to insert.
-@Returns: the inserted #GNode.
+@parent:
+@sibling:
+@node:
+@Returns:
<!-- ##### MACRO g_node_append ##### -->
<para>
-Inserts a #GNode as the last child of the given parent.
+
</para>
-@parent: the #GNode to place the new #GNode under.
-@node: the #GNode to insert.
-@Returns: the inserted #GNode.
+@parent:
+@node:
<!-- ##### FUNCTION g_node_prepend ##### -->
<para>
-Inserts a #GNode as the first child of the given parent.
+
</para>
-@parent: the #GNode to place the new #GNode under.
-@node: the #GNode to insert.
-@Returns: the inserted #GNode.
+@parent:
+@node:
+@Returns:
<!-- ##### MACRO g_node_insert_data ##### -->
<para>
-Inserts a new #GNode at the given position.
+
</para>
-@parent: the #GNode to place the new #GNode under.
-@position: the position to place the new #GNode at.
-If position is -1, the new #GNode is inserted as the last child of @parent.
-@data: the data for the new #GNode.
-@Returns: the new #GNode.
+@parent:
+@position:
+@data:
<!-- ##### MACRO g_node_insert_data_before ##### -->
<para>
-Inserts a new #GNode before the given sibling.
+
</para>
-@parent: the #GNode to place the new #GNode under.
-@sibling: the sibling #GNode to place the new #GNode before.
-@data: the data for the new #GNode.
-@Returns: the new #GNode.
+@parent:
+@sibling:
+@data:
<!-- ##### MACRO g_node_append_data ##### -->
<para>
-Inserts a new #GNode as the last child of the given parent.
+
</para>
-@parent: the #GNode to place the new #GNode under.
-@data: the data for the new #GNode.
-@Returns: the new #GNode.
+@parent:
+@data:
<!-- ##### MACRO g_node_prepend_data ##### -->
<para>
-Inserts a new #GNode as the first child of the given parent.
+
</para>
-@parent: the #GNode to place the new #GNode under.
-@data: the data for the new #GNode.
-@Returns: the new #GNode.
+@parent:
+@data:
<!-- ##### FUNCTION g_node_reverse_children ##### -->
<para>
-Reverses the order of the children of a #GNode.
-(It doesn't change the order of the grandchildren.)
+
</para>
-@node: a #GNode.
+@node:
<!-- ##### FUNCTION g_node_traverse ##### -->
<para>
-Traverses a tree starting at the given root #GNode.
-It calls the given function for each node visited.
-The traversal can be halted at any point by returning TRUE from @func.
+
</para>
-@root: the root #GNode of the tree to traverse.
-@order: the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER,
-%G_POST_ORDER, or %G_LEVEL_ORDER.
-@flags: which types of children are to be visited, one of %G_TRAVERSE_ALL,
-%G_TRAVERSE_LEAFS and %G_TRAVERSE_NON_LEAFS.
-@max_depth: the maximum depth of the traversal. Nodes below this
-depth will not be visited. If max_depth is -1 all nodes in the tree are
-visited. If depth is 1, only the root is visited. If depth is 2, the root
-and its children are visited. And so on.
-@func: the function to call for each visited #GNode.
-@data: user data to pass to the function.
+@root:
+@order:
+@flags:
+@max_depth:
+@func:
+@data:
<!-- ##### ENUM GTraverseFlags ##### -->
<para>
-Specifies which nodes are visited during several of the tree functions,
-including g_node_traverse() and g_node_find().
-<itemizedlist>
-<listitem><para>
-%G_TRAVERSE_LEAFS specifies that only leaf nodes should be visited.
-</para></listitem>
-<listitem><para>
-%G_TRAVERSE_NON_LEAFS specifies that only non-leaf nodes should be visited.
-</para></listitem>
-<listitem><para>
-%G_TRAVERSE_ALL specifies that all nodes should be visited.
-</para></listitem>
-</itemizedlist>
+
</para>
@G_TRAVERSE_LEAFS:
<!-- ##### USER_FUNCTION GNodeTraverseFunc ##### -->
<para>
-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.
+
</para>
-@node: a #GNode.
-@data: user data passed to g_node_traverse().
-@Returns: TRUE to stop the traversal.
+@node:
+@data:
+@Returns:
<!-- ##### FUNCTION g_node_children_foreach ##### -->
<para>
-Calls a function for each of the children of a #GNode.
-Note that it doesn't descend beneath the child nodes.
+
</para>
-@node: a #GNode.
-@flags: which types of children are to be visited, one of %G_TRAVERSE_ALL,
-%G_TRAVERSE_LEAFS and %G_TRAVERSE_NON_LEAFS.
-@func: the function to call for each visited node.
-@data: user data to pass to the function.
+@node:
+@flags:
+@func:
+@data:
<!-- ##### USER_FUNCTION GNodeForeachFunc ##### -->
<para>
-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().
+
</para>
-@node: a #GNode.
-@data: user data passed to g_node_children_foreach().
+@node:
+@data:
<!-- ##### FUNCTION g_node_get_root ##### -->
<para>
-Gets the root of a tree.
+
</para>
-@node: a #GNode.
-@Returns: the root of the tree.
+@node:
+@Returns:
<!-- ##### FUNCTION g_node_find ##### -->
<para>
-Finds a #GNode in a tree.
+
</para>
-@root: the root #GNode of the tree to search.
-@order: the order in which nodes are visited - %G_IN_ORDER, %G_PRE_ORDER,
-%G_POST_ORDER, or %G_LEVEL_ORDER.
-@flags: which types of children are to be searched, one of %G_TRAVERSE_ALL,
-%G_TRAVERSE_LEAFS and %G_TRAVERSE_NON_LEAFS.
-@data: the data to find.
-@Returns: the found #GNode, or NULL if the data is not found.
+@root:
+@order:
+@flags:
+@data:
+@Returns:
<!-- ##### FUNCTION g_node_find_child ##### -->
<para>
-Finds the first child of a #GNode with the given data.
+
</para>
-@node: a #GNode.
-@flags: which types of children are to be searched, one of %G_TRAVERSE_ALL,
-%G_TRAVERSE_LEAFS and %G_TRAVERSE_NON_LEAFS.
-@data: the data to find.
-@Returns: the found child #GNode, or NULL if the data is not found.
+@node:
+@flags:
+@data:
+@Returns:
<!-- ##### FUNCTION g_node_child_index ##### -->
<para>
-Gets the position of the first child of a #GNode which contains the given data.
+
</para>
-@node: a #GNode.
-@data: the data to find.
-@Returns: the index of the child of @node which contains @data, or -1
-if the data is not found.
+@node:
+@data:
+@Returns:
<!-- ##### FUNCTION g_node_child_position ##### -->
<para>
-Gets the position of a #GNode with respect to its siblings.
-@child must be a child of @node.
-The first child is numbered 0, the second 1, and so on.
+
</para>
-@node: a #GNode.
-@child: a child of @node.
-@Returns: the position of @child with respect to its siblings.
+@node:
+@child:
+@Returns:
<!-- ##### MACRO g_node_first_child ##### -->
<para>
-Gets the first child of a #GNode.
+
</para>
-@node: a #GNode.
-@Returns: the last child of @node, or NULL if @node is NULL or has no children.
+@node:
<!-- ##### FUNCTION g_node_last_child ##### -->
<para>
-Gets the last child of a #GNode.
+
</para>
-@node: a #GNode (must not be NULL).
-@Returns: the last child of @node, or NULL if @node has no children.
+@node:
+@Returns:
<!-- ##### FUNCTION g_node_nth_child ##### -->
<para>
-Gets a child of a #GNode, using the given index.
-The first child is at index 0. If the index is too big, NULL is returned.
+
</para>
-@node: a #GNode.
-@n: the index of the desired child.
-@Returns: the child of @node at index @n.
+@node:
+@n:
+@Returns:
<!-- ##### FUNCTION g_node_first_sibling ##### -->
<para>
-Gets the first sibling of a #GNode.
-This could possibly be the node itself.
+
</para>
-@node: a #GNode.
-@Returns: the first sibling of @node.
+@node:
+@Returns:
<!-- ##### MACRO g_node_next_sibling ##### -->
<para>
-Gets the next sibling of a #GNode.
+
</para>
-@node: a #GNode.
-@Returns: the next sibling of @node, or NULL if @node is NULL.
+@node:
<!-- ##### MACRO g_node_prev_sibling ##### -->
<para>
-Gets the previous sibling of a #GNode.
+
</para>
-@node: a #GNode.
-@Returns: the previous sibling of @node, or NULL if @node is NULL.
+@node:
<!-- ##### FUNCTION g_node_last_sibling ##### -->
<para>
-Gets the last sibling of a #GNode.
-This could possibly be the node itself.
+
</para>
-@node: a #GNode.
-@Returns: the last sibling of @node.
+@node:
+@Returns:
<!-- ##### MACRO G_NODE_IS_LEAF ##### -->
<para>
-Returns TRUE if a #GNode is a leaf node.
+
</para>
-@node: a #GNode.
-@Returns: TRUE if the #GNode is a leaf node (i.e. it has no children).
+@node:
<!-- ##### MACRO G_NODE_IS_ROOT ##### -->
<para>
-Returns TRUE if a #GNode is the root of a tree.
+
</para>
-@node: a #GNode.
-@Returns: TRUE if the #GNode is the root of a tree (i.e. it has no parent
-or siblings).
+@node:
<!-- ##### FUNCTION g_node_depth ##### -->
<para>
-Gets the depth of a #GNode.
-</para>
-<para>
-If @node is NULL the depth is 0.
-The root node has a depth of 1.
-For the children of the root node the depth is 2. And so on.
+
</para>
-@node: a #GNode.
-@Returns: the depth of the #GNode.
+@node:
+@Returns:
<!-- ##### FUNCTION g_node_n_nodes ##### -->
<para>
-Gets the number of nodes in a tree.
+
</para>
-@root: a #GNode.
-@flags: which types of children are to be counted, one of %G_TRAVERSE_ALL,
-%G_TRAVERSE_LEAFS and %G_TRAVERSE_NON_LEAFS.
-@Returns: the number of nodes in the tree.
+@root:
+@flags:
+@Returns:
<!-- ##### FUNCTION g_node_n_children ##### -->
<para>
-Gets the number of children of a #GNode.
+
</para>
-@node: a #GNode.
-@Returns: the number of children of @node.
+@node:
+@Returns:
<!-- ##### FUNCTION g_node_is_ancestor ##### -->
<para>
-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.
+
</para>
-@node: a #GNode.
-@descendant: a #GNode.
-@Returns: TRUE if @node is an ancestor of @descendant.
+@node:
+@descendant:
+@Returns:
<!-- ##### FUNCTION g_node_max_height ##### -->
<para>
-Gets the maximum height of all branches beneath a #GNode.
-This is the maximum distance from the #GNode to all leaf nodes.
-</para>
-<para>
-If @root is NULL, 0 is returned. If @root has no children, 1 is returned.
-If @root has children, 2 is returned. And so on.
+
</para>
-@root: a #GNode.
-@Returns: the maximum height of the tree beneath @root.
+@root:
+@Returns:
<!-- ##### FUNCTION g_node_unlink ##### -->
<para>
-Unlinks a #GNode from a tree, resulting in two separate trees.
+
</para>
-@node: the #GNode to unlink, which becomes the root of a new tree.
+@node:
<!-- ##### FUNCTION g_node_destroy ##### -->
<para>
-Removes the #GNode and its children from the tree, freeing any memory
-allocated.
+
</para>
-@root: the root of the tree/subtree to destroy.
+@root:
-<!-- ##### FUNCTION g_node_pop_allocator ##### -->
+<!-- ##### FUNCTION g_node_push_allocator ##### -->
<para>
-Restores the previous #GAllocator, used when allocating #GNode elements.
+
</para>
+@allocator:
-<!-- ##### FUNCTION g_node_push_allocator ##### -->
+<!-- ##### FUNCTION g_node_pop_allocator ##### -->
<para>
-Sets the allocator to use to allocate #GNode elements.
-Use g_node_pop_allocator() to restore the previous allocator.
+
</para>
-@allocator: the #GAllocator to use when allocating #GNode elements.
Type Conversion Macros
<!-- ##### SECTION Short_Description ##### -->
-a portable method for storing #gint & #guint values in #gpointer variables.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These macros provide a portable method of storing #gint and #guint values in
-#gpointer variables.
-</para>
-<para>
-Many of the GLib data types are based on storing #gpointer values,
-e.g. #GHashTable, #GList, #GSList, #GTree, and #GNode.
-By using the type conversion macros described below you can store #gint and
-#guint values inside a #gpointer. So you can, for example, create
-a hash table of #gint values, or a linked list of #guint values.
-</para>
-<para>
-The type conversion macros are necessary because the size of a #gpointer can
-vary across different platforms. So the type conversion has to be done
-carefully.
-</para>
-<para>
-Note that the reverse operation, storing #gpointer values in
-integer variables, is not supported, since an integer is not guaranteed to
-be large enough to store #gpointer values across all platforms.
-</para>
-<para>
-To convert an integer value, a #gint, to a #gpointer, use #GINT_TO_POINTER.
-To convert it back to a #gint, use #GPOINTER_TO_INT.
-</para>
-<para>
-To convert an unsigned integer, a #guint, to a #gpointer, use
-#GUINT_TO_POINTER. To convert it back to a #guint, use #GPOINTER_TO_UINT.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### MACRO GINT_TO_POINTER ##### -->
<para>
-Converts a #gint to a #gpointer.
+
</para>
-@i: a #gint value.
-@Returns: the value converted to a #gpointer.
+@i:
<!-- ##### MACRO GPOINTER_TO_INT ##### -->
<para>
-Converts a #gpointer to a #gint.
+
</para>
-@p: a #gpointer value.
-@Returns: the value converted to a #gint.
+@p:
<!-- ##### MACRO GUINT_TO_POINTER ##### -->
<para>
-Converts a #guint to a #gpointer.
+
</para>
-@u: a #guint value.
-@Returns: the value converted to a #gpointer.
+@u:
<!-- ##### MACRO GPOINTER_TO_UINT ##### -->
<para>
-Converts a #gpointer to a #guint.
+
</para>
-@p: a #gpointer value.
-@Returns: the value converted to a #guint.
+@p:
<!-- ##### SECTION Title ##### -->
-Basic Types
+GType
<!-- ##### SECTION Short_Description ##### -->
-standard GLib types, defined for ease-of-use and portability.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-GLib defines a number of commonly used types, which can be divided into
-4 groups:
-<itemizedlist>
-<listitem><para>
-New types which are not part of standard C - #gboolean, #gsize, #gssize.
-</para></listitem>
+</para>
+
-<listitem><para>
-Integer types which are guaranteed to be the same size across all platforms -
-#gint8, #guint8, #gint16, #guint16, #gint32, #guint32, #gint64, #guint64.
-</para></listitem>
+<!-- ##### SECTION See_Also ##### -->
+<para>
-<listitem><para>
-Types which are easier to use than their standard C counterparts -
-#gpointer, #gconstpointer, #guchar, #guint, #gushort, #gulong.
-</para></listitem>
+</para>
-<listitem><para>
-Types which correspond exactly to standard C types, but are included
-for completeness - #gchar, #gint, #gshort, #glong, #gfloat, #gdouble.
-</para></listitem>
-</itemizedlist>
+
+<!-- ##### TYPEDEF GType ##### -->
+<para>
</para>
-<!-- ##### SECTION See_Also ##### -->
+
+<!-- ##### MACRO G_TYPE_FUNDAMENTAL ##### -->
+<para>
+
+</para>
+
+@type:
+
+
+<!-- ##### MACRO G_TYPE_FUNDAMENTAL_MAX ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO G_TYPE_DERIVE_ID ##### -->
+<para>
+
+</para>
+
+@ptype:
+@branch_seqno:
+
+
+<!-- ##### MACRO G_TYPE_BRANCH_SEQNO ##### -->
+<para>
+
+</para>
+
+@type:
+
+
+<!-- ##### MACRO G_TYPE_FUNDAMENTAL_LAST ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### ENUM GTypeFundamentals ##### -->
+<para>
+
+</para>
+
+@G_TYPE_INVALID:
+@G_TYPE_NONE:
+@G_TYPE_INTERFACE:
+@G_TYPE_CHAR:
+@G_TYPE_UCHAR:
+@G_TYPE_BOOLEAN:
+@G_TYPE_INT:
+@G_TYPE_UINT:
+@G_TYPE_LONG:
+@G_TYPE_ULONG:
+@G_TYPE_ENUM:
+@G_TYPE_FLAGS:
+@G_TYPE_FLOAT:
+@G_TYPE_DOUBLE:
+@G_TYPE_STRING:
+@G_TYPE_PARAM:
+@G_TYPE_OBJECT:
+@G_TYPE_GTK_BOXED:
+@G_TYPE_GTK_POINTER:
+@G_TYPE_GTK_SIGNAL:
+@G_TYPE_BSE_PROCEDURE:
+@G_TYPE_BSE_TIME:
+@G_TYPE_BSE_NOTE:
+@G_TYPE_BSE_DOTS:
+@G_TYPE_GLE_GOBJECT:
+@G_TYPE_LAST_RESERVED_FUNDAMENTAL:
+@G_TYPE_PARAM_CHAR:
+@G_TYPE_PARAM_UCHAR:
+@G_TYPE_PARAM_BOOLEAN:
+@G_TYPE_PARAM_INT:
+@G_TYPE_PARAM_UINT:
+@G_TYPE_PARAM_LONG:
+@G_TYPE_PARAM_ULONG:
+@G_TYPE_PARAM_ENUM:
+@G_TYPE_PARAM_FLAGS:
+@G_TYPE_PARAM_FLOAT:
+@G_TYPE_PARAM_DOUBLE:
+@G_TYPE_PARAM_STRING:
+@G_TYPE_PARAM_OBJECT:
+
+<!-- ##### MACRO G_TYPE_IS_CLASSED ##### -->
+<para>
+
+</para>
+
+@type:
+
+
+<!-- ##### MACRO G_TYPE_IS_INSTANTIATABLE ##### -->
+<para>
+
+</para>
+
+@type:
+
+
+<!-- ##### MACRO G_TYPE_IS_DERIVABLE ##### -->
+<para>
+
+</para>
+
+@type:
+
+
+<!-- ##### MACRO G_TYPE_IS_DEEP_DERIVABLE ##### -->
+<para>
+
+</para>
+
+@type:
+
+
+<!-- ##### MACRO G_TYPE_IS_PARAM ##### -->
+<para>
+
+</para>
+
+@type:
+
+
+<!-- ##### MACRO G_TYPE_IS_INTERFACE ##### -->
+<para>
+
+</para>
+
+@type:
+
+
+<!-- ##### STRUCT GTypePlugin ##### -->
+<para>
+
+</para>
+
+@vtable:
+
+<!-- ##### STRUCT GTypePluginVTable ##### -->
+<para>
+
+</para>
+
+@plugin_ref:
+@plugin_unref:
+@complete_type_info:
+@complete_interface_info:
+
+<!-- ##### STRUCT GTypeInterface ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### STRUCT GTypeInstance ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### STRUCT GTypeInfo ##### -->
+<para>
+
+</para>
+
+@class_size:
+@base_init:
+@base_finalize:
+@class_init:
+@class_finalize:
+@class_data:
+@instance_size:
+@n_preallocs:
+@instance_init:
+@value_table:
+
+<!-- ##### STRUCT GTypeFundamentalInfo ##### -->
+<para>
+
+</para>
+
+@type_flags:
+
+<!-- ##### STRUCT GInterfaceInfo ##### -->
+<para>
+
+</para>
+
+@interface_init:
+@interface_finalize:
+@interface_data:
+
+<!-- ##### STRUCT GTypeValueTable ##### -->
+<para>
+
+</para>
+
+@value_init:
+@value_free:
+@value_copy:
+@collect_type:
+@collect_value:
+@lcopy_type:
+@lcopy_value:
+
+<!-- ##### MACRO G_TYPE_CHECK_INSTANCE_CAST ##### -->
+<para>
+
+</para>
+
+@instance:
+@g_type:
+@c_type:
+
+
+<!-- ##### MACRO G_TYPE_CHECK_CLASS_CAST ##### -->
+<para>
+
+</para>
+
+@g_class:
+@g_type:
+@c_type:
+
+
+<!-- ##### MACRO G_TYPE_CHECK_INSTANCE_TYPE ##### -->
+<para>
+
+</para>
+
+@instance:
+@g_type:
+
+
+<!-- ##### MACRO G_TYPE_CHECK_CLASS_TYPE ##### -->
+<para>
+
+</para>
+
+@g_class:
+@g_type:
+
+
+<!-- ##### MACRO G_TYPE_INSTANCE_GET_CLASS ##### -->
+<para>
+
+</para>
+
+@instance:
+@g_type:
+@c_type:
+
+
+<!-- ##### MACRO G_TYPE_FROM_INSTANCE ##### -->
+<para>
+
+</para>
+
+@instance:
+
+
+<!-- ##### MACRO G_TYPE_FROM_CLASS ##### -->
+<para>
+
+</para>
+
+@g_class:
+
+
+<!-- ##### MACRO G_TYPE_FROM_INTERFACE ##### -->
+<para>
+
+</para>
+
+@g_iface:
+
+
+<!-- ##### FUNCTION g_type_init ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### FUNCTION g_type_name ##### -->
+<para>
+
+</para>
+
+@type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_qname ##### -->
+<para>
+
+</para>
+
+@type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_from_name ##### -->
+<para>
+
+</para>
+
+@name:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_parent ##### -->
+<para>
+
+</para>
+
+@type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_next_base ##### -->
+<para>
+
+</para>
+
+@type:
+@base_type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_is_a ##### -->
+<para>
+
+</para>
+
+@type:
+@is_a_type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_conforms_to ##### -->
+<para>
+
+</para>
+
+@type:
+@iface_type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_fundamental_branch_last ##### -->
+<para>
+
+</para>
+
+@type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_class_ref ##### -->
+<para>
+
+</para>
+
+@type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_class_peek ##### -->
+<para>
+
+</para>
+
+@type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_class_unref ##### -->
+<para>
+
+</para>
+
+@g_class:
+
+
+<!-- ##### FUNCTION g_type_class_peek_parent ##### -->
+<para>
+
+</para>
+
+@g_class:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_interface_peek ##### -->
+<para>
+
+</para>
+
+@instance_class:
+@iface_type:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_children ##### -->
+<para>
+
+</para>
+
+@type:
+@n_children:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_interfaces ##### -->
+<para>
+
+</para>
+
+@type:
+@n_interfaces:
+@Returns:
+
+
+<!-- ##### FUNCTION g_type_set_qdata ##### -->
+<para>
+
+</para>
+
+@type:
+@quark:
+@data:
+
+
+<!-- ##### FUNCTION g_type_get_qdata ##### -->
+<para>
+
+</para>
+
+@type:
+@quark:
+@Returns:
+
+
+<!-- ##### USER_FUNCTION GBaseInitFunc ##### -->
+<para>
+
+</para>
+
+@g_class:
+
+
+<!-- ##### USER_FUNCTION GBaseFinalizeFunc ##### -->
+<para>
+
+</para>
+
+@g_class:
+
+
+<!-- ##### USER_FUNCTION GClassInitFunc ##### -->
+<para>
+
+</para>
+
+@g_class:
+@class_data:
+
+
+<!-- ##### USER_FUNCTION GClassFinalizeFunc ##### -->
+<para>
+
+</para>
+
+@g_class:
+@class_data:
+
+
+<!-- ##### USER_FUNCTION GInstanceInitFunc ##### -->
<para>
</para>
-<!-- ##### TYPEDEF gboolean ##### -->
+@instance:
+@g_class:
+
+
+<!-- ##### USER_FUNCTION GInterfaceInitFunc ##### -->
<para>
-A standard <type>boolean</type> type.
-Variables of this type should only contain the value #TRUE or #FALSE.
+
</para>
+@g_iface:
+@iface_data:
+
-<!-- ##### TYPEDEF gpointer ##### -->
+<!-- ##### USER_FUNCTION GInterfaceFinalizeFunc ##### -->
<para>
-An untyped pointer.
-#gpointer looks better and is easier to use than <type>void*</type>.
+
</para>
+@g_iface:
+@iface_data:
+
-<!-- ##### TYPEDEF gconstpointer ##### -->
+<!-- ##### USER_FUNCTION GTypePluginRef ##### -->
<para>
-An untyped pointer to constant data.
-The data pointed to should not be changed.
+
</para>
+
+@plugin:
+
+
+<!-- ##### USER_FUNCTION GTypePluginUnRef ##### -->
<para>
-This is typically used in function prototypes to indicate that the
-data pointed to will not be altered by the function.
+
</para>
+@plugin:
+
-<!-- ##### TYPEDEF gchar ##### -->
+<!-- ##### USER_FUNCTION GTypePluginFillTypeInfo ##### -->
<para>
-Corresponds to the standard C <type>char</type> type.
+
</para>
+@plugin:
+@g_type:
+@info:
+@value_table:
+
-<!-- ##### TYPEDEF guchar ##### -->
+<!-- ##### USER_FUNCTION GTypePluginFillInterfaceInfo ##### -->
<para>
-Corresponds to the standard C <type>unsigned char</type> type.
+
</para>
+@plugin:
+@interface_type:
+@instance_type:
+@info:
-<!-- ##### TYPEDEF gint ##### -->
+
+<!-- ##### USER_FUNCTION GTypeClassCacheFunc ##### -->
<para>
-Corresponds to the standard C <type>int</type> type.
-Values of this type can range from #G_MININT to #G_MAXINT.
+
</para>
+@cache_data:
+@g_class:
+@Returns:
+
-<!-- ##### TYPEDEF guint ##### -->
+<!-- ##### ENUM GTypeFlags ##### -->
<para>
-Corresponds to the standard C <type>unsigned int</type> type.
+
</para>
+@G_TYPE_FLAG_CLASSED:
+@G_TYPE_FLAG_INSTANTIATABLE:
+@G_TYPE_FLAG_DERIVABLE:
+@G_TYPE_FLAG_DEEP_DERIVABLE:
-<!-- ##### TYPEDEF gshort ##### -->
+<!-- ##### FUNCTION g_type_register_static ##### -->
<para>
-Corresponds to the standard C <type>short</type> type.
-Values of this type can range from #G_MINSHORT to #G_MAXSHORT.
+
</para>
+@parent_type:
+@type_name:
+@info:
+@Returns:
-<!-- ##### TYPEDEF gushort ##### -->
+
+<!-- ##### FUNCTION g_type_register_dynamic ##### -->
<para>
-Corresponds to the standard C <type>unsigned short</type> type.
+
</para>
+@parent_type:
+@type_name:
+@plugin:
+@Returns:
+
-<!-- ##### TYPEDEF glong ##### -->
+<!-- ##### FUNCTION g_type_register_fundamental ##### -->
<para>
-Corresponds to the standard C <type>long</type> type.
-Values of this type can range from #G_MINLONG to #G_MAXLONG.
+
</para>
+@type_id:
+@type_name:
+@info:
+@finfo:
+@Returns:
+
-<!-- ##### TYPEDEF gulong ##### -->
+<!-- ##### FUNCTION g_type_add_interface_static ##### -->
<para>
-Corresponds to the standard C <type>unsigned long</type> type.
+
</para>
+@instance_type:
+@interface_type:
+@info:
-<!-- ##### TYPEDEF gint8 ##### -->
+
+<!-- ##### FUNCTION g_type_add_interface_dynamic ##### -->
<para>
-A signed integer guaranteed to be 8 bits on all platforms.
-Values of this type can range from -128 to 127.
+
</para>
+@instance_type:
+@interface_type:
+@plugin:
+
-<!-- ##### TYPEDEF guint8 ##### -->
+<!-- ##### FUNCTION g_type_class_is_a ##### -->
<para>
-An unsigned integer guaranteed to be 8 bits on all platforms.
-Values of this type can range from 0 to 255.
+
</para>
+@g_class:
+@is_a_type:
+@Returns:
+
-<!-- ##### TYPEDEF gint16 ##### -->
+<!-- ##### FUNCTION g_type_check_class_cast ##### -->
<para>
-A signed integer guaranteed to be 16 bits on all platforms.
-Values of this type can range from -32,768 to 32,767.
+
</para>
+@g_class:
+@is_a_type:
+@Returns:
+
-<!-- ##### TYPEDEF guint16 ##### -->
+<!-- ##### FUNCTION g_type_check_instance_cast ##### -->
<para>
-An unsigned integer guaranteed to be 16 bits on all platforms.
-Values of this type can range from 0 to 65,535.
+
</para>
+@instance:
+@iface_type:
+@Returns:
-<!-- ##### TYPEDEF gint32 ##### -->
+
+<!-- ##### FUNCTION g_type_instance_conforms_to ##### -->
<para>
-A signed integer guaranteed to be 32 bits on all platforms.
-Values of this type can range from -2,147,483,648 to 2,147,483,647.
+
</para>
+@instance:
+@iface_type:
+@Returns:
+
-<!-- ##### TYPEDEF guint32 ##### -->
+<!-- ##### FUNCTION g_type_check_flags ##### -->
<para>
-An unsigned integer guaranteed to be 32 bits on all platforms.
-Values of this type can range from 0 to 4,294,967,295.
+
</para>
+@type:
+@flags:
+@Returns:
+
-<!-- ##### MACRO G_HAVE_GINT64 ##### -->
+<!-- ##### FUNCTION g_type_create_instance ##### -->
<para>
-This macro is defined if 64-bit signed and unsigned integers are available
-on the platform.
+
</para>
+@type:
+@Returns:
-<!-- ##### TYPEDEF gint64 ##### -->
+<!-- ##### FUNCTION g_type_free_instance ##### -->
<para>
-A signed integer guaranteed to be 64 bits on all platforms on which it is
-available (see #G_HAVE_GINT64).
-Values of this type can range from -9,223,372,036,854,775,808 to
-9,223,372,036,854,775,807.
+
</para>
+@instance:
+
-<!-- ##### TYPEDEF guint64 ##### -->
+<!-- ##### FUNCTION g_type_value_table_peek ##### -->
<para>
-An unsigned integer guaranteed to be 64 bits on all platforms on which it is
-available (see #G_HAVE_GINT64).
-Values of this type can range from 0 to 18,446,744,073,709,551,615.
+
</para>
+@type:
+@Returns:
+
-<!-- ##### MACRO G_GINT64_CONSTANT ##### -->
+<!-- ##### FUNCTION g_type_add_class_cache_func ##### -->
<para>
-This macro is used to insert 64-bit integer literals into the source code.
+
</para>
-@val: a literal integer value, e.g. 0x1d636b02300a7aa7U.
+@cache_data:
+@cache_func:
-<!-- ##### TYPEDEF gfloat ##### -->
+<!-- ##### FUNCTION g_type_remove_class_cache_func ##### -->
<para>
-Corresponds to the standard C <type>float</type> type.
-Values of this type can range from #G_MINFLOAT to #G_MAXFLOAT.
+
</para>
+@cache_data:
+@cache_func:
+
-<!-- ##### TYPEDEF gdouble ##### -->
+<!-- ##### FUNCTION g_type_class_unref_uncached ##### -->
<para>
-Corresponds to the standard C <type>double</type> type.
-Values of this type can range from #G_MINDOUBLE to #G_MAXDOUBLE.
+
</para>
+@g_class:
-<!-- ##### TYPEDEF gsize ##### -->
+
+<!-- ##### FUNCTION g_type_get_plugin ##### -->
<para>
-An unsigned 32-bit integer intended to represent sizes of data structures.
+
</para>
+@type:
+@Returns:
+
-<!-- ##### TYPEDEF gssize ##### -->
+<!-- ##### FUNCTION g_type_fundamental_last ##### -->
<para>
-A signed 32-bit integer intended to represent sizes of data structures.
+
</para>
+@Returns:
+
<!-- ##### SECTION Title ##### -->
-Message Output and Debugging Functions
+Warnings and Assertions
<!-- ##### SECTION Short_Description ##### -->
-functions to output messages and help debug applications.
+
<!-- ##### SECTION Long_Description ##### -->
<para>
-These functions provide support for outputting messages.
+
</para>
+
<!-- ##### SECTION See_Also ##### -->
<para>
</para>
+
<!-- ##### FUNCTION g_print ##### -->
<para>
-Outputs a formatted message via the print handler.
-The default print handler simply outputs the message to stdout.
-</para>
-<para>
-g_print() should not be used from within libraries for debugging messages,
-since it may be redirected by applications to special purpose message
-windows or even files.
-Instead, libraries should use g_log(), or the convenience functions
-g_message(), g_warning() and g_error().
+
</para>
-@format: the message format. See the <function>printf()</function>
-documentation.
-@Varargs: the parameters to insert into the format string.
+@format:
+@Varargs:
<!-- ##### FUNCTION g_set_print_handler ##### -->
<para>
-Sets the print handler.
-Any messages passed to g_print() will be output via the new handler.
-The default handler simply outputs the message to stdout.
-By providing your own handler you can redirect the output, to a GTK
-widget or a log file for example.
+
</para>
-@func: the new print handler.
-@Returns: the old print handler.
+@func:
+@Returns:
<!-- ##### USER_FUNCTION GPrintFunc ##### -->
<para>
-Specifies the type of the print handler functions.
-These are called with the complete formatted string to output.
+
</para>
-@string: the message to be output.
+@string:
<!-- ##### FUNCTION g_printerr ##### -->
<para>
-Outputs a formatted message via the error message handler.
-The default handler simply outputs the message to stderr.
-</para>
-<para>
-g_printerr() should not be used from within libraries. Instead g_log() should
-be used, or the convenience functions g_message(), g_warning() and g_error().
+
</para>
-@format: the message format. See the <function>printf()</function>
-documentation.
-@Varargs: the parameters to insert into the format string.
+@format:
+@Varargs:
<!-- ##### FUNCTION g_set_printerr_handler ##### -->
<para>
-Sets the handler for printing error messages.
-Any messages passed to g_printerr() will be output via the new handler.
-The default handler simply outputs the message to stderr.
-By providing your own handler you can redirect the output, to a GTK
-widget or a log file for example.
+
</para>
-@func: the new error message handler.
-@Returns: the old error message handler.
+@func:
+@Returns:
<!-- ##### MACRO g_return_if_fail ##### -->
<para>
-Returns from the current function if the expression is not true.
-If the expression evaluates to FALSE, a critical message is logged and
-the function returns. This can only be used in functions which do not return
-a value.
+
</para>
-@expr: the expression to check.
+@expr:
<!-- ##### MACRO g_return_val_if_fail ##### -->
<para>
-Returns from the current function, returning the value @val, if the expression
-is not true.
-If the expression evaluates to FALSE, a critical message is logged and
-@val is returned.
+
</para>
-@expr: the expression to check.
-@val: the value to return from the current function if the expression is not
-true.
+@expr:
+@val:
-<!-- ##### MACRO g_assert ##### -->
+<!-- ##### MACRO g_return_if_reached ##### -->
<para>
-Debugging macro to terminate the application if the assertion fails.
-If the assertion fails (i.e. the expression is not true), an error message
-is logged and the application is terminated.
+
</para>
+
+
+
+<!-- ##### MACRO g_return_val_if_reached ##### -->
<para>
-The macro can be turned off in final releases of code by defining
-G_DISABLE_ASSERT when compiling the application.
+
</para>
-@expr: the expression to check.
+@val:
-<!-- ##### MACRO g_assert_not_reached ##### -->
+<!-- ##### MACRO g_assert ##### -->
<para>
-Debugging macro to terminate the application if it is ever reached.
-If it is reached, an error message is logged and the application is terminated.
+
</para>
+
+@expr:
+
+
+<!-- ##### MACRO g_assert_not_reached ##### -->
<para>
-The macro can be turned off in final releases of code by defining
-G_DISABLE_ASSERT when compiling the application.
+
</para>
<!-- ##### FUNCTION g_on_error_query ##### -->
<para>
-Prompts the user with "[E]xit, [H]alt, show [S]tack trace or [P]roceed".
-This function is intended to be used for debugging use only.
-FIXME: How do you set it up?
-</para>
-<para>
-If Exit is selected, the application terminates with a call to
-<function>_exit(0)</function>.
-</para>
-<para>
-If Halt is selected, the application enters an infinite loop.
-The infinite loop can only be stopped by killing the application,
-or by setting glib_on_error_halt to FALSE (possibly via a debugger).
-</para>
-<para>
-If Stack trace is selected, g_on_error_stack_trace() is called. This
-invokes gdb, which attaches to the current process and shows a stack trace.
-The prompt is then shown again.
-</para>
-<para>
-If Proceed is selected, the function returns.
-</para>
-<para>
-This function may cause different actions on non-unix platforms.
+
</para>
-@prg_name: the program name, needed by gdb for the [S]tack trace option.
-If @prg_name is NULL, g_get_prgname() is called to get the program name
-(which will work correctly if gdk_init() or gtk_init() has been called).
+@prg_name:
<!-- ##### FUNCTION g_on_error_stack_trace ##### -->
<para>
-Invokes gdb, which attaches to the current process and shows a stack trace.
-Called by g_on_error_query() when the [S]tack trace option is selected.
-</para>
-<para>
-This function may cause different actions on non-unix platforms.
+
</para>
-@prg_name: the program name, needed by gdb for the [S]tack trace option.
-If @prg_name is NULL, g_get_prgname() is called to get the program name
-(which will work correctly if gdk_init() or gtk_init() has been called).
+@prg_name:
<!-- ##### MACRO G_BREAKPOINT ##### -->
<para>
-Inserts a breakpoint instruction into the code (on x86 machines only).
+
</para>
Windows Compatability Functions
<!-- ##### SECTION Short_Description ##### -->
-functions to support portability to the Windows environment.
-<!-- ##### SECTION Long_Description ##### -->
-<para>
-These functions and macros are provided in the GLib library when compiled
-on the Windows platform.
-</para>
-<para>
-Many of the macros simply rename available windows functions
-so that they use the same name as the standard Unix functions.
-This means that code written for the Unix platform will work without change
-under Windows.
-</para>
-<para>
-A few additional constants, types, and functions are also provided,
-to provide a common base set of functions across both the Unix and Windows
-environments.
-</para>
-
-<!-- ##### SECTION See_Also ##### -->
-<para>
-</para>
-
-<!-- ##### MACRO MAXPATHLEN ##### -->
+<!-- ##### SECTION Long_Description ##### -->
<para>
</para>
-
-<!-- ##### MACRO NAME_MAX ##### -->
+<!-- ##### SECTION See_Also ##### -->
<para>
</para>
-
-<!-- ##### MACRO getcwd ##### -->
+<!-- ##### MACRO MAXPATHLEN ##### -->
<para>
</para>
-<!-- ##### MACRO getpid ##### -->
+<!-- ##### MACRO NAME_MAX ##### -->
<para>
</para>
</para>
-<!-- ##### MACRO access ##### -->
-<para>
-
-</para>
-
-
-
-<!-- ##### MACRO open ##### -->
-<para>
-
-</para>
-
-
-
-<!-- ##### MACRO read ##### -->
-<para>
-
-</para>
-
-
-
-<!-- ##### MACRO write ##### -->
-<para>
-
-</para>
-
-
-
-<!-- ##### MACRO lseek ##### -->
-<para>
-
-</para>
-
-
-
-<!-- ##### MACRO close ##### -->
-<para>
-
-</para>
-
-
-
<!-- ##### MACRO pipe ##### -->
<para>
@phandles:
-<!-- ##### MACRO popen ##### -->
-<para>
-
-</para>
-
-
-
-<!-- ##### MACRO pclose ##### -->
+<!-- ##### MACRO ftruncate ##### -->
<para>
</para>
+@fd:
+@size:
-<!-- ##### MACRO fdopen ##### -->
+<!-- ##### MACRO opendir ##### -->
<para>
</para>
-<!-- ##### MACRO ftruncate ##### -->
+<!-- ##### MACRO readdir ##### -->
<para>
</para>
-@fd:
-@size:
-<!-- ##### MACRO opendir ##### -->
+<!-- ##### MACRO rewinddir ##### -->
<para>
</para>
-<!-- ##### MACRO readdir ##### -->
+<!-- ##### MACRO closedir ##### -->
<para>
</para>
-<!-- ##### MACRO rewinddir ##### -->
+<!-- ##### FUNCTION g_win32_error_message ##### -->
<para>
</para>
+@error:
+@Returns:
-<!-- ##### MACRO closedir ##### -->
+<!-- ##### FUNCTION g_win32_getlocale ##### -->
<para>
</para>
+@Returns:
projects / dana / cg-glib.git / commitdiff