gio2 0.90.3-x86-mingw32

data/vendor/local/include/glib-2.0/gobject/gvaluearray.h

@@ -0,0 +1,77 @@
+/* GObject - GLib Type, Object, Parameter and Signal Library
+ * Copyright (C) 2001 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * gvaluearray.h: GLib array type holding GValues
+ */
+#if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION)
+#error "Only <glib-object.h> can be included directly."
+#endif
+
+#ifndef __G_VALUE_ARRAY_H__
+#define __G_VALUE_ARRAY_H__
+
+#include	<gobject/gvalue.h>
+
+
+G_BEGIN_DECLS
+
+
+/* --- typedefs & structs --- */
+typedef struct _GValueArray GValueArray;
+/**
+ * GValueArray:
+ * @n_values: number of values contained in the array
+ * @values: array of values
+ * 
+ * A #GValueArray contains an array of #GValue elements.
+ */
+struct _GValueArray
+{
+  guint   n_values;
+  GValue *values;
+
+  /*< private >*/
+  guint   n_prealloced;
+};
+
+
+/* --- prototypes --- */
+GValue*		g_value_array_get_nth	     (GValueArray	*value_array,
+					      guint		 index_);
+GValueArray*	g_value_array_new	     (guint		 n_prealloced);
+void		g_value_array_free	     (GValueArray	*value_array);
+GValueArray*	g_value_array_copy	     (const GValueArray *value_array);
+GValueArray*	g_value_array_prepend	     (GValueArray	*value_array,
+					      const GValue	*value);
+GValueArray*	g_value_array_append	     (GValueArray	*value_array,
+					      const GValue	*value);
+GValueArray*	g_value_array_insert	     (GValueArray	*value_array,
+					      guint		 index_,
+					      const GValue	*value);
+GValueArray*	g_value_array_remove	     (GValueArray	*value_array,
+					      guint		 index_);
+GValueArray*	g_value_array_sort	     (GValueArray	*value_array,
+					      GCompareFunc	 compare_func);
+GValueArray*	g_value_array_sort_with_data (GValueArray	*value_array,
+					      GCompareDataFunc	 compare_func,
+					      gpointer		 user_data);
+
+
+G_END_DECLS
+
+#endif /* __G_VALUE_ARRAY_H__ */

data/vendor/local/include/glib-2.0/gobject/gvaluecollector.h

@@ -0,0 +1,227 @@
+/* GObject - GLib Type, Object, Parameter and Signal Library
+ * Copyright (C) 1998-1999, 2000-2001 Tim Janik and Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * gvaluecollector.h: GValue varargs stubs
+ */
+/**
+ * SECTION:value_collection
+ * @Short_description: Converting varargs to generic values
+ * @See_also:#GValueTable
+ * @Title: Varargs Value Collection
+ * 
+ * The macros in this section provide the varargs parsing support needed
+ * in variadic GObject functions such as g_object_new() or g_object_set().
+ * They currently support the collection of integral types, floating point 
+ * types and pointers.
+ */
+#ifndef __G_VALUE_COLLECTOR_H__
+#define __G_VALUE_COLLECTOR_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* we may want to add aggregate types here some day, if requested
+ * by users. the basic C types are covered already, everything
+ * smaller than an int is promoted to an integer and floats are
+ * always promoted to doubles for varargs call constructions.
+ */
+enum	/*< skip >*/
+{
+  G_VALUE_COLLECT_INT		= 'i',
+  G_VALUE_COLLECT_LONG		= 'l',
+  G_VALUE_COLLECT_INT64         = 'q',
+  G_VALUE_COLLECT_DOUBLE	= 'd',
+  G_VALUE_COLLECT_POINTER	= 'p'
+};
+
+
+/* vararg union holding actual values collected
+ */
+/**
+ * GTypeCValue:
+ * @v_int: the field for holding integer values
+ * @v_long: the field for holding long integer values
+ * @v_int64: the field for holding 64 bit integer values
+ * @v_double: the field for holding floating point values
+ * @v_pointer: the field for holding pointers
+ * 
+ * A union holding one collected value.
+ */
+union _GTypeCValue
+{
+  gint     v_int;
+  glong    v_long;
+  gint64   v_int64;
+  gdouble  v_double;
+  gpointer v_pointer;
+};
+
+/**
+ * G_VALUE_COLLECT_INIT:
+ * @value: a #GValue return location. @value must contain only 0 bytes.
+ * @_value_type: the #GType to use for @value.
+ * @var_args: the va_list variable; it may be evaluated multiple times
+ * @flags: flags which are passed on to the collect_value() function of
+ *  the #GTypeValueTable of @value.
+ * @__error: a #gchar** variable that will be modified to hold a g_new()
+ *  allocated error messages if something fails
+ * 
+ * Collects a variable argument value from a va_list. We have to
+ * implement the varargs collection as a macro, because on some systems
+ * va_list variables cannot be passed by reference.
+ *
+ * Since: 2.24
+ */
+#define G_VALUE_COLLECT_INIT(value, _value_type, var_args, flags, __error)		\
+G_STMT_START {										\
+  GValue *_val = (value);								\
+  guint _flags = (flags);								\
+  GTypeValueTable *_vtab = g_type_value_table_peek (_value_type);			\
+  gchar *_collect_format = _vtab->collect_format;					\
+  GTypeCValue _cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, };		\
+  guint _n_values = 0;									\
+                                                                                        \
+  _val->g_type = _value_type;		/* value_meminit() from gvalue.c */		\
+  while (*_collect_format)								\
+    {											\
+      GTypeCValue *_cvalue = _cvalues + _n_values++;					\
+                                                                                        \
+      switch (*_collect_format++)							\
+	{										\
+	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_INT64:							\
+	  _cvalue->v_int64 = va_arg ((var_args), gint64);				\
+	  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:									\
+	  g_assert_not_reached ();							\
+	}										\
+    }											\
+  *(__error) = _vtab->collect_value (_val,						\
+				       _n_values,					\
+				       _cvalues,					\
+				       _flags);						\
+} G_STMT_END
+
+/**
+ * G_VALUE_COLLECT:
+ * @value: a #GValue return location. @value is supposed to be initialized
+ *  according to the value type to be collected
+ * @var_args: the va_list variable; it may be evaluated multiple times
+ * @flags: flags which are passed on to the collect_value() function of
+ *  the #GTypeValueTable of @value.
+ * @__error: a #gchar** variable that will be modified to hold a g_new()
+ *  allocated error messages if something fails
+ *
+ * Collects a variable argument value from a va_list. We have to
+ * implement the varargs collection as a macro, because on some systems
+ * va_list variables cannot be passed by reference.
+ *
+ * Note: If you are creating the @value argument just before calling this macro,
+ * you should use the #G_VALUE_COLLECT_INIT variant and pass the unitialized
+ * #GValue. That variant is faster than #G_VALUE_COLLECT.
+ */
+#define G_VALUE_COLLECT(value, var_args, flags, __error) G_STMT_START {			\
+  GValue *_value = (value);								\
+  GType _value_type = G_VALUE_TYPE (_value);						\
+  GTypeValueTable *_vtable = g_type_value_table_peek (_value_type);			\
+											\
+  if (_vtable->value_free)								\
+    _vtable->value_free (_value);							\
+  memset (_value->data, 0, sizeof (_value->data));					\
+											\
+  G_VALUE_COLLECT_INIT(value, _value_type, var_args, flags, __error);			\
+} G_STMT_END
+
+/**
+ * G_VALUE_LCOPY:
+ * @value: a #GValue return location. @value is supposed to be initialized 
+ *  according to the value type to be collected
+ * @var_args: the va_list variable; it may be evaluated multiple times
+ * @flags: flags which are passed on to the lcopy_value() function of
+ *  the #GTypeValueTable of @value.
+ * @__error: a #gchar** variable that will be modified to hold a g_new()
+ *  allocated error messages if something fails
+ * 
+ * Collects a value's variable argument locations from a va_list. Usage is
+ * analogous to G_VALUE_COLLECT().
+ */
+#define G_VALUE_LCOPY(value, var_args, flags, __error)					\
+G_STMT_START {										\
+  const GValue *_value = (value);							\
+  guint _flags = (flags);								\
+  GType _value_type = G_VALUE_TYPE (_value);						\
+  GTypeValueTable *_vtable = g_type_value_table_peek (_value_type);			\
+  gchar *_lcopy_format = _vtable->lcopy_format;						\
+  GTypeCValue _cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, };		\
+  guint _n_values = 0;									\
+                                                                                        \
+  while (*_lcopy_format)								\
+    {											\
+      GTypeCValue *_cvalue = _cvalues + _n_values++;					\
+                                                                                        \
+      switch (*_lcopy_format++)								\
+	{										\
+	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_INT64:							\
+	  _cvalue->v_int64 = va_arg ((var_args), gint64);				\
+	  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:									\
+	  g_assert_not_reached ();							\
+	}										\
+    }											\
+  *(__error) = _vtable->lcopy_value (_value,						\
+				     _n_values,						\
+				     _cvalues,						\
+				     _flags);						\
+} G_STMT_END
+
+
+/**
+ * G_VALUE_COLLECT_FORMAT_MAX_LENGTH:
+ * 
+ * The maximal number of #GTypeCValue<!-- -->s which can be collected for a 
+ * single #GValue.
+ */
+#define	G_VALUE_COLLECT_FORMAT_MAX_LENGTH	(8)
+
+G_END_DECLS
+
+#endif /* __G_VALUE_COLLECTOR_H__ */

data/vendor/local/include/glib-2.0/gobject/gvaluetypes.h

@@ -0,0 +1,260 @@
+/* GObject - GLib Type, Object, Parameter and Signal Library
+ * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * gvaluetypes.h: GLib default values
+ */
+#if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION)
+#error "Only <glib-object.h> can be included directly."
+#endif
+
+#ifndef __G_VALUETYPES_H__
+#define __G_VALUETYPES_H__
+
+#include	<gobject/gvalue.h>
+
+G_BEGIN_DECLS
+
+/* --- type macros --- */
+/**
+ * G_VALUE_HOLDS_CHAR:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_CHAR.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_CHAR(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_CHAR))
+/**
+ * G_VALUE_HOLDS_UCHAR:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_UCHAR.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_UCHAR(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UCHAR))
+/**
+ * G_VALUE_HOLDS_BOOLEAN:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_BOOLEAN.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_BOOLEAN(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_BOOLEAN))
+/**
+ * G_VALUE_HOLDS_INT:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_INT.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_INT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_INT))
+/**
+ * G_VALUE_HOLDS_UINT:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_UINT.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_UINT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UINT))
+/**
+ * G_VALUE_HOLDS_LONG:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_LONG.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_LONG(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_LONG))
+/**
+ * G_VALUE_HOLDS_ULONG:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_ULONG.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_ULONG(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_ULONG))
+/**
+ * G_VALUE_HOLDS_INT64:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_INT64.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_INT64(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_INT64))
+/**
+ * G_VALUE_HOLDS_UINT64:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_UINT64.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_UINT64(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_UINT64))
+/**
+ * G_VALUE_HOLDS_FLOAT:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_FLOAT.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_FLOAT(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_FLOAT))
+/**
+ * G_VALUE_HOLDS_DOUBLE:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_DOUBLE.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_DOUBLE(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_DOUBLE))
+/**
+ * G_VALUE_HOLDS_STRING:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_STRING.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_STRING(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_STRING))
+/**
+ * G_VALUE_HOLDS_POINTER:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_POINTER.
+ * 
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_POINTER(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_POINTER))
+/**
+ * G_TYPE_GTYPE:
+ * 
+ * The type for #GType.
+ */
+#define	G_TYPE_GTYPE			 (g_gtype_get_type())
+/**
+ * G_VALUE_HOLDS_GTYPE:
+ * @value: a valid #GValue structure
+ * 
+ * Checks whether the given #GValue can hold values of type %G_TYPE_GTYPE.
+ * 
+ * Since: 2.12
+ * Returns: %TRUE on success.
+ */
+#define G_VALUE_HOLDS_GTYPE(value)	 (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_GTYPE))
+/**
+ * G_VALUE_HOLDS_VARIANT:
+ * @value: a valid #GValue structure
+ *
+ * Checks whether the given #GValue can hold values of type %G_TYPE_VARIANT.
+ *
+ * Returns: %TRUE on success.
+ *
+ * Since: 2.26
+ */
+#define G_VALUE_HOLDS_VARIANT(value)     (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_VARIANT))
+
+
+/* --- prototypes --- */
+void		      g_value_set_char		(GValue	      *value,
+						 gchar	       v_char);
+gchar		      g_value_get_char		(const GValue *value);
+void		      g_value_set_uchar		(GValue	      *value,
+						 guchar	       v_uchar);
+guchar		      g_value_get_uchar		(const GValue *value);
+void		      g_value_set_boolean	(GValue	      *value,
+						 gboolean      v_boolean);
+gboolean	      g_value_get_boolean	(const GValue *value);
+void		      g_value_set_int		(GValue	      *value,
+						 gint	       v_int);
+gint		      g_value_get_int		(const GValue *value);
+void		      g_value_set_uint		(GValue	      *value,
+						 guint	       v_uint);
+guint		      g_value_get_uint		(const GValue *value);
+void		      g_value_set_long		(GValue	      *value,
+						 glong	       v_long);
+glong		      g_value_get_long		(const GValue *value);
+void		      g_value_set_ulong		(GValue	      *value,
+						 gulong	       v_ulong);
+gulong		      g_value_get_ulong		(const GValue *value);
+void		      g_value_set_int64		(GValue	      *value,
+						 gint64	       v_int64);
+gint64		      g_value_get_int64		(const GValue *value);
+void		      g_value_set_uint64	(GValue	      *value,
+						 guint64      v_uint64);
+guint64		      g_value_get_uint64	(const GValue *value);
+void		      g_value_set_float		(GValue	      *value,
+						 gfloat	       v_float);
+gfloat		      g_value_get_float		(const GValue *value);
+void		      g_value_set_double	(GValue	      *value,
+						 gdouble       v_double);
+gdouble		      g_value_get_double	(const GValue *value);
+void		      g_value_set_string	(GValue	      *value,
+						 const gchar  *v_string);
+void		      g_value_set_static_string (GValue	      *value,
+						 const gchar  *v_string);
+G_CONST_RETURN gchar* g_value_get_string	(const GValue *value);
+gchar*		      g_value_dup_string	(const GValue *value);
+void		      g_value_set_pointer	(GValue	      *value,
+						 gpointer      v_pointer);
+gpointer	      g_value_get_pointer	(const GValue *value);
+GType		      g_gtype_get_type		(void);
+void		      g_value_set_gtype	        (GValue	      *value,
+						 GType         v_gtype);
+GType	              g_value_get_gtype	        (const GValue *value);
+void		      g_value_set_variant	(GValue	      *value,
+						 GVariant     *variant);
+void		      g_value_take_variant	(GValue	      *value,
+						 GVariant     *variant);
+GVariant*	      g_value_get_variant	(const GValue *value);
+GVariant*	      g_value_dup_variant	(const GValue *value);
+
+
+/* Convenience for registering new pointer types */
+GType                 g_pointer_type_register_static (const gchar *name);
+
+/* debugging aid, describe value contents as string */
+gchar*                g_strdup_value_contents   (const GValue *value);
+
+
+void g_value_take_string		        (GValue		   *value,
+						 gchar		   *v_string);
+#ifndef G_DISABLE_DEPRECATED
+void g_value_set_string_take_ownership		(GValue		   *value,
+						 gchar		   *v_string);
+#endif
+
+
+/* humpf, need a C representable type name for G_TYPE_STRING */
+/**
+ * gchararray:
+ * 
+ * A C representable type name for #G_TYPE_STRING.
+ */
+typedef gchar* gchararray;
+
+
+G_END_DECLS
+
+#endif /* __G_VALUETYPES_H__ */