glib2 0.90.2-x86-mingw32

data/vendor/local/include/glib-2.0/gio/goutputstream.h

@@ -0,0 +1,207 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2006-2007 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.
+ *
+ * Author: Alexander Larsson <alexl@redhat.com>
+ */
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#ifndef __G_OUTPUT_STREAM_H__
+#define __G_OUTPUT_STREAM_H__
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_OUTPUT_STREAM         (g_output_stream_get_type ())
+#define G_OUTPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_OUTPUT_STREAM, GOutputStream))
+#define G_OUTPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_OUTPUT_STREAM, GOutputStreamClass))
+#define G_IS_OUTPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_OUTPUT_STREAM))
+#define G_IS_OUTPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_OUTPUT_STREAM))
+#define G_OUTPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_OUTPUT_STREAM, GOutputStreamClass))
+
+/**
+ * GOutputStream:
+ *
+ * Base class for writing output.
+ *
+ * All classes derived from GOutputStream should implement synchronous
+ * writing, splicing, flushing and closing streams, but may implement
+ * asynchronous versions.
+ **/
+typedef struct _GOutputStreamClass    GOutputStreamClass;
+typedef struct _GOutputStreamPrivate  GOutputStreamPrivate;
+
+struct _GOutputStream
+{
+  GObject parent_instance;
+
+  /*< private >*/
+  GOutputStreamPrivate *priv;
+};
+
+
+struct _GOutputStreamClass
+{
+  GObjectClass parent_class;
+
+  /* Sync ops: */
+
+  gssize      (* write_fn)      (GOutputStream            *stream,
+                                 const void               *buffer,
+                                 gsize                     count,
+                                 GCancellable             *cancellable,
+                                 GError                  **error);
+  gssize      (* splice)        (GOutputStream            *stream,
+                                 GInputStream             *source,
+                                 GOutputStreamSpliceFlags  flags,
+                                 GCancellable             *cancellable,
+                                 GError                  **error);
+  gboolean    (* flush)	        (GOutputStream            *stream,
+                                 GCancellable             *cancellable,
+                                 GError                  **error);
+  gboolean    (* close_fn)      (GOutputStream            *stream,
+                                 GCancellable             *cancellable,
+                                 GError                  **error);
+
+  /* Async ops: (optional in derived classes) */
+
+  void        (* write_async)   (GOutputStream            *stream,
+                                 const void               *buffer,
+                                 gsize                     count,
+                                 int                       io_priority,
+                                 GCancellable             *cancellable,
+                                 GAsyncReadyCallback       callback,
+                                 gpointer                  user_data);
+  gssize      (* write_finish)  (GOutputStream            *stream,
+                                 GAsyncResult             *result,
+                                 GError                  **error);
+  void        (* splice_async)  (GOutputStream            *stream,
+                                 GInputStream             *source,
+                                 GOutputStreamSpliceFlags  flags,
+                                 int                       io_priority,
+                                 GCancellable             *cancellable,
+                                 GAsyncReadyCallback       callback,
+                                 gpointer                  data);
+  gssize      (* splice_finish) (GOutputStream            *stream,
+                                 GAsyncResult             *result,
+                                 GError                  **error);
+  void        (* flush_async)   (GOutputStream            *stream,
+                                 int                       io_priority,
+                                 GCancellable             *cancellable,
+                                 GAsyncReadyCallback       callback,
+                                 gpointer                  user_data);
+  gboolean    (* flush_finish)  (GOutputStream            *stream,
+                                 GAsyncResult             *result,
+                                 GError                  **error);
+  void        (* close_async)   (GOutputStream            *stream,
+                                 int                       io_priority,
+                                 GCancellable             *cancellable,
+                                 GAsyncReadyCallback       callback,
+                                 gpointer                  user_data);
+  gboolean    (* close_finish)  (GOutputStream            *stream,
+                                 GAsyncResult             *result,
+                                 GError                  **error);
+
+  /*< private >*/
+  /* Padding for future expansion */
+  void (*_g_reserved1) (void);
+  void (*_g_reserved2) (void);
+  void (*_g_reserved3) (void);
+  void (*_g_reserved4) (void);
+  void (*_g_reserved5) (void);
+  void (*_g_reserved6) (void);
+  void (*_g_reserved7) (void);
+  void (*_g_reserved8) (void);
+};
+
+GType    g_output_stream_get_type      (void) G_GNUC_CONST;
+
+gssize   g_output_stream_write         (GOutputStream             *stream,
+					const void                *buffer,
+					gsize                      count,
+					GCancellable              *cancellable,
+					GError                   **error);
+gboolean g_output_stream_write_all     (GOutputStream             *stream,
+					const void                *buffer,
+					gsize                      count,
+					gsize                     *bytes_written,
+					GCancellable              *cancellable,
+					GError                   **error);
+gssize   g_output_stream_splice        (GOutputStream             *stream,
+					GInputStream              *source,
+					GOutputStreamSpliceFlags   flags,
+					GCancellable              *cancellable,
+					GError                   **error);
+gboolean g_output_stream_flush         (GOutputStream             *stream,
+					GCancellable              *cancellable,
+					GError                   **error);
+gboolean g_output_stream_close         (GOutputStream             *stream,
+					GCancellable              *cancellable,
+					GError                   **error);
+void     g_output_stream_write_async   (GOutputStream             *stream,
+					const void                *buffer,
+					gsize                      count,
+					int                        io_priority,
+					GCancellable              *cancellable,
+					GAsyncReadyCallback        callback,
+					gpointer                   user_data);
+gssize   g_output_stream_write_finish  (GOutputStream             *stream,
+					GAsyncResult              *result,
+					GError                   **error);
+void     g_output_stream_splice_async  (GOutputStream             *stream,
+					GInputStream              *source,
+					GOutputStreamSpliceFlags   flags,
+					int                        io_priority,
+					GCancellable              *cancellable,
+					GAsyncReadyCallback        callback,
+					gpointer                   user_data);
+gssize   g_output_stream_splice_finish (GOutputStream             *stream,
+					GAsyncResult              *result,
+					GError                   **error);
+void     g_output_stream_flush_async   (GOutputStream             *stream,
+					int                        io_priority,
+					GCancellable              *cancellable,
+					GAsyncReadyCallback        callback,
+					gpointer                   user_data);
+gboolean g_output_stream_flush_finish  (GOutputStream             *stream,
+					GAsyncResult              *result,
+					GError                   **error);
+void     g_output_stream_close_async   (GOutputStream             *stream,
+					int                        io_priority,
+					GCancellable              *cancellable,
+					GAsyncReadyCallback        callback,
+					gpointer                   user_data);
+gboolean g_output_stream_close_finish  (GOutputStream             *stream,
+					GAsyncResult              *result,
+					GError                   **error);
+
+gboolean g_output_stream_is_closed     (GOutputStream             *stream);
+gboolean g_output_stream_is_closing    (GOutputStream             *stream);
+gboolean g_output_stream_has_pending   (GOutputStream             *stream);
+gboolean g_output_stream_set_pending   (GOutputStream             *stream,
+					GError                   **error);
+void     g_output_stream_clear_pending (GOutputStream             *stream);
+
+
+G_END_DECLS
+
+#endif /* __G_OUTPUT_STREAM_H__ */

data/vendor/local/include/glib-2.0/gio/gresolver.h

@@ -0,0 +1,167 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2008 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.
+ */
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#ifndef __G_RESOLVER_H__
+#define __G_RESOLVER_H__
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_RESOLVER         (g_resolver_get_type ())
+#define G_RESOLVER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_RESOLVER, GResolver))
+#define G_RESOLVER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_RESOLVER, GResolverClass))
+#define G_IS_RESOLVER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_RESOLVER))
+#define G_IS_RESOLVER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_RESOLVER))
+#define G_RESOLVER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_RESOLVER, GResolverClass))
+
+typedef struct _GResolverPrivate GResolverPrivate;
+typedef struct _GResolverClass   GResolverClass;
+
+struct _GResolver {
+  GObject parent_instance;
+
+  GResolverPrivate *priv;
+};
+
+struct _GResolverClass {
+  GObjectClass parent_class;
+
+  /* Signals */
+  void    ( *reload)                   (GResolver            *resolver);
+
+  /* Virtual methods */
+  GList * ( *lookup_by_name)           (GResolver            *resolver,
+					const gchar          *hostname,
+					GCancellable         *cancellable,
+					GError              **error);
+  void    ( *lookup_by_name_async)     (GResolver            *resolver,
+					const gchar          *hostname,
+					GCancellable         *cancellable,
+					GAsyncReadyCallback   callback,
+					gpointer              user_data);
+  GList * ( *lookup_by_name_finish)    (GResolver            *resolver,
+					GAsyncResult         *result,
+					GError              **error);
+
+  gchar * ( *lookup_by_address)        (GResolver            *resolver,
+					GInetAddress         *address,
+					GCancellable         *cancellable,
+					GError              **error);
+  void    ( *lookup_by_address_async)  (GResolver            *resolver,
+					GInetAddress         *address,
+					GCancellable         *cancellable,
+					GAsyncReadyCallback   callback,
+					gpointer              user_data);
+  gchar * ( *lookup_by_address_finish) (GResolver            *resolver,
+					GAsyncResult         *result,
+					GError              **error);
+
+  GList * ( *lookup_service)           (GResolver            *resolver,
+					const gchar          *rrname,
+					GCancellable         *cancellable,
+					GError              **error);
+  void    ( *lookup_service_async)     (GResolver            *resolver,
+					const gchar          *rrname,
+					GCancellable         *cancellable,
+					GAsyncReadyCallback   callback,
+					gpointer              user_data);
+  GList * ( *lookup_service_finish)    (GResolver            *resolver,
+					GAsyncResult         *result,
+					GError              **error);
+
+  /* Padding for future expansion */
+  void (*_g_reserved1) (void);
+  void (*_g_reserved2) (void);
+  void (*_g_reserved3) (void);
+  void (*_g_reserved4) (void);
+  void (*_g_reserved5) (void);
+  void (*_g_reserved6) (void);
+
+};
+
+GType      g_resolver_get_type                  (void) G_GNUC_CONST;
+GResolver *g_resolver_get_default               (void);
+void       g_resolver_set_default               (GResolver            *resolver);
+
+GList     *g_resolver_lookup_by_name            (GResolver            *resolver,
+						 const gchar          *hostname,
+						 GCancellable         *cancellable,
+						 GError              **error);
+void       g_resolver_lookup_by_name_async      (GResolver            *resolver,
+						 const gchar          *hostname,
+						 GCancellable         *cancellable,
+						 GAsyncReadyCallback   callback,
+						 gpointer              user_data);
+GList     *g_resolver_lookup_by_name_finish     (GResolver            *resolver,
+						 GAsyncResult         *result,
+						 GError              **error);
+
+void       g_resolver_free_addresses            (GList                *addresses);
+
+gchar     *g_resolver_lookup_by_address         (GResolver            *resolver,
+						 GInetAddress         *address,
+						 GCancellable         *cancellable,
+						 GError              **error);
+void       g_resolver_lookup_by_address_async   (GResolver            *resolver,
+						 GInetAddress         *address,
+						 GCancellable         *cancellable,
+						 GAsyncReadyCallback   callback,
+						 gpointer              user_data);
+gchar     *g_resolver_lookup_by_address_finish  (GResolver            *resolver,
+						 GAsyncResult         *result,
+						 GError              **error);
+
+GList     *g_resolver_lookup_service            (GResolver            *resolver,
+						 const gchar          *service,
+						 const gchar          *protocol,
+						 const gchar          *domain,
+						 GCancellable         *cancellable,
+						 GError              **error);
+void       g_resolver_lookup_service_async      (GResolver            *resolver,
+						 const gchar          *service,
+						 const gchar          *protocol,
+						 const gchar          *domain,
+						 GCancellable         *cancellable,
+						 GAsyncReadyCallback   callback,
+						 gpointer              user_data);
+GList     *g_resolver_lookup_service_finish     (GResolver            *resolver,
+						 GAsyncResult         *result,
+						 GError              **error);
+
+void       g_resolver_free_targets              (GList                *targets);
+
+/**
+ * G_RESOLVER_ERROR:
+ *
+ * Error domain for #GResolver. Errors in this domain will be from the
+ * #GResolverError enumeration. See #GError for more information on
+ * error domains.
+ */
+#define G_RESOLVER_ERROR (g_resolver_error_quark ())
+GQuark g_resolver_error_quark (void);
+
+G_END_DECLS
+
+#endif /* __G_RESOLVER_H__ */

data/vendor/local/include/glib-2.0/gio/gseekable.h

@@ -0,0 +1,99 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2006-2007 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.
+ *
+ * Author: Alexander Larsson <alexl@redhat.com>
+ */
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#ifndef __G_SEEKABLE_H__
+#define __G_SEEKABLE_H__
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_SEEKABLE            (g_seekable_get_type ())
+#define G_SEEKABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SEEKABLE, GSeekable))
+#define G_IS_SEEKABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_SEEKABLE))
+#define G_SEEKABLE_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_TYPE_SEEKABLE, GSeekableIface))
+
+/**
+ * GSeekable:
+ *
+ * Seek object for streaming operations.
+ **/
+typedef struct _GSeekableIface   GSeekableIface;
+
+/**
+ * GSeekableIface:
+ * @g_iface: The parent interface.
+ * @tell: Tells the current location within a stream.
+ * @can_seek: Checks if seeking is supported by the stream.
+ * @seek: Seeks to a location within a stream.
+ * @can_truncate: Chekcs if truncation is suppored by the stream.
+ * @truncate_fn: Truncates a stream.
+ *
+ * Provides an interface for implementing seekable functionality on I/O Streams.
+ **/
+struct _GSeekableIface
+{
+  GTypeInterface g_iface;
+
+  /* Virtual Table */
+
+  goffset     (* tell)	         (GSeekable    *seekable);
+
+  gboolean    (* can_seek)       (GSeekable    *seekable);
+  gboolean    (* seek)	         (GSeekable    *seekable,
+				  goffset       offset,
+				  GSeekType     type,
+				  GCancellable *cancellable,
+				  GError      **error);
+
+  gboolean    (* can_truncate)   (GSeekable    *seekable);
+  gboolean    (* truncate_fn)    (GSeekable    *seekable,
+				  goffset       offset,
+				  GCancellable *cancellable,
+				  GError       **error);
+
+  /* TODO: Async seek/truncate */
+};
+
+GType    g_seekable_get_type     (void) G_GNUC_CONST;
+
+goffset  g_seekable_tell         (GSeekable     *seekable);
+gboolean g_seekable_can_seek     (GSeekable     *seekable);
+gboolean g_seekable_seek         (GSeekable     *seekable,
+				  goffset        offset,
+				  GSeekType      type,
+				  GCancellable  *cancellable,
+				  GError       **error);
+gboolean g_seekable_can_truncate (GSeekable     *seekable);
+gboolean g_seekable_truncate     (GSeekable     *seekable,
+				  goffset        offset,
+				  GCancellable  *cancellable,
+				  GError       **error);
+
+G_END_DECLS
+
+
+#endif /* __G_SEEKABLE_H__ */

data/vendor/local/include/glib-2.0/gio/gsimpleasyncresult.h

@@ -0,0 +1,125 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2006-2007 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.
+ *
+ * Author: Alexander Larsson <alexl@redhat.com>
+ */
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#ifndef __G_SIMPLE_ASYNC_RESULT_H__
+#define __G_SIMPLE_ASYNC_RESULT_H__
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_SIMPLE_ASYNC_RESULT         (g_simple_async_result_get_type ())
+#define G_SIMPLE_ASYNC_RESULT(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_SIMPLE_ASYNC_RESULT, GSimpleAsyncResult))
+#define G_SIMPLE_ASYNC_RESULT_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_SIMPLE_ASYNC_RESULT, GSimpleAsyncResultClass))
+#define G_IS_SIMPLE_ASYNC_RESULT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_SIMPLE_ASYNC_RESULT))
+#define G_IS_SIMPLE_ASYNC_RESULT_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_SIMPLE_ASYNC_RESULT))
+#define G_SIMPLE_ASYNC_RESULT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_SIMPLE_ASYNC_RESULT, GSimpleAsyncResultClass))
+
+/**
+ * GSimpleAsyncResult:
+ *
+ * A simple implementation of #GAsyncResult.
+ **/
+typedef struct _GSimpleAsyncResultClass   GSimpleAsyncResultClass;
+
+
+GType               g_simple_async_result_get_type         (void) G_GNUC_CONST;
+
+GSimpleAsyncResult *g_simple_async_result_new              (GObject                 *source_object,
+							    GAsyncReadyCallback      callback,
+							    gpointer                 user_data,
+							    gpointer                 source_tag);
+GSimpleAsyncResult *g_simple_async_result_new_error        (GObject                 *source_object,
+							    GAsyncReadyCallback      callback,
+							    gpointer                 user_data,
+							    GQuark                   domain,
+							    gint                     code,
+							    const char              *format,
+							    ...) G_GNUC_PRINTF (6, 7);
+GSimpleAsyncResult *g_simple_async_result_new_from_error   (GObject                 *source_object,
+							    GAsyncReadyCallback      callback,
+							    gpointer                 user_data,
+							    GError                  *error);
+
+void                g_simple_async_result_set_op_res_gpointer (GSimpleAsyncResult      *simple,
+                                                               gpointer                 op_res,
+                                                               GDestroyNotify           destroy_op_res);
+gpointer            g_simple_async_result_get_op_res_gpointer (GSimpleAsyncResult      *simple);
+
+void                g_simple_async_result_set_op_res_gssize   (GSimpleAsyncResult      *simple,
+                                                               gssize                   op_res);
+gssize              g_simple_async_result_get_op_res_gssize   (GSimpleAsyncResult      *simple);
+
+void                g_simple_async_result_set_op_res_gboolean (GSimpleAsyncResult      *simple,
+                                                               gboolean                 op_res);
+gboolean            g_simple_async_result_get_op_res_gboolean (GSimpleAsyncResult      *simple);
+
+
+
+gpointer            g_simple_async_result_get_source_tag   (GSimpleAsyncResult      *simple);
+void                g_simple_async_result_set_handle_cancellation (GSimpleAsyncResult      *simple,
+								   gboolean          handle_cancellation);
+void                g_simple_async_result_complete         (GSimpleAsyncResult      *simple);
+void                g_simple_async_result_complete_in_idle (GSimpleAsyncResult      *simple);
+void                g_simple_async_result_run_in_thread    (GSimpleAsyncResult      *simple,
+							    GSimpleAsyncThreadFunc   func,
+							    int                      io_priority,
+							    GCancellable            *cancellable);
+void                g_simple_async_result_set_from_error   (GSimpleAsyncResult      *simple,
+							    const GError            *error);
+gboolean            g_simple_async_result_propagate_error  (GSimpleAsyncResult      *simple,
+							    GError                 **dest);
+void                g_simple_async_result_set_error        (GSimpleAsyncResult      *simple,
+							    GQuark                   domain,
+							    gint                     code,
+							    const char              *format,
+							    ...) G_GNUC_PRINTF (4, 5);
+void                g_simple_async_result_set_error_va     (GSimpleAsyncResult      *simple,
+							    GQuark                   domain,
+							    gint                     code,
+							    const char              *format,
+							    va_list                  args);
+gboolean            g_simple_async_result_is_valid         (GAsyncResult            *result,
+                                                            GObject                 *source,
+                                                            gpointer                 source_tag);
+
+void g_simple_async_report_error_in_idle  (GObject            *object,
+					   GAsyncReadyCallback callback,
+					   gpointer            user_data,
+					   GQuark              domain,
+					   gint                code,
+					   const char         *format,
+					   ...);
+void g_simple_async_report_gerror_in_idle (GObject            *object,
+					   GAsyncReadyCallback callback,
+					   gpointer            user_data,
+					   GError             *error);
+
+G_END_DECLS
+
+
+
+#endif /* __G_SIMPLE_ASYNC_RESULT_H__ */