@img/sharp-libvips-dev 0.0.1

package/include/glib-2.0/gio/gsocketservice.h

@@ -0,0 +1,95 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright © 2009 Codethink Limited
+ * Copyright © 2009 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/>.
+ *
+ * Authors: Ryan Lortie <desrt@desrt.ca>
+ *          Alexander Larsson <alexl@redhat.com>
+ */
+
+#ifndef __G_SOCKET_SERVICE_H__
+#define __G_SOCKET_SERVICE_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/gsocketlistener.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_SOCKET_SERVICE                               (g_socket_service_get_type ())
+#define G_SOCKET_SERVICE(inst)                              (G_TYPE_CHECK_INSTANCE_CAST ((inst),                     \
+                                                             G_TYPE_SOCKET_SERVICE, GSocketService))
+#define G_SOCKET_SERVICE_CLASS(class)                       (G_TYPE_CHECK_CLASS_CAST ((class),                       \
+                                                             G_TYPE_SOCKET_SERVICE, GSocketServiceClass))
+#define G_IS_SOCKET_SERVICE(inst)                           (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                     \
+                                                             G_TYPE_SOCKET_SERVICE))
+#define G_IS_SOCKET_SERVICE_CLASS(class)                    (G_TYPE_CHECK_CLASS_TYPE ((class),                       \
+                                                             G_TYPE_SOCKET_SERVICE))
+#define G_SOCKET_SERVICE_GET_CLASS(inst)                    (G_TYPE_INSTANCE_GET_CLASS ((inst),                      \
+                                                             G_TYPE_SOCKET_SERVICE, GSocketServiceClass))
+
+typedef struct _GSocketServicePrivate                       GSocketServicePrivate;
+typedef struct _GSocketServiceClass                         GSocketServiceClass;
+
+/**
+ * GSocketServiceClass:
+ * @incoming: signal emitted when new connections are accepted
+ *
+ * Class structure for #GSocketService.
+ */
+struct _GSocketServiceClass
+{
+  GSocketListenerClass parent_class;
+
+  gboolean (* incoming) (GSocketService    *service,
+                         GSocketConnection *connection,
+			 GObject           *source_object);
+
+  /* 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);
+};
+
+struct _GSocketService
+{
+  GSocketListener parent_instance;
+  GSocketServicePrivate *priv;
+};
+
+GIO_AVAILABLE_IN_ALL
+GType           g_socket_service_get_type  (void);
+
+GIO_AVAILABLE_IN_ALL
+GSocketService *g_socket_service_new       (void);
+GIO_AVAILABLE_IN_ALL
+void            g_socket_service_start     (GSocketService *service);
+GIO_AVAILABLE_IN_ALL
+void            g_socket_service_stop      (GSocketService *service);
+GIO_AVAILABLE_IN_ALL
+gboolean        g_socket_service_is_active (GSocketService *service);
+
+
+G_END_DECLS
+
+#endif /* __G_SOCKET_SERVICE_H__ */

package/include/glib-2.0/gio/gsrvtarget.h

@@ -0,0 +1,60 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2008 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/>.
+ */
+
+#ifndef __G_SRV_TARGET_H__
+#define __G_SRV_TARGET_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+GIO_AVAILABLE_IN_ALL
+GType g_srv_target_get_type (void) G_GNUC_CONST;
+#define G_TYPE_SRV_TARGET (g_srv_target_get_type ())
+
+GIO_AVAILABLE_IN_ALL
+GSrvTarget  *g_srv_target_new          (const gchar *hostname,
+				        guint16      port,
+				        guint16      priority,
+				        guint16      weight);
+GIO_AVAILABLE_IN_ALL
+GSrvTarget  *g_srv_target_copy         (GSrvTarget  *target);
+GIO_AVAILABLE_IN_ALL
+void         g_srv_target_free         (GSrvTarget  *target);
+
+GIO_AVAILABLE_IN_ALL
+const gchar *g_srv_target_get_hostname (GSrvTarget  *target);
+GIO_AVAILABLE_IN_ALL
+guint16      g_srv_target_get_port     (GSrvTarget  *target);
+GIO_AVAILABLE_IN_ALL
+guint16      g_srv_target_get_priority (GSrvTarget  *target);
+GIO_AVAILABLE_IN_ALL
+guint16      g_srv_target_get_weight   (GSrvTarget  *target);
+
+GIO_AVAILABLE_IN_ALL
+GList       *g_srv_target_list_sort    (GList       *targets);
+
+G_END_DECLS
+
+#endif /* __G_SRV_TARGET_H__ */

package/include/glib-2.0/gio/gsubprocess.h

@@ -0,0 +1,169 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright (C) 2012 Colin Walters <walters@verbum.org>
+ *
+ * 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/>.
+ *
+ * Author: Colin Walters <walters@verbum.org>
+ */
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#ifndef __G_SUBPROCESS_H__
+#define __G_SUBPROCESS_H__
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_SUBPROCESS         (g_subprocess_get_type ())
+#define G_SUBPROCESS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_SUBPROCESS, GSubprocess))
+#define G_IS_SUBPROCESS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_SUBPROCESS))
+
+GIO_AVAILABLE_IN_2_40
+GType            g_subprocess_get_type                  (void) G_GNUC_CONST;
+
+/**** Core API ****/
+
+GIO_AVAILABLE_IN_2_40
+GSubprocess *    g_subprocess_new                       (GSubprocessFlags        flags,
+                                                         GError                **error,
+                                                         const gchar            *argv0,
+                                                         ...) G_GNUC_NULL_TERMINATED;
+GIO_AVAILABLE_IN_2_40
+GSubprocess *    g_subprocess_newv                      (const gchar * const  *argv,
+                                                         GSubprocessFlags      flags,
+                                                         GError              **error);
+
+GIO_AVAILABLE_IN_2_40
+GOutputStream *  g_subprocess_get_stdin_pipe            (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+GInputStream *   g_subprocess_get_stdout_pipe           (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+GInputStream *   g_subprocess_get_stderr_pipe           (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+const gchar *    g_subprocess_get_identifier            (GSubprocess          *subprocess);
+
+#ifdef G_OS_UNIX
+GIO_AVAILABLE_IN_2_40
+void             g_subprocess_send_signal               (GSubprocess          *subprocess,
+                                                         gint                  signal_num);
+#endif
+
+GIO_AVAILABLE_IN_2_40
+void             g_subprocess_force_exit                (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+gboolean         g_subprocess_wait                      (GSubprocess          *subprocess,
+                                                         GCancellable         *cancellable,
+                                                         GError              **error);
+
+GIO_AVAILABLE_IN_2_40
+void             g_subprocess_wait_async                (GSubprocess          *subprocess,
+                                                         GCancellable         *cancellable,
+                                                         GAsyncReadyCallback   callback,
+                                                         gpointer              user_data);
+
+GIO_AVAILABLE_IN_2_40
+gboolean         g_subprocess_wait_finish               (GSubprocess          *subprocess,
+                                                         GAsyncResult         *result,
+                                                         GError              **error);
+
+GIO_AVAILABLE_IN_2_40
+gboolean         g_subprocess_wait_check                (GSubprocess          *subprocess,
+                                                         GCancellable         *cancellable,
+                                                         GError              **error);
+
+GIO_AVAILABLE_IN_2_40
+void             g_subprocess_wait_check_async          (GSubprocess          *subprocess,
+                                                         GCancellable         *cancellable,
+                                                         GAsyncReadyCallback   callback,
+                                                         gpointer              user_data);
+
+GIO_AVAILABLE_IN_2_40
+gboolean         g_subprocess_wait_check_finish         (GSubprocess          *subprocess,
+                                                         GAsyncResult         *result,
+                                                         GError              **error);
+
+
+GIO_AVAILABLE_IN_2_40
+gint             g_subprocess_get_status                (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+gboolean         g_subprocess_get_successful            (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+gboolean         g_subprocess_get_if_exited             (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+gint             g_subprocess_get_exit_status           (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+gboolean         g_subprocess_get_if_signaled           (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+gint             g_subprocess_get_term_sig              (GSubprocess          *subprocess);
+
+GIO_AVAILABLE_IN_2_40
+gboolean         g_subprocess_communicate               (GSubprocess          *subprocess,
+                                                         GBytes               *stdin_buf,
+                                                         GCancellable         *cancellable,
+                                                         GBytes              **stdout_buf,
+                                                         GBytes              **stderr_buf,
+                                                         GError              **error);
+GIO_AVAILABLE_IN_2_40
+void            g_subprocess_communicate_async          (GSubprocess          *subprocess,
+                                                         GBytes               *stdin_buf,
+                                                         GCancellable         *cancellable,
+                                                         GAsyncReadyCallback   callback,
+                                                         gpointer              user_data);
+
+GIO_AVAILABLE_IN_2_40
+gboolean        g_subprocess_communicate_finish         (GSubprocess          *subprocess,
+                                                         GAsyncResult         *result,
+                                                         GBytes              **stdout_buf,
+                                                         GBytes              **stderr_buf,
+                                                         GError              **error);
+
+GIO_AVAILABLE_IN_2_40
+gboolean         g_subprocess_communicate_utf8          (GSubprocess          *subprocess,
+                                                         const char           *stdin_buf,
+                                                         GCancellable         *cancellable,
+                                                         char                **stdout_buf,
+                                                         char                **stderr_buf,
+                                                         GError              **error);
+GIO_AVAILABLE_IN_2_40
+void            g_subprocess_communicate_utf8_async     (GSubprocess          *subprocess,
+                                                         const char           *stdin_buf,
+                                                         GCancellable         *cancellable,
+                                                         GAsyncReadyCallback   callback,
+                                                         gpointer              user_data);
+
+GIO_AVAILABLE_IN_2_40
+gboolean        g_subprocess_communicate_utf8_finish    (GSubprocess          *subprocess,
+                                                         GAsyncResult         *result,
+                                                         char                **stdout_buf,
+                                                         char                **stderr_buf,
+                                                         GError              **error);
+
+G_END_DECLS
+
+#endif /* __G_SUBPROCESS_H__ */

package/include/glib-2.0/gio/gsubprocesslauncher.h

@@ -0,0 +1,121 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright © 2012,2013 Colin Walters <walters@verbum.org>
+ * Copyright © 2012,2013 Canonical Limited
+ *
+ * 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/>.
+ *
+ * Author: Ryan Lortie <desrt@desrt.ca>
+ * Author: Colin Walters <walters@verbum.org>
+ */
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#ifndef __G_SUBPROCESS_LAUNCHER_H__
+#define __G_SUBPROCESS_LAUNCHER_H__
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_SUBPROCESS_LAUNCHER         (g_subprocess_launcher_get_type ())
+#define G_SUBPROCESS_LAUNCHER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_SUBPROCESS_LAUNCHER, GSubprocessLauncher))
+#define G_IS_SUBPROCESS_LAUNCHER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_SUBPROCESS_LAUNCHER))
+
+GIO_AVAILABLE_IN_2_40
+GType                   g_subprocess_launcher_get_type                  (void) G_GNUC_CONST;
+
+GIO_AVAILABLE_IN_2_40
+GSubprocessLauncher *   g_subprocess_launcher_new                       (GSubprocessFlags       flags);
+
+GIO_AVAILABLE_IN_2_40
+GSubprocess *           g_subprocess_launcher_spawn                     (GSubprocessLauncher   *self,
+                                                                         GError               **error,
+                                                                         const gchar           *argv0,
+                                                                         ...) G_GNUC_NULL_TERMINATED;
+
+GIO_AVAILABLE_IN_2_40
+GSubprocess *           g_subprocess_launcher_spawnv                    (GSubprocessLauncher   *self,
+                                                                         const gchar * const   *argv,
+                                                                         GError               **error);
+
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_set_environ               (GSubprocessLauncher   *self,
+                                                                         gchar                **env);
+
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_setenv                    (GSubprocessLauncher   *self,
+                                                                         const gchar           *variable,
+                                                                         const gchar           *value,
+                                                                         gboolean               overwrite);
+
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_unsetenv                  (GSubprocessLauncher *self,
+                                                                         const gchar         *variable);
+
+GIO_AVAILABLE_IN_2_40
+const gchar *           g_subprocess_launcher_getenv                    (GSubprocessLauncher   *self,
+                                                                         const gchar           *variable);
+
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_set_cwd                   (GSubprocessLauncher   *self,
+                                                                         const gchar           *cwd);
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_set_flags                 (GSubprocessLauncher   *self,
+                                                                         GSubprocessFlags       flags);
+
+/* Extended I/O control, only available on UNIX */
+#ifdef G_OS_UNIX
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_set_stdin_file_path       (GSubprocessLauncher   *self,
+                                                                         const gchar           *path);
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_take_stdin_fd             (GSubprocessLauncher   *self,
+                                                                         gint                   fd);
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_set_stdout_file_path      (GSubprocessLauncher   *self,
+                                                                         const gchar           *path);
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_take_stdout_fd            (GSubprocessLauncher   *self,
+                                                                         gint                   fd);
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_set_stderr_file_path      (GSubprocessLauncher   *self,
+                                                                         const gchar           *path);
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_take_stderr_fd            (GSubprocessLauncher   *self,
+                                                                         gint                   fd);
+
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_take_fd                   (GSubprocessLauncher   *self,
+                                                                         gint                   source_fd,
+                                                                         gint                   target_fd);
+
+GIO_AVAILABLE_IN_2_68
+void                    g_subprocess_launcher_close                     (GSubprocessLauncher      *self);
+
+/* Child setup, only available on UNIX */
+GIO_AVAILABLE_IN_2_40
+void                    g_subprocess_launcher_set_child_setup           (GSubprocessLauncher   *self,
+                                                                         GSpawnChildSetupFunc   child_setup,
+                                                                         gpointer               user_data,
+                                                                         GDestroyNotify         destroy_notify);
+#endif
+
+G_END_DECLS
+
+#endif /* __G_SUBPROCESS_H__ */

package/include/glib-2.0/gio/gtask.h

@@ -0,0 +1,207 @@
+/* GIO - GLib Input, Output and Streaming Library
+ *
+ * Copyright 2011 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/>.
+ */
+
+#ifndef __G_TASK_H__
+#define __G_TASK_H__
+
+#if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
+#error "Only <gio/gio.h> can be included directly."
+#endif
+
+#include <gio/giotypes.h>
+
+G_BEGIN_DECLS
+
+#define G_TYPE_TASK         (g_task_get_type ())
+#define G_TASK(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_TASK, GTask))
+#define G_TASK_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_TASK, GTaskClass))
+#define G_IS_TASK(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_TASK))
+#define G_IS_TASK_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_TASK))
+#define G_TASK_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_TASK, GTaskClass))
+
+typedef struct _GTaskClass   GTaskClass;
+
+GIO_AVAILABLE_IN_2_36
+GType         g_task_get_type              (void) G_GNUC_CONST;
+
+GIO_AVAILABLE_IN_2_36
+GTask        *g_task_new                   (gpointer             source_object,
+                                            GCancellable        *cancellable,
+                                            GAsyncReadyCallback  callback,
+                                            gpointer             callback_data);
+
+GIO_AVAILABLE_IN_2_36
+void          g_task_report_error          (gpointer             source_object,
+                                            GAsyncReadyCallback  callback,
+                                            gpointer             callback_data,
+                                            gpointer             source_tag,
+                                            GError              *error);
+GIO_AVAILABLE_IN_2_36
+void          g_task_report_new_error      (gpointer             source_object,
+                                            GAsyncReadyCallback  callback,
+                                            gpointer             callback_data,
+                                            gpointer             source_tag,
+                                            GQuark               domain,
+                                            gint                 code,
+                                            const char          *format,
+                                            ...) G_GNUC_PRINTF(7, 8);
+
+GIO_AVAILABLE_IN_2_36
+void          g_task_set_task_data         (GTask               *task,
+                                            gpointer             task_data,
+                                            GDestroyNotify       task_data_destroy);
+GIO_AVAILABLE_IN_2_36
+void          g_task_set_priority          (GTask               *task,
+                                            gint                 priority);
+GIO_AVAILABLE_IN_2_36
+void          g_task_set_check_cancellable (GTask               *task,
+                                            gboolean             check_cancellable);
+GIO_AVAILABLE_IN_2_36
+void          g_task_set_source_tag        (GTask               *task,
+                                            gpointer             source_tag);
+GIO_AVAILABLE_IN_2_60
+void          g_task_set_name              (GTask               *task,
+                                            const gchar         *name);
+GIO_AVAILABLE_IN_2_76
+void          g_task_set_static_name       (GTask               *task,
+                                            const gchar         *name);
+
+/* Macro wrapper to set the task name when setting the source tag. */
+#if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_76
+#define g_task_set_source_tag(task, tag) G_STMT_START { \
+  GTask *_task = (task); \
+  (g_task_set_source_tag) (_task, tag); \
+  if (g_task_get_name (_task) == NULL) \
+    g_task_set_static_name (_task, G_STRINGIFY (tag)); \
+} G_STMT_END
+#endif
+
+#if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_76
+#if defined (__GNUC__) && (__GNUC__ >= 2)
+#define g_task_set_name(task, name) G_STMT_START { \
+  GTask *_task = (task); \
+  if (__builtin_constant_p (name)) \
+    g_task_set_static_name (_task, name); \
+  else \
+    g_task_set_name (_task, name); \
+} G_STMT_END
+#endif
+#endif
+
+GIO_AVAILABLE_IN_2_36
+gpointer      g_task_get_source_object     (GTask               *task);
+GIO_AVAILABLE_IN_2_36
+gpointer      g_task_get_task_data         (GTask               *task);
+GIO_AVAILABLE_IN_2_36
+gint          g_task_get_priority          (GTask               *task);
+GIO_AVAILABLE_IN_2_36
+GMainContext *g_task_get_context           (GTask               *task);
+GIO_AVAILABLE_IN_2_36
+GCancellable *g_task_get_cancellable       (GTask               *task);
+GIO_AVAILABLE_IN_2_36
+gboolean      g_task_get_check_cancellable (GTask               *task);
+GIO_AVAILABLE_IN_2_36
+gpointer      g_task_get_source_tag        (GTask               *task);
+GIO_AVAILABLE_IN_2_60
+const gchar  *g_task_get_name              (GTask               *task);
+
+GIO_AVAILABLE_IN_2_36
+gboolean      g_task_is_valid              (gpointer             result,
+                                            gpointer             source_object);
+
+
+typedef void (*GTaskThreadFunc)           (GTask           *task,
+                                           gpointer         source_object,
+                                           gpointer         task_data,
+                                           GCancellable    *cancellable);
+GIO_AVAILABLE_IN_2_36
+void          g_task_run_in_thread        (GTask           *task,
+                                           GTaskThreadFunc  task_func);
+GIO_AVAILABLE_IN_2_36
+void          g_task_run_in_thread_sync   (GTask           *task,
+                                           GTaskThreadFunc  task_func);
+GIO_AVAILABLE_IN_2_36
+gboolean      g_task_set_return_on_cancel (GTask           *task,
+                                           gboolean         return_on_cancel);
+GIO_AVAILABLE_IN_2_36
+gboolean      g_task_get_return_on_cancel (GTask           *task);
+
+GIO_AVAILABLE_IN_2_36
+void          g_task_attach_source        (GTask           *task,
+                                           GSource         *source,
+                                           GSourceFunc      callback);
+
+
+GIO_AVAILABLE_IN_2_36
+void          g_task_return_pointer            (GTask           *task,
+                                                gpointer         result,
+                                                GDestroyNotify   result_destroy);
+GIO_AVAILABLE_IN_2_36
+void          g_task_return_boolean            (GTask           *task,
+                                                gboolean         result);
+GIO_AVAILABLE_IN_2_36
+void          g_task_return_int                (GTask           *task,
+                                                gssize           result);
+
+GIO_AVAILABLE_IN_2_36
+void          g_task_return_error              (GTask           *task,
+                                                GError          *error);
+GIO_AVAILABLE_IN_2_36
+void          g_task_return_new_error          (GTask           *task,
+                                                GQuark           domain,
+                                                gint             code,
+                                                const char      *format,
+                                                ...) G_GNUC_PRINTF (4, 5);
+GIO_AVAILABLE_IN_2_64
+void          g_task_return_value              (GTask           *task,
+                                                GValue          *result);
+
+GIO_AVAILABLE_IN_2_36
+gboolean      g_task_return_error_if_cancelled (GTask           *task);
+
+GIO_AVAILABLE_IN_2_36
+gpointer      g_task_propagate_pointer         (GTask           *task,
+                                                GError         **error);
+GIO_AVAILABLE_IN_2_36
+gboolean      g_task_propagate_boolean         (GTask           *task,
+                                                GError         **error);
+GIO_AVAILABLE_IN_2_36
+gssize        g_task_propagate_int             (GTask           *task,
+                                                GError         **error);
+GIO_AVAILABLE_IN_2_64
+gboolean      g_task_propagate_value           (GTask           *task,
+                                                GValue          *value,
+                                                GError         **error);
+GIO_AVAILABLE_IN_2_36
+gboolean      g_task_had_error                 (GTask           *task);
+GIO_AVAILABLE_IN_2_44
+gboolean      g_task_get_completed             (GTask           *task);
+
+/*< private >*/
+#ifndef __GTK_DOC_IGNORE__
+#ifndef __GI_SCANNER__
+/* Debugging API, not part of the public API */
+void g_task_print_alive_tasks (void);
+#endif /* !__GI_SCANNER__ */
+#endif  /* !__GTK_DOC_IGNORE__ */
+
+G_END_DECLS
+
+#endif /* __G_TASK_H__ */