@img/sharp-libvips-dev 0.0.1

package/include/glib-2.0/gobject/gvaluearray.h

@@ -0,0 +1,106 @@
+/* GObject - GLib Type, Object, Parameter and Signal Library
+ * Copyright (C) 2001 Red Hat, Inc.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * 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.1 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, see <http://www.gnu.org/licenses/>.
+ *
+ * gvaluearray.h: GLib array type holding GValues
+ */
+#ifndef __G_VALUE_ARRAY_H__
+#define __G_VALUE_ARRAY_H__
+
+#if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION)
+#error "Only <glib-object.h> can be included directly."
+#endif
+
+#include	<gobject/gvalue.h>
+
+G_BEGIN_DECLS
+
+/**
+ * G_TYPE_VALUE_ARRAY:
+ *
+ * The type ID of the "GValueArray" type which is a boxed type,
+ * used to pass around pointers to GValueArrays.
+ *
+ * Deprecated: 2.32: Use #GArray instead of #GValueArray
+ */
+#define G_TYPE_VALUE_ARRAY (g_value_array_get_type ()) GOBJECT_DEPRECATED_MACRO_IN_2_32_FOR(G_TYPE_ARRAY)
+
+/* --- 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 --- */
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GType           g_value_array_get_type       (void) G_GNUC_CONST;
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GValue*		g_value_array_get_nth	     (GValueArray	*value_array,
+					      guint		 index_);
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GValueArray*	g_value_array_new	     (guint		 n_prealloced);
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+void		g_value_array_free	     (GValueArray	*value_array);
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GValueArray*	g_value_array_copy	     (const GValueArray *value_array);
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GValueArray*	g_value_array_prepend	     (GValueArray	*value_array,
+					      const GValue	*value);
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GValueArray*	g_value_array_append	     (GValueArray	*value_array,
+					      const GValue	*value);
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GValueArray*	g_value_array_insert	     (GValueArray	*value_array,
+					      guint		 index_,
+					      const GValue	*value);
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GValueArray*	g_value_array_remove	     (GValueArray	*value_array,
+					      guint		 index_);
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GValueArray*	g_value_array_sort	     (GValueArray	*value_array,
+					      GCompareFunc	 compare_func);
+
+GOBJECT_DEPRECATED_IN_2_32_FOR(GArray)
+GValueArray*	g_value_array_sort_with_data (GValueArray	*value_array,
+					      GCompareDataFunc	 compare_func,
+					      gpointer		 user_data);
+
+
+G_END_DECLS
+
+#endif /* __G_VALUE_ARRAY_H__ */

package/include/glib-2.0/gobject/gvaluecollector.h

@@ -0,0 +1,290 @@
+/* GObject - GLib Type, Object, Parameter and Signal Library
+ * Copyright (C) 1998-1999, 2000-2001 Tim Janik and Red Hat, Inc.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * 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.1 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, see <http://www.gnu.org/licenses/>.
+ *
+ * gvaluecollector.h: GValue varargs stubs
+ */
+/**
+ * SECTION:value_collection
+ * @Short_description: Converting varargs to generic values
+ * @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 { \
+    GTypeValueTable *g_vci_vtab; \
+    G_VALUE_COLLECT_INIT2(value, g_vci_vtab, _value_type, var_args, flags, __error); \
+} G_STMT_END
+
+/**
+ * G_VALUE_COLLECT_INIT2:
+ * @value: a #GValue return location. @value must contain only 0 bytes.
+ * @g_vci_vtab: a #GTypeValueTable pointer that will be set to the value table
+ *   for @_value_type
+ * @_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
+ *
+ * A variant of G_VALUE_COLLECT_INIT() that provides the #GTypeValueTable
+ * to the caller.
+ *
+ * Since: 2.74
+ */
+#define G_VALUE_COLLECT_INIT2(value, g_vci_vtab, _value_type, var_args, flags, __error)		\
+G_STMT_START {										\
+  GValue *g_vci_val = (value);								\
+  guint g_vci_flags = (flags);								\
+  const gchar *g_vci_collect_format; \
+  GTypeCValue g_vci_cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, };		\
+  guint g_vci_n_values = 0;									\
+  g_vci_vtab = g_type_value_table_peek (_value_type);			\
+  g_vci_collect_format = g_vci_vtab->collect_format;					\
+  g_vci_val->g_type = _value_type;		/* value_meminit() from gvalue.c */		\
+  while (*g_vci_collect_format)								\
+    {											\
+      GTypeCValue *g_vci_cvalue = g_vci_cvalues + g_vci_n_values++;					\
+                                                                                        \
+      switch (*g_vci_collect_format++)							\
+	{										\
+	case G_VALUE_COLLECT_INT:							\
+	  g_vci_cvalue->v_int = va_arg ((var_args), gint);					\
+	  break;									\
+	case G_VALUE_COLLECT_LONG:							\
+	  g_vci_cvalue->v_long = va_arg ((var_args), glong);					\
+	  break;									\
+	case G_VALUE_COLLECT_INT64:							\
+	  g_vci_cvalue->v_int64 = va_arg ((var_args), gint64);				\
+	  break;									\
+	case G_VALUE_COLLECT_DOUBLE:							\
+	  g_vci_cvalue->v_double = va_arg ((var_args), gdouble);				\
+	  break;									\
+	case G_VALUE_COLLECT_POINTER:							\
+	  g_vci_cvalue->v_pointer = va_arg ((var_args), gpointer);				\
+	  break;									\
+	default:									\
+	  g_assert_not_reached ();							\
+	}										\
+    }											\
+  *(__error) = g_vci_vtab->collect_value (g_vci_val,						\
+				       g_vci_n_values,					\
+				       g_vci_cvalues,					\
+				       g_vci_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 uninitialized
+ * #GValue. That variant is faster than G_VALUE_COLLECT().
+ */
+#define G_VALUE_COLLECT(value, var_args, flags, __error) G_STMT_START {			\
+  GValue *g_vc_value = (value);								\
+  GType g_vc_value_type = G_VALUE_TYPE (g_vc_value);						\
+  GTypeValueTable *g_vc_vtable = g_type_value_table_peek (g_vc_value_type);			\
+											\
+  if (g_vc_vtable->value_free)								\
+    g_vc_vtable->value_free (g_vc_value);							\
+  memset (g_vc_value->data, 0, sizeof (g_vc_value->data));					\
+											\
+  G_VALUE_COLLECT_INIT(value, g_vc_value_type, var_args, flags, __error);			\
+} G_STMT_END
+
+/**
+ * G_VALUE_COLLECT_SKIP:
+ * @_value_type: the #GType of the value to skip
+ * @var_args: the va_list variable; it may be evaluated multiple times
+ *
+ * Skip an argument of type @_value_type from @var_args.
+ */
+#define G_VALUE_COLLECT_SKIP(_value_type, var_args)					\
+G_STMT_START {										\
+  GTypeValueTable *g_vcs_vtable = g_type_value_table_peek (_value_type);			\
+  const gchar *g_vcs_collect_format = g_vcs_vtable->collect_format;				\
+                                                                                        \
+  while (*g_vcs_collect_format)								\
+    {											\
+      switch (*g_vcs_collect_format++)							\
+	{										\
+	case G_VALUE_COLLECT_INT:							\
+	  va_arg ((var_args), gint);							\
+	  break;									\
+	case G_VALUE_COLLECT_LONG:							\
+	  va_arg ((var_args), glong);							\
+	  break;									\
+	case G_VALUE_COLLECT_INT64:							\
+	  va_arg ((var_args), gint64);							\
+	  break;									\
+	case G_VALUE_COLLECT_DOUBLE:							\
+	  va_arg ((var_args), gdouble);							\
+	  break;									\
+	case G_VALUE_COLLECT_POINTER:							\
+	  va_arg ((var_args), gpointer);						\
+	  break;									\
+	default:									\
+	  g_assert_not_reached ();							\
+	}										\
+    }											\
+} G_STMT_END
+
+/**
+ * G_VALUE_LCOPY:
+ * @value: a #GValue to store into the @var_args; this must be initialized
+ *  and set
+ * @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 message if something fails
+ *
+ * Stores a value’s value into one or more argument locations from a `va_list`.
+ *
+ * This is the inverse of G_VALUE_COLLECT().
+ */
+#define G_VALUE_LCOPY(value, var_args, flags, __error)					\
+G_STMT_START {										\
+  const GValue *g_vl_value = (value);							\
+  guint g_vl_flags = (flags);								\
+  GType g_vl_value_type = G_VALUE_TYPE (g_vl_value);						\
+  GTypeValueTable *g_vl_vtable = g_type_value_table_peek (g_vl_value_type);			\
+  const gchar *g_vl_lcopy_format = g_vl_vtable->lcopy_format;					\
+  GTypeCValue g_vl_cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, };		\
+  guint g_vl_n_values = 0;									\
+                                                                                        \
+  while (*g_vl_lcopy_format)								\
+    {											\
+      GTypeCValue *g_vl_cvalue = g_vl_cvalues + g_vl_n_values++;					\
+                                                                                        \
+      switch (*g_vl_lcopy_format++)								\
+	{										\
+	case G_VALUE_COLLECT_INT:							\
+	  g_vl_cvalue->v_int = va_arg ((var_args), gint);					\
+	  break;									\
+	case G_VALUE_COLLECT_LONG:							\
+	  g_vl_cvalue->v_long = va_arg ((var_args), glong);					\
+	  break;									\
+	case G_VALUE_COLLECT_INT64:							\
+	  g_vl_cvalue->v_int64 = va_arg ((var_args), gint64);				\
+	  break;									\
+	case G_VALUE_COLLECT_DOUBLE:							\
+	  g_vl_cvalue->v_double = va_arg ((var_args), gdouble);				\
+	  break;									\
+	case G_VALUE_COLLECT_POINTER:							\
+	  g_vl_cvalue->v_pointer = va_arg ((var_args), gpointer);				\
+	  break;									\
+	default:									\
+	  g_assert_not_reached ();							\
+	}										\
+    }											\
+  *(__error) = g_vl_vtable->lcopy_value (g_vl_value,						\
+				     g_vl_n_values,						\
+				     g_vl_cvalues,						\
+				     g_vl_flags);						\
+} G_STMT_END
+
+
+/**
+ * G_VALUE_COLLECT_FORMAT_MAX_LENGTH:
+ * 
+ * The maximal number of #GTypeCValues which can be collected for a 
+ * single #GValue.
+ */
+#define	G_VALUE_COLLECT_FORMAT_MAX_LENGTH	(8)
+
+G_END_DECLS
+
+#endif /* __G_VALUE_COLLECTOR_H__ */

package/include/glib-2.0/gobject/gvaluetypes.h

@@ -0,0 +1,318 @@
+/* GObject - GLib Type, Object, Parameter and Signal Library
+ * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ *
+ * 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.1 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, see <http://www.gnu.org/licenses/>.
+ *
+ * gvaluetypes.h: GLib default values
+ */
+#ifndef __G_VALUETYPES_H__
+#define __G_VALUETYPES_H__
+
+#if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION)
+#error "Only <glib-object.h> can be included directly."
+#endif
+
+#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_IS_INTERNED_STRING:
+ * @value: a valid #GValue structure
+ *
+ * Checks whether @value contains a string which is canonical.
+ *
+ * Returns: %TRUE if the value contains a string in its canonical
+ * representation, as returned by g_intern_string(). See also
+ * g_value_set_interned_string().
+ *
+ * Since: 2.66
+ */
+#define G_VALUE_IS_INTERNED_STRING(value) (G_VALUE_HOLDS_STRING (value) && ((value)->data[1].v_uint & G_VALUE_INTERNED_STRING)) GOBJECT_AVAILABLE_MACRO_IN_2_66
+/**
+ * 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 --- */
+GOBJECT_DEPRECATED_IN_2_32_FOR(g_value_set_schar)
+void                  g_value_set_char          (GValue       *value,
+                                                 gchar         v_char);
+GOBJECT_DEPRECATED_IN_2_32_FOR(g_value_get_schar)
+gchar                 g_value_get_char          (const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_schar		(GValue	      *value,
+						 gint8	       v_char);
+GOBJECT_AVAILABLE_IN_ALL
+gint8		      g_value_get_schar		(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_uchar		(GValue	      *value,
+						 guchar	       v_uchar);
+GOBJECT_AVAILABLE_IN_ALL
+guchar		      g_value_get_uchar		(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_boolean	(GValue	      *value,
+						 gboolean      v_boolean);
+GOBJECT_AVAILABLE_IN_ALL
+gboolean	      g_value_get_boolean	(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_int		(GValue	      *value,
+						 gint	       v_int);
+GOBJECT_AVAILABLE_IN_ALL
+gint		      g_value_get_int		(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_uint		(GValue	      *value,
+						 guint	       v_uint);
+GOBJECT_AVAILABLE_IN_ALL
+guint		      g_value_get_uint		(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_long		(GValue	      *value,
+						 glong	       v_long);
+GOBJECT_AVAILABLE_IN_ALL
+glong		      g_value_get_long		(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_ulong		(GValue	      *value,
+						 gulong	       v_ulong);
+GOBJECT_AVAILABLE_IN_ALL
+gulong		      g_value_get_ulong		(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_int64		(GValue	      *value,
+						 gint64	       v_int64);
+GOBJECT_AVAILABLE_IN_ALL
+gint64		      g_value_get_int64		(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_uint64	(GValue	      *value,
+						 guint64      v_uint64);
+GOBJECT_AVAILABLE_IN_ALL
+guint64		      g_value_get_uint64	(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_float		(GValue	      *value,
+						 gfloat	       v_float);
+GOBJECT_AVAILABLE_IN_ALL
+gfloat		      g_value_get_float		(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_double	(GValue	      *value,
+						 gdouble       v_double);
+GOBJECT_AVAILABLE_IN_ALL
+gdouble		      g_value_get_double	(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_string	(GValue	      *value,
+						 const gchar  *v_string);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_static_string (GValue	      *value,
+						 const gchar  *v_string);
+GOBJECT_AVAILABLE_IN_2_66
+void		      g_value_set_interned_string (GValue      *value,
+						   const gchar  *v_string);
+GOBJECT_AVAILABLE_IN_ALL
+const gchar *         g_value_get_string	(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+gchar*		      g_value_dup_string	(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_pointer	(GValue	      *value,
+						 gpointer      v_pointer);
+GOBJECT_AVAILABLE_IN_ALL
+gpointer	      g_value_get_pointer	(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+GType		      g_gtype_get_type		(void);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_gtype	        (GValue	      *value,
+						 GType         v_gtype);
+GOBJECT_AVAILABLE_IN_ALL
+GType	              g_value_get_gtype	        (const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_set_variant	(GValue	      *value,
+						 GVariant     *variant);
+GOBJECT_AVAILABLE_IN_ALL
+void		      g_value_take_variant	(GValue	      *value,
+						 GVariant     *variant);
+GOBJECT_AVAILABLE_IN_ALL
+GVariant*	      g_value_get_variant	(const GValue *value);
+GOBJECT_AVAILABLE_IN_ALL
+GVariant*	      g_value_dup_variant	(const GValue *value);
+
+
+/* Convenience for registering new pointer types */
+GOBJECT_AVAILABLE_IN_ALL
+GType                 g_pointer_type_register_static (const gchar *name);
+
+/* debugging aid, describe value contents as string */
+GOBJECT_AVAILABLE_IN_ALL
+gchar*                g_strdup_value_contents   (const GValue *value);
+
+
+GOBJECT_AVAILABLE_IN_ALL
+void g_value_take_string		        (GValue		   *value,
+						 gchar		   *v_string);
+GOBJECT_DEPRECATED_FOR(g_value_take_string)
+void g_value_set_string_take_ownership          (GValue            *value,
+                                                 gchar             *v_string);
+
+
+/* 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__ */