[glibmm] Regenerated the -methods.defs files.

From: Murray Cumming <murrayc src gnome org>
To: commits-list gnome org
Cc:
Subject: [glibmm] Regenerated the -methods.defs files.
Date: Thu, 21 Mar 2013 09:43:04 +0000 (UTC)
commit 7d209e16e094d22d9f79f41b4c591c03d7eebfd3
Author: Murray Cumming <murrayc murrayc com>
Date:   Tue Mar 19 11:18:48 2013 +0100

    Regenerated the -methods.defs files.
    
        * gio/src/gio_methods.xml:
        * glib/src/glib_functions.xml:
        * glib/src/gmodule_functions.xml:
        * glib/src/gobject_functions.xml: Regenerated using
        tools/gen_scripts/gio_generate_methods.sh and
        tools/gen_scripts/glib_generate_methods.sh,
        with a slight hand-edit to avoid the problem in
        gioschedule.h with h2def.py (see previous commit).

 ChangeLog                       |   18 +-
 gio/src/gio_methods.defs        |  887 ++++++++++++++++++++++++++++++++++++++-
 glib/src/glib_functions.defs    |  566 ++++++++++++++++++++++++-
 glib/src/gmodule_functions.defs |   15 +
 glib/src/gobject_functions.defs |  625 +++++++++++++++++++++++++++-
 5 files changed, 2077 insertions(+), 34 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index ec8069e..3e71fa4 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,18 @@
 2013-03-19  Murray Cumming  <murrayc murrayc com>
 
+       Regenerated the -methods.defs files.
+
+       * gio/src/gio_methods.xml:
+       * glib/src/glib_functions.xml: 
+       * glib/src/gmodule_functions.xml: 
+       * glib/src/gobject_functions.xml: Regenerated using
+       tools/gen_scripts/gio_generate_methods.sh and
+       tools/gen_scripts/glib_generate_methods.sh,
+       with a slight hand-edit to avoid the problem in
+       gioschedule.h with h2def.py (see previous commit).
+
+2013-03-19  Murray Cumming  <murrayc murrayc com>
+
        h2def.py: Handle GLIB_AVAILABLE_IN_ALL
 
        * tools/defs_gen/h2def.py: Do not just ignore
@@ -12,17 +25,16 @@
 
 2013-03-19  Murray Cumming  <murrayc murrayc com>
 
-       Regenereated the -enums.defs files.
+       Regenerated the -enums.defs files.
 
        * gio/src/gio_enums.xml:
        * glib/src/glib_enums.xml: Regenerated using
        tools/gen_scripts/gio_generate_enums.sh and
        tools/gen_scripts/glib_generate_enums.sh.
 
-
 2013-03-19  Murray Cumming  <murrayc murrayc com>
 
-       Regenereated the -docs.xml files.
+       Regenerated the -docs.xml files.
 
        * gio/src/gio_docs.xml:
        * glib/src/glib_docs.xml: Regenerated using
diff --git a/gio/src/gio_methods.defs b/gio/src/gio_methods.defs
index 9db65c7..be03a9e 100644
--- a/gio/src/gio_methods.defs
+++ b/gio/src/gio_methods.defs
@@ -481,6 +481,13 @@
   (gtype-id "G_TYPE_SIMPLE_ACTION_GROUP")
 )
 
+(define-object ProxyResolver
+  (in-module "GSimple")
+  (parent "GObject")
+  (c-name "GSimpleProxyResolver")
+  (gtype-id "G_TYPE_SIMPLE_PROXY_RESOLVER")
+)
+
 (define-object t
   (in-module "GSocke")
   (parent "GObject")
@@ -936,6 +943,7 @@
     '("none" "G_FILE_MONITOR_NONE")
     '("watch-mounts" "G_FILE_MONITOR_WATCH_MOUNTS")
     '("send-moved" "G_FILE_MONITOR_SEND_MOVED")
+    '("watch-hard-links" "G_FILE_MONITOR_WATCH_HARD_LINKS")
   )
 )
 
@@ -1030,6 +1038,7 @@
     '("proxy-auth-failed" "G_IO_ERROR_PROXY_AUTH_FAILED")
     '("proxy-need-auth" "G_IO_ERROR_PROXY_NEED_AUTH")
     '("proxy-not-allowed" "G_IO_ERROR_PROXY_NOT_ALLOWED")
+    '("broken-pipe" "G_IO_ERROR_BROKEN_PIPE")
   )
 )
 
@@ -2254,6 +2263,12 @@
   )
 )
 
+(define-method get_stdin
+  (of-object "GApplicationCommandLine")
+  (c-name "g_application_command_line_get_stdin")
+  (return-type "GInputStream*")
+)
+
 (define-method get_environ
   (of-object "GApplicationCommandLine")
   (c-name "g_application_command_line_get_environ")
@@ -2322,6 +2337,15 @@
   (return-type "GVariant*")
 )
 
+(define-method create_file_for_arg
+  (of-object "GApplicationCommandLine")
+  (c-name "g_application_command_line_create_file_for_arg")
+  (return-type "GFile*")
+  (parameters
+    '("const-gchar*" "arg")
+  )
+)
+
 
 
 ;; From gapplication.h
@@ -2497,6 +2521,75 @@
 
 ;; From gapplicationimpl.h
 
+(define-method destroy
+  (of-object "GApplicationImpl")
+  (c-name "g_application_impl_destroy")
+  (return-type "none")
+)
+
+(define-method impl_register
+  (of-object "GApplication")
+  (c-name "g_application_impl_register")
+  (return-type "GApplicationImpl*")
+  (parameters
+    '("const-gchar*" "appid")
+    '("GApplicationFlags" "flags")
+    '("GActionGroup*" "exported_actions")
+    '("GRemoteActionGroup**" "remote_actions")
+    '("GCancellable*" "cancellable")
+    '("GError**" "error")
+  )
+)
+
+(define-method activate
+  (of-object "GApplicationImpl")
+  (c-name "g_application_impl_activate")
+  (return-type "none")
+  (parameters
+    '("GVariant*" "platform_data")
+  )
+)
+
+(define-method open
+  (of-object "GApplicationImpl")
+  (c-name "g_application_impl_open")
+  (return-type "none")
+  (parameters
+    '("GFile**" "files")
+    '("gint" "n_files")
+    '("const-gchar*" "hint")
+    '("GVariant*" "platform_data")
+  )
+)
+
+(define-method command_line
+  (of-object "GApplicationImpl")
+  (c-name "g_application_impl_command_line")
+  (return-type "int")
+  (parameters
+    '("gchar**" "arguments")
+    '("GVariant*" "platform_data")
+  )
+)
+
+(define-method flush
+  (of-object "GApplicationImpl")
+  (c-name "g_application_impl_flush")
+  (return-type "none")
+)
+
+(define-method get_dbus_connection
+  (of-object "GApplicationImpl")
+  (c-name "g_application_impl_get_dbus_connection")
+  (return-type "GDBusConnection*")
+)
+
+(define-method get_dbus_object_path
+  (of-object "GApplicationImpl")
+  (c-name "g_application_impl_get_dbus_object_path")
+  (return-type "const-gchar*")
+)
+
 
 
 ;; From gasynchelper.h
@@ -3187,6 +3280,15 @@
   )
 )
 
+(define-method get_unix_pid
+  (of-object "GCredentials")
+  (c-name "g_credentials_get_unix_pid")
+  (return-type "pid_t")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
 (define-method get_unix_user
   (of-object "GCredentials")
   (c-name "g_credentials_get_unix_user")
@@ -3596,8 +3698,30 @@
 
 
 
+;; From gdbusactiongroup-private.h
+
+(define-method sync
+  (of-object "GDBusActionGroup")
+  (c-name "g_dbus_action_group_sync")
+  (return-type "gboolean")
+  (parameters
+    '("GCancellable*" "cancellable")
+    '("GError**" "error")
+  )
+)
+
+
+
 ;; From gdbusaddress.h
 
+(define-function g_dbus_address_escape_value
+  (c-name "g_dbus_address_escape_value")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "string")
+  )
+)
+
 (define-function g_dbus_is_address
   (c-name "g_dbus_is_address")
   (return-type "gboolean")
@@ -6090,6 +6214,40 @@
 
 ;; From gdelayedsettingsbackend.h
 
+(define-function g_delayed_settings_backend_get_type
+  (c-name "g_delayed_settings_backend_get_type")
+  (return-type "GType")
+)
+
+(define-function g_delayed_settings_backend_new
+  (c-name "g_delayed_settings_backend_new")
+  (is-constructor-of "GDelayedSettingsBackend")
+  (return-type "GDelayedSettingsBackend*")
+  (parameters
+    '("GSettingsBackend*" "backend")
+    '("gpointer" "owner")
+    '("GMainContext*" "owner_context")
+  )
+)
+
+(define-method revert
+  (of-object "GDelayedSettingsBackend")
+  (c-name "g_delayed_settings_backend_revert")
+  (return-type "none")
+)
+
+(define-method apply
+  (of-object "GDelayedSettingsBackend")
+  (c-name "g_delayed_settings_backend_apply")
+  (return-type "none")
+)
+
+(define-method get_has_unapplied
+  (of-object "GDelayedSettingsBackend")
+  (c-name "g_delayed_settings_backend_get_has_unapplied")
+  (return-type "gboolean")
+)
+
 
 
 ;; From gdesktopappinfo.h
@@ -6183,6 +6341,33 @@
   )
 )
 
+(define-method has_key
+  (of-object "GDesktopAppInfo")
+  (c-name "g_desktop_app_info_has_key")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "key")
+  )
+)
+
+(define-method get_string
+  (of-object "GDesktopAppInfo")
+  (c-name "g_desktop_app_info_get_string")
+  (return-type "char*")
+  (parameters
+    '("const-char*" "key")
+  )
+)
+
+(define-method get_boolean
+  (of-object "GDesktopAppInfo")
+  (c-name "g_desktop_app_info_get_boolean")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "key")
+  )
+)
+
 (define-function g_desktop_app_info_lookup_get_type
   (c-name "g_desktop_app_info_lookup_get_type")
   (return-type "GType")
@@ -6709,6 +6894,15 @@
   (return-type "GFile*")
 )
 
+(define-method get_child
+  (of-object "GFileEnumerator")
+  (c-name "g_file_enumerator_get_child")
+  (return-type "GFile*")
+  (parameters
+    '("GFileInfo*" "info")
+  )
+)
+
 
 
 ;; From gfile.h
@@ -6742,6 +6936,15 @@
   )
 )
 
+(define-function g_file_new_for_commandline_arg_and_cwd
+  (c-name "g_file_new_for_commandline_arg_and_cwd")
+  (return-type "GFile*")
+  (parameters
+    '("const-gchar*" "arg")
+    '("const-gchar*" "cwd")
+  )
+)
+
 (define-function g_file_new_tmp
   (c-name "g_file_new_tmp")
   (return-type "GFile*")
@@ -8291,6 +8494,12 @@
   (return-type "none")
 )
 
+(define-method get_deletion_date
+  (of-object "GFileInfo")
+  (c-name "g_file_info_get_deletion_date")
+  (return-type "GDateTime*")
+)
+
 (define-method get_file_type
   (of-object "GFileInfo")
   (c-name "g_file_info_get_file_type")
@@ -10286,6 +10495,11 @@
   )
 )
 
+(define-function g_memory_output_stream_new_resizable
+  (c-name "g_memory_output_stream_new_resizable")
+  (return-type "GOutputStream*")
+)
+
 (define-method get_data
   (of-object "GMemoryOutputStream")
   (c-name "g_memory_output_stream_get_data")
@@ -11225,8 +11439,34 @@
 
 
 
+;; From gnetworking.h
+
+(define-function g_networking_init
+  (c-name "g_networking_init")
+  (return-type "none")
+)
+
+
+
 ;; From gnetworkingprivate.h
 
+(define-method get_serial
+  (of-object "GResolver")
+  (c-name "g_resolver_get_serial")
+  (return-type "guint64")
+)
+
+(define-function g_socket
+  (c-name "g_socket")
+  (return-type "gint")
+  (parameters
+    '("gint" "domain")
+    '("gint" "type")
+    '("gint" "protocol")
+    '("GError**" "error")
+  )
+)
+
 
 
 ;; From gnetworkmonitorbase.h
@@ -12040,6 +12280,11 @@
 
 ;; From gregistrysettingsbackend.h
 
+(define-function g_registry_backend_get_type
+  (c-name "g_registry_backend_get_type")
+  (return-type "GType")
+)
+
 
 
 ;; From gremoteactiongroup.h
@@ -12577,6 +12822,129 @@
 
 ;; From gsettingsbackendinternal.h
 
+(define-method watch
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_watch")
+  (return-type "none")
+  (parameters
+    '("const-GSettingsListenerVTable*" "vtable")
+    '("GObject*" "target")
+    '("GMainContext*" "context")
+  )
+)
+
+(define-method unwatch
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_unwatch")
+  (return-type "none")
+  (parameters
+    '("GObject*" "target")
+  )
+)
+
+(define-function g_settings_backend_create_tree
+  (c-name "g_settings_backend_create_tree")
+  (return-type "GTree*")
+)
+
+(define-method read
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_read")
+  (return-type "GVariant*")
+  (parameters
+    '("const-gchar*" "key")
+    '("const-GVariantType*" "expected_type")
+    '("gboolean" "default_value")
+  )
+)
+
+(define-method write
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_write")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+    '("GVariant*" "value")
+    '("gpointer" "origin_tag")
+  )
+)
+
+(define-method write_tree
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_write_tree")
+  (return-type "gboolean")
+  (parameters
+    '("GTree*" "tree")
+    '("gpointer" "origin_tag")
+  )
+)
+
+(define-method reset
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_reset")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "key")
+    '("gpointer" "origin_tag")
+  )
+)
+
+(define-method get_writable
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_get_writable")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "key")
+  )
+)
+
+(define-method unsubscribe
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_unsubscribe")
+  (return-type "none")
+  (parameters
+    '("const-char*" "name")
+  )
+)
+
+(define-method subscribe
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_subscribe")
+  (return-type "none")
+  (parameters
+    '("const-char*" "name")
+  )
+)
+
+(define-method get_permission
+  (of-object "GSettingsBackend")
+  (c-name "g_settings_backend_get_permission")
+  (return-type "GPermission*")
+  (parameters
+    '("const-gchar*" "path")
+  )
+)
+
+(define-function g_settings_backend_sync_default
+  (c-name "g_settings_backend_sync_default")
+  (return-type "none")
+)
+
+(define-function g_null_settings_backend_get_type
+  (c-name "g_null_settings_backend_get_type")
+  (return-type "GType")
+)
+
+(define-function g_memory_settings_backend_get_type
+  (c-name "g_memory_settings_backend_get_type")
+  (return-type "GType")
+)
+
+(define-function g_nextstep_settings_backend_get_type
+  (c-name "g_nextstep_settings_backend_get_type")
+  (return-type "GType")
+)
+
 
 
 ;; From gsettings.h
@@ -12996,11 +13364,40 @@
 
 ;; From gsettings-mapping.h
 
-
-
-;; From gsettingsschema.h
-
-(define-function g_settings_schema_source_get_type
+(define-function g_settings_set_mapping
+  (c-name "g_settings_set_mapping")
+  (return-type "GVariant*")
+  (parameters
+    '("const-GValue*" "value")
+    '("const-GVariantType*" "expected_type")
+    '("gpointer" "user_data")
+  )
+)
+
+(define-function g_settings_get_mapping
+  (c-name "g_settings_get_mapping")
+  (return-type "gboolean")
+  (parameters
+    '("GValue*" "value")
+    '("GVariant*" "variant")
+    '("gpointer" "user_data")
+  )
+)
+
+(define-function g_settings_mapping_is_compatible
+  (c-name "g_settings_mapping_is_compatible")
+  (return-type "gboolean")
+  (parameters
+    '("GType" "gvalue_type")
+    '("const-GVariantType*" "variant_type")
+  )
+)
+
+
+
+;; From gsettingsschema.h
+
+(define-function g_settings_schema_source_get_type
   (c-name "g_settings_schema_source_get_type")
   (return-type "GType")
 )
@@ -13076,6 +13473,133 @@
 
 ;; From gsettingsschema-internal.h
 
+(define-method get_gettext_domain
+  (of-object "GSettingsSchema")
+  (c-name "g_settings_schema_get_gettext_domain")
+  (return-type "const-gchar*")
+)
+
+(define-method get_value
+  (of-object "GSettingsSchema")
+  (c-name "g_settings_schema_get_value")
+  (return-type "GVariantIter*")
+  (parameters
+    '("const-gchar*" "key")
+  )
+)
+
+(define-method has_key
+  (of-object "GSettingsSchema")
+  (c-name "g_settings_schema_has_key")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+  )
+)
+
+(define-method list
+  (of-object "GSettingsSchema")
+  (c-name "g_settings_schema_list")
+  (return-type "const-GQuark*")
+  (parameters
+    '("gint*" "n_items")
+  )
+)
+
+(define-method get_string
+  (of-object "GSettingsSchema")
+  (c-name "g_settings_schema_get_string")
+  (return-type "const-gchar*")
+  (parameters
+    '("const-gchar*" "key")
+  )
+)
+
+(define-method init
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_init")
+  (return-type "none")
+  (parameters
+    '("GSettingsSchema*" "schema")
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method clear
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_clear")
+  (return-type "none")
+)
+
+(define-method type_check
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_type_check")
+  (return-type "gboolean")
+  (parameters
+    '("GVariant*" "value")
+  )
+)
+
+(define-method range_check
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_range_check")
+  (return-type "gboolean")
+  (parameters
+    '("GVariant*" "value")
+  )
+)
+
+(define-method range_fixup
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_range_fixup")
+  (return-type "GVariant*")
+  (parameters
+    '("GVariant*" "value")
+  )
+)
+
+(define-method get_translated_default
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_get_translated_default")
+  (return-type "GVariant*")
+)
+
+(define-method to_enum
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_to_enum")
+  (return-type "gint")
+  (parameters
+    '("GVariant*" "value")
+  )
+)
+
+(define-method from_enum
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_from_enum")
+  (return-type "GVariant*")
+  (parameters
+    '("gint" "value")
+  )
+)
+
+(define-method to_flags
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_to_flags")
+  (return-type "guint")
+  (parameters
+    '("GVariant*" "value")
+  )
+)
+
+(define-method from_flags
+  (of-object "GSettingsSchemaKey")
+  (c-name "g_settings_schema_key_from_flags")
+  (return-type "GVariant*")
+  (parameters
+    '("guint" "value")
+  )
+)
+
 
 
 ;; From gsimpleactiongroup.h
@@ -13443,6 +13967,53 @@
 
 
 
+;; From gsimpleproxyresolver.h
+
+(define-function g_simple_proxy_resolver_get_type
+  (c-name "g_simple_proxy_resolver_get_type")
+  (return-type "GType")
+)
+
+(define-function g_simple_proxy_resolver_new
+  (c-name "g_simple_proxy_resolver_new")
+  (is-constructor-of "GSimpleProxyResolver")
+  (return-type "GProxyResolver*")
+  (parameters
+    '("const-gchar*" "default_proxy")
+    '("gchar**" "ignore_hosts")
+  )
+)
+
+(define-method set_default_proxy
+  (of-object "GSimpleProxyResolver")
+  (c-name "g_simple_proxy_resolver_set_default_proxy")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "default_proxy")
+  )
+)
+
+(define-method set_ignore_hosts
+  (of-object "GSimpleProxyResolver")
+  (c-name "g_simple_proxy_resolver_set_ignore_hosts")
+  (return-type "none")
+  (parameters
+    '("gchar**" "ignore_hosts")
+  )
+)
+
+(define-method set_uri_proxy
+  (of-object "GSimpleProxyResolver")
+  (c-name "g_simple_proxy_resolver_set_uri_proxy")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "uri_scheme")
+    '("const-gchar*" "proxy")
+  )
+)
+
+
+
 ;; From gsocketaddressenumerator.h
 
 (define-function g_socket_address_enumerator_get_type
@@ -13657,6 +14228,21 @@
   )
 )
 
+(define-method get_proxy_resolver
+  (of-object "GSocketClient")
+  (c-name "g_socket_client_get_proxy_resolver")
+  (return-type "GProxyResolver*")
+)
+
+(define-method set_proxy_resolver
+  (of-object "GSocketClient")
+  (c-name "g_socket_client_set_proxy_resolver")
+  (return-type "none")
+  (parameters
+    '("GProxyResolver*" "proxy_resolver")
+  )
+)
+
 (define-method connect
   (of-object "GSocketClient")
   (c-name "g_socket_client_connect")
@@ -14440,6 +15026,30 @@
   )
 )
 
+(define-method get_option
+  (of-object "GSocket")
+  (c-name "g_socket_get_option")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "level")
+    '("gint" "optname")
+    '("gint*" "value")
+    '("GError**" "error")
+  )
+)
+
+(define-method set_option
+  (of-object "GSocket")
+  (c-name "g_socket_set_option")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "level")
+    '("gint" "optname")
+    '("gint" "value")
+    '("GError**" "error")
+  )
+)
+
 
 
 ;; From gsocketinputstream.h
@@ -14702,6 +15312,273 @@
 
 
 
+;; From gtask.h
+
+(define-function g_task_get_type
+  (c-name "g_task_get_type")
+  (return-type "GType")
+)
+
+(define-function g_task_new
+  (c-name "g_task_new")
+  (is-constructor-of "GTask")
+  (return-type "GTask*")
+  (parameters
+    '("gpointer" "source_object")
+    '("GCancellable*" "cancellable")
+    '("GAsyncReadyCallback" "callback")
+    '("gpointer" "callback_data")
+  )
+)
+
+(define-function g_task_report_error
+  (c-name "g_task_report_error")
+  (return-type "none")
+  (parameters
+    '("gpointer" "source_object")
+    '("GAsyncReadyCallback" "callback")
+    '("gpointer" "callback_data")
+    '("gpointer" "source_tag")
+    '("GError*" "error")
+  )
+)
+
+(define-function g_task_report_new_error
+  (c-name "g_task_report_new_error")
+  (return-type "none")
+  (parameters
+    '("gpointer" "source_object")
+    '("GAsyncReadyCallback" "callback")
+    '("gpointer" "callback_data")
+    '("gpointer" "source_tag")
+    '("GQuark" "domain")
+    '("gint" "code")
+    '("const-char*" "format")
+  )
+  (varargs #t)
+)
+
+(define-method set_task_data
+  (of-object "GTask")
+  (c-name "g_task_set_task_data")
+  (return-type "none")
+  (parameters
+    '("gpointer" "task_data")
+    '("GDestroyNotify" "task_data_destroy")
+  )
+)
+
+(define-method set_priority
+  (of-object "GTask")
+  (c-name "g_task_set_priority")
+  (return-type "none")
+  (parameters
+    '("gint" "priority")
+  )
+)
+
+(define-method set_check_cancellable
+  (of-object "GTask")
+  (c-name "g_task_set_check_cancellable")
+  (return-type "none")
+  (parameters
+    '("gboolean" "check_cancellable")
+  )
+)
+
+(define-method set_source_tag
+  (of-object "GTask")
+  (c-name "g_task_set_source_tag")
+  (return-type "none")
+  (parameters
+    '("gpointer" "source_tag")
+  )
+)
+
+(define-method get_source_object
+  (of-object "GTask")
+  (c-name "g_task_get_source_object")
+  (return-type "gpointer")
+)
+
+(define-method get_task_data
+  (of-object "GTask")
+  (c-name "g_task_get_task_data")
+  (return-type "gpointer")
+)
+
+(define-method get_priority
+  (of-object "GTask")
+  (c-name "g_task_get_priority")
+  (return-type "gint")
+)
+
+(define-method get_context
+  (of-object "GTask")
+  (c-name "g_task_get_context")
+  (return-type "GMainContext*")
+)
+
+(define-method get_cancellable
+  (of-object "GTask")
+  (c-name "g_task_get_cancellable")
+  (return-type "GCancellable*")
+)
+
+(define-method get_check_cancellable
+  (of-object "GTask")
+  (c-name "g_task_get_check_cancellable")
+  (return-type "gboolean")
+)
+
+(define-method get_source_tag
+  (of-object "GTask")
+  (c-name "g_task_get_source_tag")
+  (return-type "gpointer")
+)
+
+(define-function g_task_is_valid
+  (c-name "g_task_is_valid")
+  (return-type "gboolean")
+  (parameters
+    '("gpointer" "result")
+    '("gpointer" "source_object")
+  )
+)
+
+(define-method run_in_thread
+  (of-object "GTask")
+  (c-name "g_task_run_in_thread")
+  (return-type "none")
+  (parameters
+    '("GTaskThreadFunc" "task_func")
+  )
+)
+
+(define-method run_in_thread_sync
+  (of-object "GTask")
+  (c-name "g_task_run_in_thread_sync")
+  (return-type "none")
+  (parameters
+    '("GTaskThreadFunc" "task_func")
+  )
+)
+
+(define-method set_return_on_cancel
+  (of-object "GTask")
+  (c-name "g_task_set_return_on_cancel")
+  (return-type "gboolean")
+  (parameters
+    '("gboolean" "return_on_cancel")
+  )
+)
+
+(define-method get_return_on_cancel
+  (of-object "GTask")
+  (c-name "g_task_get_return_on_cancel")
+  (return-type "gboolean")
+)
+
+(define-method attach_source
+  (of-object "GTask")
+  (c-name "g_task_attach_source")
+  (return-type "none")
+  (parameters
+    '("GSource*" "source")
+    '("GSourceFunc" "callback")
+  )
+)
+
+(define-method return_pointer
+  (of-object "GTask")
+  (c-name "g_task_return_pointer")
+  (return-type "none")
+  (parameters
+    '("gpointer" "result")
+    '("GDestroyNotify" "result_destroy")
+  )
+)
+
+(define-method return_boolean
+  (of-object "GTask")
+  (c-name "g_task_return_boolean")
+  (return-type "none")
+  (parameters
+    '("gboolean" "result")
+  )
+)
+
+(define-method return_int
+  (of-object "GTask")
+  (c-name "g_task_return_int")
+  (return-type "none")
+  (parameters
+    '("gssize" "result")
+  )
+)
+
+(define-method return_error
+  (of-object "GTask")
+  (c-name "g_task_return_error")
+  (return-type "none")
+  (parameters
+    '("GError*" "error")
+  )
+)
+
+(define-method return_new_error
+  (of-object "GTask")
+  (c-name "g_task_return_new_error")
+  (return-type "none")
+  (parameters
+    '("GQuark" "domain")
+    '("gint" "code")
+    '("const-char*" "format")
+  )
+  (varargs #t)
+)
+
+(define-method return_error_if_cancelled
+  (of-object "GTask")
+  (c-name "g_task_return_error_if_cancelled")
+  (return-type "gboolean")
+)
+
+(define-method propagate_pointer
+  (of-object "GTask")
+  (c-name "g_task_propagate_pointer")
+  (return-type "gpointer")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
+(define-method propagate_boolean
+  (of-object "GTask")
+  (c-name "g_task_propagate_boolean")
+  (return-type "gboolean")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
+(define-method propagate_int
+  (of-object "GTask")
+  (c-name "g_task_propagate_int")
+  (return-type "gssize")
+  (parameters
+    '("GError**" "error")
+  )
+)
+
+(define-method had_error
+  (of-object "GTask")
+  (c-name "g_task_had_error")
+  (return-type "gboolean")
+)
+
+
+
 ;; From gtcpconnection.h
 
 (define-function g_tcp_connection_get_type
diff --git a/glib/src/glib_functions.defs b/glib/src/glib_functions.defs
index d8a3197..2b7e9e1 100644
--- a/glib/src/glib_functions.defs
+++ b/glib/src/glib_functions.defs
@@ -36,6 +36,7 @@
     '("md5" "G_CHECKSUM_MD5")
     '("sha1" "G_CHECKSUM_SHA1")
     '("sha256" "G_CHECKSUM_SHA256")
+    '("sha512" "G_CHECKSUM_SHA512")
   )
 )
 
@@ -210,20 +211,6 @@
   )
 )
 
-(define-enum n
-  (in-module "GIOConditio")
-  (c-name "GIOCondition")
-  (gtype-id "G_TYPE_IO_CONDITION")
-  (values
-    '("in" "G_IO_IN")
-    '("out" "G_IO_OUT")
-    '("pri" "G_IO_PRI")
-    '("err" "G_IO_ERR")
-    '("hup" "G_IO_HUP")
-    '("nval" "G_IO_NVAL")
-  )
-)
-
 (define-flags s
   (in-module "GIOFlag")
   (c-name "GIOFlags")
@@ -233,6 +220,7 @@
     '("nonblock" "G_IO_FLAG_NONBLOCK")
     '("is-readable" "G_IO_FLAG_IS_READABLE")
     '("is-writable" "G_IO_FLAG_IS_WRITABLE")
+    '("is-writeable" "G_IO_FLAG_IS_WRITEABLE")
     '("is-seekable" "G_IO_FLAG_IS_SEEKABLE")
     '("mask" "G_IO_FLAG_MASK")
     '("get-mask" "G_IO_FLAG_GET_MASK")
@@ -265,6 +253,20 @@
   )
 )
 
+(define-enum n
+  (in-module "GIOConditio")
+  (c-name "GIOCondition")
+  (gtype-id "G_TYPE_IO_CONDITION")
+  (values
+    '("in" "G_IO_IN")
+    '("out" "G_IO_OUT")
+    '("pri" "G_IO_PRI")
+    '("err" "G_IO_ERR")
+    '("hup" "G_IO_HUP")
+    '("nval" "G_IO_NVAL")
+  )
+)
+
 (define-enum Error
   (in-module "GMarkup")
   (c-name "GMarkupError")
@@ -752,6 +754,7 @@
     '("close-paranthesis" "G_UNICODE_BREAK_CLOSE_PARANTHESIS")
     '("conditional-japanese-starter" "G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER")
     '("hebrew-letter" "G_UNICODE_BREAK_HEBREW_LETTER")
+    '("regional-indicator" "G_UNICODE_BREAK_REGIONAL_INDICATOR")
   )
 )
 
@@ -1615,7 +1618,7 @@
   (c-name "g_atomic_int_get")
   (return-type "gint")
   (parameters
-    '("volatile-gint*" "atomic")
+    '("const-volatile-gint*" "atomic")
   )
 )
 
@@ -1694,7 +1697,7 @@
   (c-name "g_atomic_pointer_get")
   (return-type "gpointer")
   (parameters
-    '("volatile-void*" "atomic")
+    '("const-volatile-void*" "atomic")
   )
 )
 
@@ -2487,6 +2490,10 @@
 
 
 
+;; From gcharsetprivate.h
+
+
+
 ;; From gchecksum.h
 
 (define-method get_length
@@ -2759,6 +2766,50 @@
   )
 )
 
+(define-function g_filename_to_utf8_utf8
+  (c-name "g_filename_to_utf8_utf8")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "opsysstring")
+    '("gssize" "len")
+    '("gsize*" "bytes_read")
+    '("gsize*" "bytes_written")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_filename_from_utf8_utf8
+  (c-name "g_filename_from_utf8_utf8")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "utf8string")
+    '("gssize" "len")
+    '("gsize*" "bytes_read")
+    '("gsize*" "bytes_written")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_filename_from_uri_utf8
+  (c-name "g_filename_from_uri_utf8")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "uri")
+    '("gchar**" "hostname")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_filename_to_uri_utf8
+  (c-name "g_filename_to_uri_utf8")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "filename")
+    '("const-gchar*" "hostname")
+    '("GError**" "error")
+  )
+)
+
 
 
 ;; From gdataset.h
@@ -3726,6 +3777,22 @@
   (return-type "none")
 )
 
+(define-function g_dir_open_utf8
+  (c-name "g_dir_open_utf8")
+  (return-type "GDir*")
+  (parameters
+    '("const-gchar*" "path")
+    '("guint" "flags")
+    '("GError**" "error")
+  )
+)
+
+(define-method read_name_utf8
+  (of-object "GDir")
+  (c-name "g_dir_read_name_utf8")
+  (return-type "const-gchar*")
+)
+
 
 
 ;; From genviron.h
@@ -3795,6 +3862,32 @@
   )
 )
 
+(define-function g_getenv_utf8
+  (c-name "g_getenv_utf8")
+  (return-type "const-gchar*")
+  (parameters
+    '("const-gchar*" "variable")
+  )
+)
+
+(define-function g_setenv_utf8
+  (c-name "g_setenv_utf8")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "variable")
+    '("const-gchar*" "value")
+    '("gboolean" "overwrite")
+  )
+)
+
+(define-function g_unsetenv_utf8
+  (c-name "g_unsetenv_utf8")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "variable")
+  )
+)
+
 
 
 ;; From gerror.h
@@ -4116,6 +4209,49 @@
   )
 )
 
+(define-function g_file_test_utf8
+  (c-name "g_file_test_utf8")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "filename")
+    '("GFileTest" "test")
+  )
+)
+
+(define-function g_file_get_contents_utf8
+  (c-name "g_file_get_contents_utf8")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "filename")
+    '("gchar**" "contents")
+    '("gsize*" "length")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_mkstemp_utf8
+  (c-name "g_mkstemp_utf8")
+  (return-type "gint")
+  (parameters
+    '("gchar*" "tmpl")
+  )
+)
+
+(define-function g_file_open_tmp_utf8
+  (c-name "g_file_open_tmp_utf8")
+  (return-type "gint")
+  (parameters
+    '("const-gchar*" "tmpl")
+    '("gchar**" "name_used")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_get_current_dir_utf8
+  (c-name "g_get_current_dir_utf8")
+  (return-type "gchar*")
+)
+
 
 
 ;; From ggettext.h
@@ -5253,6 +5389,33 @@
   )
 )
 
+(define-function g_io_channel_win32_new_stream_socket
+  (c-name "g_io_channel_win32_new_stream_socket")
+  (return-type "GIOChannel*")
+  (parameters
+    '("gint" "socket")
+  )
+)
+
+(define-method win32_set_debug
+  (of-object "GIOChannel")
+  (c-name "g_io_channel_win32_set_debug")
+  (return-type "none")
+  (parameters
+    '("gboolean" "flag")
+  )
+)
+
+(define-function g_io_channel_new_file_utf8
+  (c-name "g_io_channel_new_file_utf8")
+  (return-type "GIOChannel*")
+  (parameters
+    '("const-gchar*" "filename")
+    '("const-gchar*" "mode")
+    '("GError**" "error")
+  )
+)
+
 
 
 ;; From gkeyfile.h
@@ -5766,6 +5929,21 @@
 
 ;; From glib-init.h
 
+(define-function g_thread_win32_thread_detach
+  (c-name "g_thread_win32_thread_detach")
+  (return-type "none")
+)
+
+(define-function g_thread_win32_init
+  (c-name "g_thread_win32_init")
+  (return-type "none")
+)
+
+(define-function g_clock_win32_init
+  (c-name "g_clock_win32_init")
+  (return-type "none")
+)
+
 
 
 ;; From glibintl.h
@@ -5795,14 +5973,28 @@
 
 ;; From glib-private.h
 
-(define-function glib__private__
-  (c-name "glib__private__")
-  (return-type "GLibPrivateVTable*")
+(define-function g_get_worker_context
+  (c-name "g_get_worker_context")
+  (return-type "GMainContext*")
 )
 
+(define-function g_check_setuid
+  (c-name "g_check_setuid")
+  (return-type "gboolean")
+)
 
+(define-function g_main_context_new_with_next_id
+  (c-name "g_main_context_new_with_next_id")
+  (return-type "GMainContext*")
+  (parameters
+    '("guint" "next_id")
+  )
+)
 
-;; From glib_probes.h
+(define-function glib__private__
+  (c-name "glib__private__")
+  (return-type "GLibPrivateVTable*")
+)
 
 
 
@@ -5868,6 +6060,40 @@
   )
 )
 
+(define-function g_unix_fd_source_new
+  (c-name "g_unix_fd_source_new")
+  (is-constructor-of "GUnixFdSource")
+  (return-type "GSource*")
+  (parameters
+    '("gint" "fd")
+    '("GIOCondition" "condition")
+  )
+)
+
+(define-function g_unix_fd_add_full
+  (c-name "g_unix_fd_add_full")
+  (return-type "guint")
+  (parameters
+    '("gint" "priority")
+    '("gint" "fd")
+    '("GIOCondition" "condition")
+    '("GUnixFDSourceFunc" "function")
+    '("gpointer" "user_data")
+    '("GDestroyNotify" "notify")
+  )
+)
+
+(define-function g_unix_fd_add
+  (c-name "g_unix_fd_add")
+  (return-type "guint")
+  (parameters
+    '("gint" "fd")
+    '("GIOCondition" "condition")
+    '("GUnixFDSourceFunc" "function")
+    '("gpointer" "user_data")
+  )
+)
+
 
 
 ;; From glist.h
@@ -6522,6 +6748,59 @@
   )
 )
 
+(define-method set_ready_time
+  (of-object "GSource")
+  (c-name "g_source_set_ready_time")
+  (return-type "none")
+  (parameters
+    '("gint64" "ready_time")
+  )
+)
+
+(define-method get_ready_time
+  (of-object "GSource")
+  (c-name "g_source_get_ready_time")
+  (return-type "gint64")
+)
+
+(define-method add_unix_fd
+  (of-object "GSource")
+  (c-name "g_source_add_unix_fd")
+  (return-type "gpointer")
+  (parameters
+    '("gint" "fd")
+    '("GIOCondition" "events")
+  )
+)
+
+(define-method modify_unix_fd
+  (of-object "GSource")
+  (c-name "g_source_modify_unix_fd")
+  (return-type "none")
+  (parameters
+    '("gpointer" "tag")
+    '("GIOCondition" "new_events")
+  )
+)
+
+(define-method remove_unix_fd
+  (of-object "GSource")
+  (c-name "g_source_remove_unix_fd")
+  (return-type "none")
+  (parameters
+    '("gpointer" "tag")
+  )
+)
+
+(define-method query_unix_fd
+  (of-object "GSource")
+  (c-name "g_source_query_unix_fd")
+  (return-type "GIOCondition")
+  (parameters
+    '("gpointer" "tag")
+  )
+)
+
 (define-method set_callback_indirect
   (of-object "GSource")
   (c-name "g_source_set_callback_indirect")
@@ -6860,6 +7139,18 @@
   )
 )
 
+(define-method ref
+  (of-object "GMarkupParseContext")
+  (c-name "g_markup_parse_context_ref")
+  (return-type "GMarkupParseContext*")
+)
+
+(define-method unref
+  (of-object "GMarkupParseContext")
+  (c-name "g_markup_parse_context_unref")
+  (return-type "none")
+)
+
 (define-method free
   (of-object "GMarkupParseContext")
   (c-name "g_markup_parse_context_free")
@@ -9370,6 +9661,11 @@
   )
 )
 
+(define-function g_slice_debug_tree_statistics
+  (c-name "g_slice_debug_tree_statistics")
+  (return-type "none")
+)
+
 
 
 ;; From gslist.h
@@ -9724,6 +10020,77 @@
   )
 )
 
+(define-function g_spawn_async_utf8
+  (c-name "g_spawn_async_utf8")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "working_directory")
+    '("gchar**" "argv")
+    '("gchar**" "envp")
+    '("GSpawnFlags" "flags")
+    '("GSpawnChildSetupFunc" "child_setup")
+    '("gpointer" "user_data")
+    '("GPid*" "child_pid")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_spawn_async_with_pipes_utf8
+  (c-name "g_spawn_async_with_pipes_utf8")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "working_directory")
+    '("gchar**" "argv")
+    '("gchar**" "envp")
+    '("GSpawnFlags" "flags")
+    '("GSpawnChildSetupFunc" "child_setup")
+    '("gpointer" "user_data")
+    '("GPid*" "child_pid")
+    '("gint*" "standard_input")
+    '("gint*" "standard_output")
+    '("gint*" "standard_error")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_spawn_sync_utf8
+  (c-name "g_spawn_sync_utf8")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "working_directory")
+    '("gchar**" "argv")
+    '("gchar**" "envp")
+    '("GSpawnFlags" "flags")
+    '("GSpawnChildSetupFunc" "child_setup")
+    '("gpointer" "user_data")
+    '("gchar**" "standard_output")
+    '("gchar**" "standard_error")
+    '("gint*" "exit_status")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_spawn_command_line_sync_utf8
+  (c-name "g_spawn_command_line_sync_utf8")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "command_line")
+    '("gchar**" "standard_output")
+    '("gchar**" "standard_error")
+    '("gint*" "exit_status")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_spawn_command_line_async_utf8
+  (c-name "g_spawn_command_line_async_utf8")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "command_line")
+    '("GError**" "error")
+  )
+)
+
 
 
 ;; From gstdio.h
@@ -9894,6 +10261,15 @@
   )
 )
 
+(define-function g_close
+  (c-name "g_close")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "fd")
+    '("GError**" "error")
+  )
+)
+
 
 
 ;; From gstrfuncs.h
@@ -11360,6 +11736,11 @@
   )
 )
 
+(define-function g_get_num_processors
+  (c-name "g_get_num_processors")
+  (return-type "guint")
+)
+
 
 
 ;; From gthreadpool.h
@@ -11475,6 +11856,67 @@
 
 ;; From gthreadprivate.h
 
+(define-function g_system_thread_wait
+  (c-name "g_system_thread_wait")
+  (return-type "none")
+  (parameters
+    '("GRealThread*" "thread")
+  )
+)
+
+(define-function g_system_thread_new
+  (c-name "g_system_thread_new")
+  (is-constructor-of "GSystemThread")
+  (return-type "GRealThread*")
+  (parameters
+    '("GThreadFunc" "func")
+    '("gulong" "stack_size")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_system_thread_free
+  (c-name "g_system_thread_free")
+  (return-type "none")
+  (parameters
+    '("GRealThread*" "thread")
+  )
+)
+
+(define-function g_system_thread_exit
+  (c-name "g_system_thread_exit")
+  (return-type "none")
+)
+
+(define-function g_system_thread_set_name
+  (c-name "g_system_thread_set_name")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-function g_thread_new_internal
+  (c-name "g_thread_new_internal")
+  (return-type "GThread*")
+  (parameters
+    '("const-gchar*" "name")
+    '("GThreadFunc" "proxy")
+    '("GThreadFunc" "func")
+    '("gpointer" "data")
+    '("gsize" "stack_size")
+    '("GError**" "error")
+  )
+)
+
+(define-function g_thread_proxy
+  (c-name "g_thread_proxy")
+  (return-type "gpointer")
+  (parameters
+    '("gpointer" "thread")
+  )
+)
+
 
 
 ;; From gtimer.h
@@ -12454,7 +12896,7 @@
 
 (define-function g_get_prgname
   (c-name "g_get_prgname")
-  (return-type "gchar*")
+  (return-type "const-gchar*")
 )
 
 (define-function g_set_prgname
@@ -12643,6 +13085,29 @@
 
 ;; From gvariant-core.h
 
+(define-function g_variant_new_from_children
+  (c-name "g_variant_new_from_children")
+  (return-type "GVariant*")
+  (parameters
+    '("const-GVariantType*" "type")
+    '("GVariant**" "children")
+    '("gsize" "n_children")
+    '("gboolean" "trusted")
+  )
+)
+
+(define-method is_trusted
+  (of-object "GVariant")
+  (c-name "g_variant_is_trusted")
+  (return-type "gboolean")
+)
+
+(define-method get_type_info
+  (of-object "GVariant")
+  (c-name "g_variant_get_type_info")
+  (return-type "GVariantTypeInfo*")
+)
+
 
 
 ;; From gvariant.h
@@ -13147,6 +13612,12 @@
   (return-type "gconstpointer")
 )
 
+(define-method get_data_as_bytes
+  (of-object "GVariant")
+  (c-name "g_variant_get_data_as_bytes")
+  (return-type "GBytes*")
+)
+
 (define-method store
   (of-object "GVariant")
   (c-name "g_variant_store")
@@ -13210,6 +13681,16 @@
   (return-type "GVariant*")
 )
 
+(define-function g_variant_new_from_bytes
+  (c-name "g_variant_new_from_bytes")
+  (return-type "GVariant*")
+  (parameters
+    '("const-GVariantType*" "type")
+    '("GBytes*" "bytes")
+    '("gboolean" "trusted")
+  )
+)
+
 (define-function g_variant_new_from_data
   (c-name "g_variant_new_from_data")
   (return-type "GVariant*")
@@ -13872,6 +14353,39 @@
 
 ;; From gwakeup.h
 
+(define-function g_wakeup_new
+  (c-name "g_wakeup_new")
+  (is-constructor-of "GWakeup")
+  (return-type "GWakeup*")
+)
+
+(define-method free
+  (of-object "GWakeup")
+  (c-name "g_wakeup_free")
+  (return-type "none")
+)
+
+(define-method get_pollfd
+  (of-object "GWakeup")
+  (c-name "g_wakeup_get_pollfd")
+  (return-type "none")
+  (parameters
+    '("GPollFD*" "poll_fd")
+  )
+)
+
+(define-method signal
+  (of-object "GWakeup")
+  (c-name "g_wakeup_signal")
+  (return-type "none")
+)
+
+(define-method acknowledge
+  (of-object "GWakeup")
+  (c-name "g_wakeup_acknowledge")
+  (return-type "none")
+)
+
 
 
 ;; From gwin32.h
@@ -13938,6 +14452,16 @@
   )
 )
 
+(define-function g_win32_get_package_installation_subdirectory_utf8
+  (c-name "g_win32_get_package_installation_subdirectory_utf8")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "package")
+    '("const-gchar*" "dll_name")
+    '("const-gchar*" "subdir")
+  )
+)
+
 
 
 ;; From gallocator.h
diff --git a/glib/src/gmodule_functions.defs b/glib/src/gmodule_functions.defs
index 29b4835..9d92ebe 100644
--- a/glib/src/gmodule_functions.defs
+++ b/glib/src/gmodule_functions.defs
@@ -76,4 +76,19 @@
   )
 )
 
+(define-function g_module_open_utf8
+  (c-name "g_module_open_utf8")
+  (return-type "GModule*")
+  (parameters
+    '("const-gchar*" "file_name")
+    '("GModuleFlags" "flags")
+  )
+)
+
+(define-method name_utf8
+  (of-object "GModule")
+  (c-name "g_module_name_utf8")
+  (return-type "const-gchar*")
+)
+
 
diff --git a/glib/src/gobject_functions.defs b/glib/src/gobject_functions.defs
index 57fe7ab..5b2d2d1 100644
--- a/glib/src/gobject_functions.defs
+++ b/glib/src/gobject_functions.defs
@@ -708,6 +708,26 @@
   (return-type "GType")
 )
 
+(define-function g_pollfd_get_type
+  (c-name "g_pollfd_get_type")
+  (return-type "GType")
+)
+
+(define-function g_thread_get_type
+  (c-name "g_thread_get_type")
+  (return-type "GType")
+)
+
+(define-function g_checksum_get_type
+  (c-name "g_checksum_get_type")
+  (return-type "GType")
+)
+
+(define-function g_markup_parse_context_get_type
+  (c-name "g_markup_parse_context_get_type")
+  (return-type "GType")
+)
+
 (define-function g_variant_get_gtype
   (c-name "g_variant_get_gtype")
   (return-type "GType")
@@ -715,7 +735,601 @@
 
 
 
-;; From gmarshal.h
+;; From gmarshal.h
+
+(define-function g_cclosure_marshal_VOID__VOID
+  (c-name "g_cclosure_marshal_VOID__VOID")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__VOIDv
+  (c-name "g_cclosure_marshal_VOID__VOIDv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__BOOLEAN
+  (c-name "g_cclosure_marshal_VOID__BOOLEAN")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__BOOLEANv
+  (c-name "g_cclosure_marshal_VOID__BOOLEANv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__CHAR
+  (c-name "g_cclosure_marshal_VOID__CHAR")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__CHARv
+  (c-name "g_cclosure_marshal_VOID__CHARv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__UCHAR
+  (c-name "g_cclosure_marshal_VOID__UCHAR")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__UCHARv
+  (c-name "g_cclosure_marshal_VOID__UCHARv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__INT
+  (c-name "g_cclosure_marshal_VOID__INT")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__INTv
+  (c-name "g_cclosure_marshal_VOID__INTv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__UINT
+  (c-name "g_cclosure_marshal_VOID__UINT")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__UINTv
+  (c-name "g_cclosure_marshal_VOID__UINTv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__LONG
+  (c-name "g_cclosure_marshal_VOID__LONG")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__LONGv
+  (c-name "g_cclosure_marshal_VOID__LONGv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__ULONG
+  (c-name "g_cclosure_marshal_VOID__ULONG")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__ULONGv
+  (c-name "g_cclosure_marshal_VOID__ULONGv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__ENUM
+  (c-name "g_cclosure_marshal_VOID__ENUM")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__ENUMv
+  (c-name "g_cclosure_marshal_VOID__ENUMv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__FLAGS
+  (c-name "g_cclosure_marshal_VOID__FLAGS")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__FLAGSv
+  (c-name "g_cclosure_marshal_VOID__FLAGSv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__FLOAT
+  (c-name "g_cclosure_marshal_VOID__FLOAT")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__FLOATv
+  (c-name "g_cclosure_marshal_VOID__FLOATv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__DOUBLE
+  (c-name "g_cclosure_marshal_VOID__DOUBLE")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__DOUBLEv
+  (c-name "g_cclosure_marshal_VOID__DOUBLEv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__STRING
+  (c-name "g_cclosure_marshal_VOID__STRING")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__STRINGv
+  (c-name "g_cclosure_marshal_VOID__STRINGv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__PARAM
+  (c-name "g_cclosure_marshal_VOID__PARAM")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__PARAMv
+  (c-name "g_cclosure_marshal_VOID__PARAMv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__BOXED
+  (c-name "g_cclosure_marshal_VOID__BOXED")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__BOXEDv
+  (c-name "g_cclosure_marshal_VOID__BOXEDv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__POINTER
+  (c-name "g_cclosure_marshal_VOID__POINTER")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__POINTERv
+  (c-name "g_cclosure_marshal_VOID__POINTERv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__OBJECT
+  (c-name "g_cclosure_marshal_VOID__OBJECT")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__OBJECTv
+  (c-name "g_cclosure_marshal_VOID__OBJECTv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__VARIANT
+  (c-name "g_cclosure_marshal_VOID__VARIANT")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__VARIANTv
+  (c-name "g_cclosure_marshal_VOID__VARIANTv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__UINT_POINTER
+  (c-name "g_cclosure_marshal_VOID__UINT_POINTER")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_VOID__UINT_POINTERv
+  (c-name "g_cclosure_marshal_VOID__UINT_POINTERv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_BOOLEAN__FLAGS
+  (c-name "g_cclosure_marshal_BOOLEAN__FLAGS")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_BOOLEAN__FLAGSv
+  (c-name "g_cclosure_marshal_BOOLEAN__FLAGSv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_STRING__OBJECT_POINTER
+  (c-name "g_cclosure_marshal_STRING__OBJECT_POINTER")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_STRING__OBJECT_POINTERv
+  (c-name "g_cclosure_marshal_STRING__OBJECT_POINTERv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
+
+(define-function g_cclosure_marshal_BOOLEAN__BOXED_BOXED
+  (c-name "g_cclosure_marshal_BOOLEAN__BOXED_BOXED")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+(define-function g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv
+  (c-name "g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("gpointer" "instance")
+    '("va_list" "args")
+    '("gpointer" "marshal_data")
+    '("int" "n_params")
+    '("GType*" "param_types")
+  )
+)
 
 
 
@@ -1310,10 +1924,6 @@
 
 
 
-;; From gobject_probes.h
-
-
-
 ;; From gobject_trace.h
 
 
@@ -2630,6 +3240,11 @@
   (return-type "none")
 )
 
+(define-function g_type_get_type_registration_serial
+  (c-name "g_type_get_type_registration_serial")
+  (return-type "guint")
+)
+
 (define-method get_plugin
   (of-object "GType")
   (c-name "g_type_get_plugin")
[Date Prev][Date Next] [Thread Prev][Thread Next] [Thread Index] [Date Index] [Author Index]