[glibmm] Settings: Fix the build with the latest glib.
- From: Murray Cumming <murrayc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [glibmm] Settings: Fix the build with the latest glib.
- Date: Fri, 18 Jun 2010 15:52:23 +0000 (UTC)
commit 858f51add2b4b332fbaf4d53c612a7f28878b2a7
Author: Murray Cumming <murrayc murrayc com>
Date: Fri Jun 18 17:52:14 2010 +0200
Settings: Fix the build with the latest glib.
* gio/src/settingsbackend.[hg|ccg]: Add this interface. Notice the
comment about the semi-private get_type() function.
* gio/src/filelist.am: Mention the new files.
* gio/src/settings.hg: Adapt to the changed glib API, using
a SettingsBackend backend instead of a string context.
ChangeLog | 10 +
gio/src/filelist.am | 1 +
gio/src/gio_methods.defs | 2630 +++++++++++++++++++++++++++++++++-
gio/src/settings.ccg | 6 -
gio/src/settings.hg | 10 +-
gio/src/settingsbackend.ccg | 23 +
gio/src/settingsbackend.hg | 66 +
glib/src/glib_functions.defs | 3288 +++++++++++++++++++++++++++++++++++++++++-
tools/m4/convert_gio.m4 | 2 +-
9 files changed, 5987 insertions(+), 49 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 7d4e8c0..9697324 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,13 @@
+2010-06-18 Murray Cumming <murrayc murrayc com>
+
+ Settings: Fix the build with the latest glib.
+
+ * gio/src/settingsbackend.[hg|ccg]: Add this interface. Notice the
+ comment about the semi-private get_type() function.
+ * gio/src/filelist.am: Mention the new files.
+ * gio/src/settings.hg: Adapt to the changed glib API, using
+ a SettingsBackend backend instead of a string context.
+
2010-06-08 Murray Cumming <murrayc murrayc com>
Use GLIBMM_DISABLE_DEPRECATED on StreamIoChannel.
diff --git a/gio/src/filelist.am b/gio/src/filelist.am
index 894f3d7..a7d2eab 100644
--- a/gio/src/filelist.am
+++ b/gio/src/filelist.am
@@ -53,6 +53,7 @@ giomm_files_any_hg = \
resolver.hg \
seekable.hg \
settings.hg \
+ settingsbackend.hg \
socket.hg \
socketaddress.hg \
socketaddressenumerator.hg \
diff --git a/gio/src/gio_methods.defs b/gio/src/gio_methods.defs
index d407f00..4347c9c 100644
--- a/gio/src/gio_methods.defs
+++ b/gio/src/gio_methods.defs
@@ -13,6 +13,13 @@
(gtype-id "G_TYPE_APP_LAUNCH_CONTEXT")
)
+(define-object n
+ (in-module "GApplicatio")
+ (parent "GObject")
+ (c-name "GApplication")
+ (gtype-id "G_TYPE_APPLICATION")
+)
+
(define-object Initable
(in-module "GAsync")
(c-name "GAsyncInitable")
@@ -38,6 +45,55 @@
(gtype-id "G_TYPE_CONVERTER")
)
+(define-object s
+ (in-module "GCredential")
+ (parent "GObject")
+ (c-name "GCredentials")
+ (gtype-id "G_TYPE_CREDENTIALS")
+)
+
+(define-object AuthObserver
+ (in-module "GDBus")
+ (parent "GObject")
+ (c-name "GDBusAuthObserver")
+ (gtype-id "G_TYPE_D_BUS_AUTH_OBSERVER")
+)
+
+(define-object Connection
+ (in-module "GDBus")
+ (parent "GObject")
+ (c-name "GDBusConnection")
+ (gtype-id "G_TYPE_D_BUS_CONNECTION")
+)
+
+(define-object Message
+ (in-module "GDBus")
+ (parent "GObject")
+ (c-name "GDBusMessage")
+ (gtype-id "G_TYPE_D_BUS_MESSAGE")
+)
+
+(define-object MethodInvocation
+ (in-module "GDBus")
+ (parent "GObject")
+ (c-name "GDBusMethodInvocation")
+ (gtype-id "G_TYPE_D_BUS_METHOD_INVOCATION")
+)
+
+(define-object Proxy
+ (in-module "GDBus")
+ (parent "GObject")
+ (c-name "GDBusProxy")
+ (gtype-id "G_TYPE_D_BUS_PROXY")
+)
+
+(define-object Server
+ (in-module "GDBus")
+ (parent "GObject")
+ (c-name "GDBusServer")
+ (gtype-id "G_TYPE_D_BUS_SERVER")
+)
+
(define-object AppInfoLookup
(in-module "GDesktop")
(c-name "GDesktopAppInfoLookup")
@@ -240,6 +296,13 @@
(gtype-id "G_TYPE_FILE_OUTPUT_STREAM")
)
+(define-object n
+ (in-module "GPermissio")
+ (parent "GObject")
+ (c-name "GPermission")
+ (gtype-id "G_TYPE_PERMISSION")
+)
+
(define-object r
(in-module "GResolve")
(parent "GObject")
@@ -357,6 +420,13 @@
(gtype-id "G_TYPE_UNIX_CONNECTION")
)
+(define-object CredentialsMessage
+ (in-module "GUnix")
+ (parent "GSocketControlMessage")
+ (c-name "GUnixCredentialsMessage")
+ (gtype-id "G_TYPE_UNIX_CREDENTIALS_MESSAGE")
+)
+
(define-object FDList
(in-module "GUnix")
(parent "GObject")
@@ -696,6 +766,7 @@
'("address-in-use" "G_IO_ERROR_ADDRESS_IN_USE")
'("partial-input" "G_IO_ERROR_PARTIAL_INPUT")
'("invalid-data" "G_IO_ERROR_INVALID_DATA")
+ '("dbus-error" "G_IO_ERROR_DBUS_ERROR")
)
)
@@ -828,6 +899,220 @@
)
)
+(define-enum SocketAddressType
+ (in-module "GUnix")
+ (c-name "GUnixSocketAddressType")
+ (gtype-id "G_TYPE_UNIX_SOCKET_ADDRESS_TYPE")
+ (values
+ '("invalid" "G_UNIX_SOCKET_ADDRESS_INVALID")
+ '("anonymous" "G_UNIX_SOCKET_ADDRESS_ANONYMOUS")
+ '("path" "G_UNIX_SOCKET_ADDRESS_PATH")
+ '("abstract" "G_UNIX_SOCKET_ADDRESS_ABSTRACT")
+ '("abstract-padded" "G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED")
+ )
+)
+
+(define-enum Type
+ (in-module "GBus")
+ (c-name "GBusType")
+ (gtype-id "G_TYPE_BUS_TYPE")
+ (values
+ '("starter" "G_BUS_TYPE_STARTER")
+ '("none" "G_BUS_TYPE_NONE")
+ '("system" "G_BUS_TYPE_SYSTEM")
+ '("session" "G_BUS_TYPE_SESSION")
+ )
+)
+
+(define-flags NameOwnerFlags
+ (in-module "GBus")
+ (c-name "GBusNameOwnerFlags")
+ (gtype-id "G_TYPE_BUS_NAME_OWNER_FLAGS")
+ (values
+ '("none" "G_BUS_NAME_OWNER_FLAGS_NONE")
+ '("allow-replacement" "G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT")
+ '("replace" "G_BUS_NAME_OWNER_FLAGS_REPLACE")
+ )
+)
+
+(define-flags NameWatcherFlags
+ (in-module "GBus")
+ (c-name "GBusNameWatcherFlags")
+ (gtype-id "G_TYPE_BUS_NAME_WATCHER_FLAGS")
+ (values
+ '("none" "G_BUS_NAME_WATCHER_FLAGS_NONE")
+ '("auto-start" "G_BUS_NAME_WATCHER_FLAGS_AUTO_START")
+ )
+)
+
+(define-flags ProxyFlags
+ (in-module "GDBus")
+ (c-name "GDBusProxyFlags")
+ (gtype-id "G_TYPE_D_BUS_PROXY_FLAGS")
+ (values
+ '("none" "G_DBUS_PROXY_FLAGS_NONE")
+ '("do-not-load-properties" "G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES")
+ '("do-not-connect-signals" "G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS")
+ '("do-not-auto-start" "G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START")
+ )
+)
+
+(define-enum Error
+ (in-module "GDBus")
+ (c-name "GDBusError")
+ (gtype-id "G_TYPE_D_BUS_ERROR")
+ (values
+ '("failed" "G_DBUS_ERROR_FAILED")
+ '("no-memory" "G_DBUS_ERROR_NO_MEMORY")
+ '("service-unknown" "G_DBUS_ERROR_SERVICE_UNKNOWN")
+ '("name-has-no-owner" "G_DBUS_ERROR_NAME_HAS_NO_OWNER")
+ '("no-reply" "G_DBUS_ERROR_NO_REPLY")
+ '("io-error" "G_DBUS_ERROR_IO_ERROR")
+ '("bad-address" "G_DBUS_ERROR_BAD_ADDRESS")
+ '("not-supported" "G_DBUS_ERROR_NOT_SUPPORTED")
+ '("limits-exceeded" "G_DBUS_ERROR_LIMITS_EXCEEDED")
+ '("access-denied" "G_DBUS_ERROR_ACCESS_DENIED")
+ '("auth-failed" "G_DBUS_ERROR_AUTH_FAILED")
+ '("no-server" "G_DBUS_ERROR_NO_SERVER")
+ '("timeout" "G_DBUS_ERROR_TIMEOUT")
+ '("no-network" "G_DBUS_ERROR_NO_NETWORK")
+ '("address-in-use" "G_DBUS_ERROR_ADDRESS_IN_USE")
+ '("disconnected" "G_DBUS_ERROR_DISCONNECTED")
+ '("invalid-args" "G_DBUS_ERROR_INVALID_ARGS")
+ '("file-not-found" "G_DBUS_ERROR_FILE_NOT_FOUND")
+ '("file-exists" "G_DBUS_ERROR_FILE_EXISTS")
+ '("unknown-method" "G_DBUS_ERROR_UNKNOWN_METHOD")
+ '("timed-out" "G_DBUS_ERROR_TIMED_OUT")
+ '("match-rule-not-found" "G_DBUS_ERROR_MATCH_RULE_NOT_FOUND")
+ '("match-rule-invalid" "G_DBUS_ERROR_MATCH_RULE_INVALID")
+ '("spawn-exec-failed" "G_DBUS_ERROR_SPAWN_EXEC_FAILED")
+ '("spawn-fork-failed" "G_DBUS_ERROR_SPAWN_FORK_FAILED")
+ '("spawn-child-exited" "G_DBUS_ERROR_SPAWN_CHILD_EXITED")
+ '("spawn-child-signaled" "G_DBUS_ERROR_SPAWN_CHILD_SIGNALED")
+ '("spawn-failed" "G_DBUS_ERROR_SPAWN_FAILED")
+ '("spawn-setup-failed" "G_DBUS_ERROR_SPAWN_SETUP_FAILED")
+ '("spawn-config-invalid" "G_DBUS_ERROR_SPAWN_CONFIG_INVALID")
+ '("spawn-service-invalid" "G_DBUS_ERROR_SPAWN_SERVICE_INVALID")
+ '("spawn-service-not-found" "G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND")
+ '("spawn-permissions-invalid" "G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID")
+ '("spawn-file-invalid" "G_DBUS_ERROR_SPAWN_FILE_INVALID")
+ '("spawn-no-memory" "G_DBUS_ERROR_SPAWN_NO_MEMORY")
+ '("unix-process-id-unknown" "G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN")
+ '("invalid-signature" "G_DBUS_ERROR_INVALID_SIGNATURE")
+ '("invalid-file-content" "G_DBUS_ERROR_INVALID_FILE_CONTENT")
+ '("selinux-security-context-unknown" "G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN")
+ '("adt-audit-data-unknown" "G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN")
+ '("object-path-in-use" "G_DBUS_ERROR_OBJECT_PATH_IN_USE")
+ )
+)
+
+(define-flags ConnectionFlags
+ (in-module "GDBus")
+ (c-name "GDBusConnectionFlags")
+ (gtype-id "G_TYPE_D_BUS_CONNECTION_FLAGS")
+ (values
+ '("none" "G_DBUS_CONNECTION_FLAGS_NONE")
+ '("authentication-client" "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT")
+ '("authentication-server" "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER")
+ '("authentication-allow-anonymous" "G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS")
+ '("message-bus-connection" "G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION")
+ )
+)
+
+(define-flags CapabilityFlags
+ (in-module "GDBus")
+ (c-name "GDBusCapabilityFlags")
+ (gtype-id "G_TYPE_D_BUS_CAPABILITY_FLAGS")
+ (values
+ '("none" "G_DBUS_CAPABILITY_FLAGS_NONE")
+ '("unix-fd-passing" "G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING")
+ )
+)
+
+(define-flags CallFlags
+ (in-module "GDBus")
+ (c-name "GDBusCallFlags")
+ (gtype-id "G_TYPE_D_BUS_CALL_FLAGS")
+ (values
+ '("none" "G_DBUS_CALL_FLAGS_NONE")
+ '("no-auto-start" "G_DBUS_CALL_FLAGS_NO_AUTO_START")
+ )
+)
+
+(define-enum MessageType
+ (in-module "GDBus")
+ (c-name "GDBusMessageType")
+ (gtype-id "G_TYPE_D_BUS_MESSAGE_TYPE")
+ (values
+ '("invalid" "G_DBUS_MESSAGE_TYPE_INVALID")
+ '("method-call" "G_DBUS_MESSAGE_TYPE_METHOD_CALL")
+ '("method-return" "G_DBUS_MESSAGE_TYPE_METHOD_RETURN")
+ '("error" "G_DBUS_MESSAGE_TYPE_ERROR")
+ '("signal" "G_DBUS_MESSAGE_TYPE_SIGNAL")
+ )
+)
+
+(define-flags MessageFlags
+ (in-module "GDBus")
+ (c-name "GDBusMessageFlags")
+ (gtype-id "G_TYPE_D_BUS_MESSAGE_FLAGS")
+ (values
+ '("none" "G_DBUS_MESSAGE_FLAGS_NONE")
+ '("no-reply-expected" "G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED")
+ '("no-auto-start" "G_DBUS_MESSAGE_FLAGS_NO_AUTO_START")
+ )
+)
+
+(define-enum MessageHeaderField
+ (in-module "GDBus")
+ (c-name "GDBusMessageHeaderField")
+ (gtype-id "G_TYPE_D_BUS_MESSAGE_HEADER_FIELD")
+ (values
+ '("invalid" "G_DBUS_MESSAGE_HEADER_FIELD_INVALID")
+ '("path" "G_DBUS_MESSAGE_HEADER_FIELD_PATH")
+ '("interface" "G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE")
+ '("member" "G_DBUS_MESSAGE_HEADER_FIELD_MEMBER")
+ '("error-name" "G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME")
+ '("reply-serial" "G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL")
+ '("destination" "G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION")
+ '("sender" "G_DBUS_MESSAGE_HEADER_FIELD_SENDER")
+ '("signature" "G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE")
+ '("num-unix-fds" "G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS")
+ )
+)
+
+(define-flags PropertyInfoFlags
+ (in-module "GDBus")
+ (c-name "GDBusPropertyInfoFlags")
+ (gtype-id "G_TYPE_D_BUS_PROPERTY_INFO_FLAGS")
+ (values
+ '("none" "G_DBUS_PROPERTY_INFO_FLAGS_NONE")
+ '("readable" "G_DBUS_PROPERTY_INFO_FLAGS_READABLE")
+ '("writable" "G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE")
+ )
+)
+
+(define-flags SubtreeFlags
+ (in-module "GDBus")
+ (c-name "GDBusSubtreeFlags")
+ (gtype-id "G_TYPE_D_BUS_SUBTREE_FLAGS")
+ (values
+ '("none" "G_DBUS_SUBTREE_FLAGS_NONE")
+ '("dispatch-to-unenumerated-nodes" "G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES")
+ )
+)
+
+(define-flags ServerFlags
+ (in-module "GDBus")
+ (c-name "GDBusServerFlags")
+ (gtype-id "G_TYPE_D_BUS_SERVER_FLAGS")
+ (values
+ '("none" "G_DBUS_SERVER_FLAGS_NONE")
+ '("run-in-thread" "G_DBUS_SERVER_FLAGS_RUN_IN_THREAD")
+ '("authentication-allow-anonymous" "G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS")
+ )
+)
+
(define-flags BindFlags
(in-module "GSettings")
(c-name "GSettingsBindFlags")
@@ -1105,6 +1390,151 @@
+;; From gapplication.h
+
+(define-function g_application_get_type
+ (c-name "g_application_get_type")
+ (return-type "GType")
+)
+
+(define-function g_application_new
+ (c-name "g_application_new")
+ (is-constructor-of "GApplication")
+ (return-type "GApplication*")
+ (parameters
+ '("const-gchar*" "appid")
+ '("int" "argc")
+ '("char**" "argv")
+ )
+)
+
+(define-function g_application_try_new
+ (c-name "g_application_try_new")
+ (is-constructor-of "GApplicationTry")
+ (return-type "GApplication*")
+ (parameters
+ '("const-gchar*" "appid")
+ '("int" "argc")
+ '("char**" "argv")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_application_unregistered_try_new
+ (c-name "g_application_unregistered_try_new")
+ (is-constructor-of "GApplicationUnregisteredTry")
+ (return-type "GApplication*")
+ (parameters
+ '("const-gchar*" "appid")
+ '("int" "argc")
+ '("char**" "argv")
+ '("GError**" "error")
+ )
+)
+
+(define-method register
+ (of-object "GApplication")
+ (c-name "g_application_register")
+ (return-type "gboolean")
+)
+
+(define-function g_application_get_instance
+ (c-name "g_application_get_instance")
+ (return-type "GApplication*")
+)
+
+(define-method get_id
+ (of-object "GApplication")
+ (c-name "g_application_get_id")
+ (return-type "const-gchar*")
+)
+
+(define-method add_action
+ (of-object "GApplication")
+ (c-name "g_application_add_action")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "description")
+ )
+)
+
+(define-method remove_action
+ (of-object "GApplication")
+ (c-name "g_application_remove_action")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method list_actions
+ (of-object "GApplication")
+ (c-name "g_application_list_actions")
+ (return-type "gchar**")
+)
+
+(define-method set_action_enabled
+ (of-object "GApplication")
+ (c-name "g_application_set_action_enabled")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "name")
+ '("gboolean" "enabled")
+ )
+)
+
+(define-method get_action_enabled
+ (of-object "GApplication")
+ (c-name "g_application_get_action_enabled")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method get_action_description
+ (of-object "GApplication")
+ (c-name "g_application_get_action_description")
+ (return-type "const-gchar*")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method invoke_action
+ (of-object "GApplication")
+ (c-name "g_application_invoke_action")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "name")
+ '("GVariant*" "platform_data")
+ )
+)
+
+(define-method run
+ (of-object "GApplication")
+ (c-name "g_application_run")
+ (return-type "none")
+)
+
+(define-method quit_with_data
+ (of-object "GApplication")
+ (c-name "g_application_quit_with_data")
+ (return-type "gboolean")
+ (parameters
+ '("GVariant*" "platform_data")
+ )
+)
+
+(define-method is_remote
+ (of-object "GApplication")
+ (c-name "g_application_is_remote")
+ (return-type "gboolean")
+)
+
+
+
;; From gasyncinitable.h
(define-function g_async_initable_get_type
@@ -1693,6 +2123,71 @@
+;; From gcredentials.h
+
+(define-function g_credentials_get_type
+ (c-name "g_credentials_get_type")
+ (return-type "GType")
+)
+
+(define-function g_credentials_new
+ (c-name "g_credentials_new")
+ (is-constructor-of "GCredentials")
+ (return-type "GCredentials*")
+)
+
+(define-method to_string
+ (of-object "GCredentials")
+ (c-name "g_credentials_to_string")
+ (return-type "gchar*")
+)
+
+(define-method get_native
+ (of-object "GCredentials")
+ (c-name "g_credentials_get_native")
+ (return-type "gpointer")
+)
+
+(define-method set_native
+ (of-object "GCredentials")
+ (c-name "g_credentials_set_native")
+ (return-type "none")
+ (parameters
+ '("gpointer" "native")
+ )
+)
+
+(define-method is_same_user
+ (of-object "GCredentials")
+ (c-name "g_credentials_is_same_user")
+ (return-type "gboolean")
+ (parameters
+ '("GCredentials*" "other_credentials")
+ '("GError**" "error")
+ )
+)
+
+(define-method get_unix_user
+ (of-object "GCredentials")
+ (c-name "g_credentials_get_unix_user")
+ (return-type "uid_t")
+ (parameters
+ '("GError**" "error")
+ )
+)
+
+(define-method set_unix_user
+ (of-object "GCredentials")
+ (c-name "g_credentials_set_unix_user")
+ (return-type "gboolean")
+ (parameters
+ '("uid_t" "uid")
+ '("GError**" "error")
+ )
+)
+
+
+
;; From gdatainputstream.h
(define-function g_data_input_stream_get_type
@@ -2002,6 +2497,1774 @@
+;; From gdbusaddress.h
+
+(define-function g_dbus_is_address
+ (c-name "g_dbus_is_address")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "string")
+ )
+)
+
+(define-function g_dbus_is_supported_address
+ (c-name "g_dbus_is_supported_address")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "string")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_address_get_stream
+ (c-name "g_dbus_address_get_stream")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "address")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-function g_dbus_address_get_stream_finish
+ (c-name "g_dbus_address_get_stream_finish")
+ (return-type "GIOStream*")
+ (parameters
+ '("GAsyncResult*" "res")
+ '("gchar**" "out_guid")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_address_get_stream_sync
+ (c-name "g_dbus_address_get_stream_sync")
+ (return-type "GIOStream*")
+ (parameters
+ '("const-gchar*" "address")
+ '("gchar**" "out_guid")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_address_get_for_bus_sync
+ (c-name "g_dbus_address_get_for_bus_sync")
+ (return-type "gchar*")
+ (parameters
+ '("GBusType" "bus_type")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+
+
+;; From gdbusauthobserver.h
+
+(define-function g_dbus_auth_observer_get_type
+ (c-name "g_dbus_auth_observer_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_auth_observer_new
+ (c-name "g_dbus_auth_observer_new")
+ (is-constructor-of "GDbusAuthObserver")
+ (return-type "GDBusAuthObserver*")
+)
+
+(define-method authorize_authenticated_peer
+ (of-object "GDBusAuthObserver")
+ (c-name "g_dbus_auth_observer_authorize_authenticated_peer")
+ (return-type "gboolean")
+ (parameters
+ '("GIOStream*" "stream")
+ '("GCredentials*" "credentials")
+ )
+)
+
+
+
+;; From gdbusconnection.h
+
+(define-function g_dbus_connection_get_type
+ (c-name "g_dbus_connection_get_type")
+ (return-type "GType")
+)
+
+(define-function g_bus_get
+ (c-name "g_bus_get")
+ (return-type "none")
+ (parameters
+ '("GBusType" "bus_type")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-function g_bus_get_finish
+ (c-name "g_bus_get_finish")
+ (return-type "GDBusConnection*")
+ (parameters
+ '("GAsyncResult*" "res")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_bus_get_sync
+ (c-name "g_bus_get_sync")
+ (return-type "GDBusConnection*")
+ (parameters
+ '("GBusType" "bus_type")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_connection_new
+ (c-name "g_dbus_connection_new")
+ (return-type "none")
+ (parameters
+ '("GIOStream*" "stream")
+ '("const-gchar*" "guid")
+ '("GDBusConnectionFlags" "flags")
+ '("GDBusAuthObserver*" "observer")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-function g_dbus_connection_new_finish
+ (c-name "g_dbus_connection_new_finish")
+ (return-type "GDBusConnection*")
+ (parameters
+ '("GAsyncResult*" "res")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_connection_new_sync
+ (c-name "g_dbus_connection_new_sync")
+ (return-type "GDBusConnection*")
+ (parameters
+ '("GIOStream*" "stream")
+ '("const-gchar*" "guid")
+ '("GDBusConnectionFlags" "flags")
+ '("GDBusAuthObserver*" "observer")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_connection_new_for_address
+ (c-name "g_dbus_connection_new_for_address")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "address")
+ '("GDBusConnectionFlags" "flags")
+ '("GDBusAuthObserver*" "observer")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-function g_dbus_connection_new_for_address_finish
+ (c-name "g_dbus_connection_new_for_address_finish")
+ (return-type "GDBusConnection*")
+ (parameters
+ '("GAsyncResult*" "res")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_connection_new_for_address_sync
+ (c-name "g_dbus_connection_new_for_address_sync")
+ (return-type "GDBusConnection*")
+ (parameters
+ '("const-gchar*" "address")
+ '("GDBusConnectionFlags" "flags")
+ '("GDBusAuthObserver*" "observer")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-method is_closed
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_is_closed")
+ (return-type "gboolean")
+)
+
+(define-method close
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_close")
+ (return-type "none")
+)
+
+(define-method get_stream
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_get_stream")
+ (return-type "GIOStream*")
+)
+
+(define-method get_guid
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_get_guid")
+ (return-type "const-gchar*")
+)
+
+(define-method get_unique_name
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_get_unique_name")
+ (return-type "const-gchar*")
+)
+
+(define-method get_peer_credentials
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_get_peer_credentials")
+ (return-type "GCredentials*")
+)
+
+(define-method get_exit_on_close
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_get_exit_on_close")
+ (return-type "gboolean")
+)
+
+(define-method set_exit_on_close
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_set_exit_on_close")
+ (return-type "none")
+ (parameters
+ '("gboolean" "exit_on_close")
+ )
+)
+
+(define-method get_capabilities
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_get_capabilities")
+ (return-type "GDBusCapabilityFlags")
+)
+
+(define-method send_message
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_send_message")
+ (return-type "gboolean")
+ (parameters
+ '("GDBusMessage*" "message")
+ '("volatile-guint32*" "out_serial")
+ '("GError**" "error")
+ )
+)
+
+(define-method send_message_with_reply
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_send_message_with_reply")
+ (return-type "none")
+ (parameters
+ '("GDBusMessage*" "message")
+ '("gint" "timeout_msec")
+ '("volatile-guint32*" "out_serial")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-method send_message_with_reply_finish
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_send_message_with_reply_finish")
+ (return-type "GDBusMessage*")
+ (parameters
+ '("GAsyncResult*" "res")
+ '("GError**" "error")
+ )
+)
+
+(define-method send_message_with_reply_sync
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_send_message_with_reply_sync")
+ (return-type "GDBusMessage*")
+ (parameters
+ '("GDBusMessage*" "message")
+ '("gint" "timeout_msec")
+ '("volatile-guint32*" "out_serial")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-method emit_signal
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_emit_signal")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "destination_bus_name")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("const-gchar*" "signal_name")
+ '("GVariant*" "parameters")
+ '("GError**" "error")
+ )
+)
+
+(define-method call
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_call")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "bus_name")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("const-gchar*" "method_name")
+ '("GVariant*" "parameters")
+ '("const-GVariantType*" "reply_type")
+ '("GDBusCallFlags" "flags")
+ '("gint" "timeout_msec")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-method call_finish
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_call_finish")
+ (return-type "GVariant*")
+ (parameters
+ '("GAsyncResult*" "res")
+ '("GError**" "error")
+ )
+)
+
+(define-method call_sync
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_call_sync")
+ (return-type "GVariant*")
+ (parameters
+ '("const-gchar*" "bus_name")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("const-gchar*" "method_name")
+ '("GVariant*" "parameters")
+ '("const-GVariantType*" "reply_type")
+ '("GDBusCallFlags" "flags")
+ '("gint" "timeout_msec")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-method register_object
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_register_object")
+ (return-type "guint")
+ (parameters
+ '("const-gchar*" "object_path")
+ '("const-GDBusInterfaceInfo*" "introspection_data")
+ '("const-GDBusInterfaceVTable*" "vtable")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ '("GError**" "error")
+ )
+)
+
+(define-method unregister_object
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_unregister_object")
+ (return-type "gboolean")
+ (parameters
+ '("guint" "registration_id")
+ )
+)
+
+(define-method register_subtree
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_register_subtree")
+ (return-type "guint")
+ (parameters
+ '("const-gchar*" "object_path")
+ '("const-GDBusSubtreeVTable*" "vtable")
+ '("GDBusSubtreeFlags" "flags")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ '("GError**" "error")
+ )
+)
+
+(define-method unregister_subtree
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_unregister_subtree")
+ (return-type "gboolean")
+ (parameters
+ '("guint" "registration_id")
+ )
+)
+
+(define-method signal_subscribe
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_signal_subscribe")
+ (return-type "guint")
+ (parameters
+ '("const-gchar*" "sender")
+ '("const-gchar*" "interface_name")
+ '("const-gchar*" "member")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "arg0")
+ '("GDBusSignalCallback" "callback")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ )
+)
+
+(define-method signal_unsubscribe
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_signal_unsubscribe")
+ (return-type "none")
+ (parameters
+ '("guint" "subscription_id")
+ )
+)
+
+(define-method add_filter
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_add_filter")
+ (return-type "guint")
+ (parameters
+ '("GDBusMessageFilterFunction" "filter_function")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ )
+)
+
+(define-method remove_filter
+ (of-object "GDBusConnection")
+ (c-name "g_dbus_connection_remove_filter")
+ (return-type "none")
+ (parameters
+ '("guint" "filter_id")
+ )
+)
+
+
+
+;; From gdbuserror.h
+
+(define-function g_dbus_error_quark
+ (c-name "g_dbus_error_quark")
+ (return-type "GQuark")
+)
+
+(define-function g_dbus_error_is_remote_error
+ (c-name "g_dbus_error_is_remote_error")
+ (return-type "gboolean")
+ (parameters
+ '("const-GError*" "error")
+ )
+)
+
+(define-function g_dbus_error_get_remote_error
+ (c-name "g_dbus_error_get_remote_error")
+ (return-type "gchar*")
+ (parameters
+ '("const-GError*" "error")
+ )
+)
+
+(define-function g_dbus_error_strip_remote_error
+ (c-name "g_dbus_error_strip_remote_error")
+ (return-type "gboolean")
+ (parameters
+ '("GError*" "error")
+ )
+)
+
+(define-function g_dbus_error_register_error
+ (c-name "g_dbus_error_register_error")
+ (return-type "gboolean")
+ (parameters
+ '("GQuark" "error_domain")
+ '("gint" "error_code")
+ '("const-gchar*" "dbus_error_name")
+ )
+)
+
+(define-function g_dbus_error_unregister_error
+ (c-name "g_dbus_error_unregister_error")
+ (return-type "gboolean")
+ (parameters
+ '("GQuark" "error_domain")
+ '("gint" "error_code")
+ '("const-gchar*" "dbus_error_name")
+ )
+)
+
+(define-function g_dbus_error_register_error_domain
+ (c-name "g_dbus_error_register_error_domain")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "error_domain_quark_name")
+ '("volatile-gsize*" "quark_volatile")
+ '("const-GDBusErrorEntry*" "entries")
+ '("guint" "num_entries")
+ )
+)
+
+(define-function g_dbus_error_new_for_dbus_error
+ (c-name "g_dbus_error_new_for_dbus_error")
+ (return-type "GError*")
+ (parameters
+ '("const-gchar*" "dbus_error_name")
+ '("const-gchar*" "dbus_error_message")
+ )
+)
+
+(define-function g_dbus_error_set_dbus_error
+ (c-name "g_dbus_error_set_dbus_error")
+ (return-type "none")
+ (parameters
+ '("GError**" "error")
+ '("const-gchar*" "dbus_error_name")
+ '("const-gchar*" "dbus_error_message")
+ '("const-gchar*" "format")
+ )
+ (varargs #t)
+)
+
+(define-function g_dbus_error_set_dbus_error_valist
+ (c-name "g_dbus_error_set_dbus_error_valist")
+ (return-type "none")
+ (parameters
+ '("GError**" "error")
+ '("const-gchar*" "dbus_error_name")
+ '("const-gchar*" "dbus_error_message")
+ '("const-gchar*" "format")
+ '("va_list" "var_args")
+ )
+)
+
+(define-function g_dbus_error_encode_gerror
+ (c-name "g_dbus_error_encode_gerror")
+ (return-type "gchar*")
+ (parameters
+ '("const-GError*" "error")
+ )
+)
+
+
+
+;; From gdbusintrospection.h
+
+(define-function g_dbus_annotation_info_lookup
+ (c-name "g_dbus_annotation_info_lookup")
+ (return-type "const-gchar*")
+ (parameters
+ '("const-GDBusAnnotationInfo**" "annotations")
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method lookup_method
+ (of-object "GDBusInterfaceInfo")
+ (c-name "g_dbus_interface_info_lookup_method")
+ (return-type "const-GDBusMethodInfo*")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method lookup_signal
+ (of-object "GDBusInterfaceInfo")
+ (c-name "g_dbus_interface_info_lookup_signal")
+ (return-type "const-GDBusSignalInfo*")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method lookup_property
+ (of-object "GDBusInterfaceInfo")
+ (c-name "g_dbus_interface_info_lookup_property")
+ (return-type "const-GDBusPropertyInfo*")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method generate_xml
+ (of-object "GDBusInterfaceInfo")
+ (c-name "g_dbus_interface_info_generate_xml")
+ (return-type "none")
+ (parameters
+ '("guint" "indent")
+ '("GString*" "string_builder")
+ )
+)
+
+(define-function g_dbus_node_info_new_for_xml
+ (c-name "g_dbus_node_info_new_for_xml")
+ (return-type "GDBusNodeInfo*")
+ (parameters
+ '("const-gchar*" "xml_data")
+ '("GError**" "error")
+ )
+)
+
+(define-method lookup_interface
+ (of-object "GDBusNodeInfo")
+ (c-name "g_dbus_node_info_lookup_interface")
+ (return-type "const-GDBusInterfaceInfo*")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method generate_xml
+ (of-object "GDBusNodeInfo")
+ (c-name "g_dbus_node_info_generate_xml")
+ (return-type "none")
+ (parameters
+ '("guint" "indent")
+ '("GString*" "string_builder")
+ )
+)
+
+(define-method ref
+ (of-object "GDBusNodeInfo")
+ (c-name "g_dbus_node_info_ref")
+ (return-type "GDBusNodeInfo*")
+)
+
+(define-method ref
+ (of-object "GDBusInterfaceInfo")
+ (c-name "g_dbus_interface_info_ref")
+ (return-type "GDBusInterfaceInfo*")
+)
+
+(define-method ref
+ (of-object "GDBusMethodInfo")
+ (c-name "g_dbus_method_info_ref")
+ (return-type "GDBusMethodInfo*")
+)
+
+(define-method ref
+ (of-object "GDBusSignalInfo")
+ (c-name "g_dbus_signal_info_ref")
+ (return-type "GDBusSignalInfo*")
+)
+
+(define-method ref
+ (of-object "GDBusPropertyInfo")
+ (c-name "g_dbus_property_info_ref")
+ (return-type "GDBusPropertyInfo*")
+)
+
+(define-method ref
+ (of-object "GDBusArgInfo")
+ (c-name "g_dbus_arg_info_ref")
+ (return-type "GDBusArgInfo*")
+)
+
+(define-method ref
+ (of-object "GDBusAnnotationInfo")
+ (c-name "g_dbus_annotation_info_ref")
+ (return-type "GDBusAnnotationInfo*")
+)
+
+(define-method unref
+ (of-object "GDBusNodeInfo")
+ (c-name "g_dbus_node_info_unref")
+ (return-type "none")
+)
+
+(define-method unref
+ (of-object "GDBusInterfaceInfo")
+ (c-name "g_dbus_interface_info_unref")
+ (return-type "none")
+)
+
+(define-method unref
+ (of-object "GDBusMethodInfo")
+ (c-name "g_dbus_method_info_unref")
+ (return-type "none")
+)
+
+(define-method unref
+ (of-object "GDBusSignalInfo")
+ (c-name "g_dbus_signal_info_unref")
+ (return-type "none")
+)
+
+(define-method unref
+ (of-object "GDBusPropertyInfo")
+ (c-name "g_dbus_property_info_unref")
+ (return-type "none")
+)
+
+(define-method unref
+ (of-object "GDBusArgInfo")
+ (c-name "g_dbus_arg_info_unref")
+ (return-type "none")
+)
+
+(define-method unref
+ (of-object "GDBusAnnotationInfo")
+ (c-name "g_dbus_annotation_info_unref")
+ (return-type "none")
+)
+
+(define-function g_dbus_node_info_get_type
+ (c-name "g_dbus_node_info_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_interface_info_get_type
+ (c-name "g_dbus_interface_info_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_method_info_get_type
+ (c-name "g_dbus_method_info_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_signal_info_get_type
+ (c-name "g_dbus_signal_info_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_property_info_get_type
+ (c-name "g_dbus_property_info_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_arg_info_get_type
+ (c-name "g_dbus_arg_info_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_annotation_info_get_type
+ (c-name "g_dbus_annotation_info_get_type")
+ (return-type "GType")
+)
+
+
+
+;; From gdbusmessage.h
+
+(define-function g_dbus_message_get_type
+ (c-name "g_dbus_message_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_message_new
+ (c-name "g_dbus_message_new")
+ (is-constructor-of "GDbusMessage")
+ (return-type "GDBusMessage*")
+)
+
+(define-function g_dbus_message_new_signal
+ (c-name "g_dbus_message_new_signal")
+ (return-type "GDBusMessage*")
+ (parameters
+ '("const-gchar*" "path")
+ '("const-gchar*" "interface_")
+ '("const-gchar*" "signal")
+ )
+)
+
+(define-function g_dbus_message_new_method_call
+ (c-name "g_dbus_message_new_method_call")
+ (return-type "GDBusMessage*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "path")
+ '("const-gchar*" "interface_")
+ '("const-gchar*" "method")
+ )
+)
+
+(define-method new_method_reply
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_new_method_reply")
+ (return-type "GDBusMessage*")
+)
+
+(define-method new_method_error
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_new_method_error")
+ (return-type "GDBusMessage*")
+ (parameters
+ '("const-gchar*" "error_name")
+ '("const-gchar*" "error_message_format")
+ )
+ (varargs #t)
+)
+
+(define-method new_method_error_valist
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_new_method_error_valist")
+ (return-type "GDBusMessage*")
+ (parameters
+ '("const-gchar*" "error_name")
+ '("const-gchar*" "error_message_format")
+ '("va_list" "var_args")
+ )
+)
+
+(define-method new_method_error_literal
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_new_method_error_literal")
+ (return-type "GDBusMessage*")
+ (parameters
+ '("const-gchar*" "error_name")
+ '("const-gchar*" "error_message")
+ )
+)
+
+(define-method print
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_print")
+ (return-type "gchar*")
+ (parameters
+ '("guint" "indent")
+ )
+)
+
+(define-method get_message_type
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_message_type")
+ (return-type "GDBusMessageType")
+)
+
+(define-method set_message_type
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_message_type")
+ (return-type "none")
+ (parameters
+ '("GDBusMessageType" "type")
+ )
+)
+
+(define-method get_flags
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_flags")
+ (return-type "GDBusMessageFlags")
+)
+
+(define-method set_flags
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_flags")
+ (return-type "none")
+ (parameters
+ '("GDBusMessageFlags" "flags")
+ )
+)
+
+(define-method get_serial
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_serial")
+ (return-type "guint32")
+)
+
+(define-method set_serial
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_serial")
+ (return-type "none")
+ (parameters
+ '("guint32" "serial")
+ )
+)
+
+(define-method get_header
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_header")
+ (return-type "GVariant*")
+ (parameters
+ '("GDBusMessageHeaderField" "header_field")
+ )
+)
+
+(define-method set_header
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_header")
+ (return-type "none")
+ (parameters
+ '("GDBusMessageHeaderField" "header_field")
+ '("GVariant*" "value")
+ )
+)
+
+(define-method get_header_fields
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_header_fields")
+ (return-type "guchar*")
+)
+
+(define-method get_body
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_body")
+ (return-type "GVariant*")
+)
+
+(define-method set_body
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_body")
+ (return-type "none")
+ (parameters
+ '("GVariant*" "body")
+ )
+)
+
+(define-method get_unix_fd_list
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_unix_fd_list")
+ (return-type "GUnixFDList*")
+)
+
+(define-method set_unix_fd_list
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_unix_fd_list")
+ (return-type "none")
+ (parameters
+ '("GUnixFDList*" "fd_list")
+ )
+)
+
+(define-method get_reply_serial
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_reply_serial")
+ (return-type "guint32")
+)
+
+(define-method set_reply_serial
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_reply_serial")
+ (return-type "none")
+ (parameters
+ '("guint32" "value")
+ )
+)
+
+(define-method get_interface
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_interface")
+ (return-type "const-gchar*")
+)
+
+(define-method set_interface
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_interface")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "value")
+ )
+)
+
+(define-method get_member
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_member")
+ (return-type "const-gchar*")
+)
+
+(define-method set_member
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_member")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "value")
+ )
+)
+
+(define-method get_path
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_path")
+ (return-type "const-gchar*")
+)
+
+(define-method set_path
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_path")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "value")
+ )
+)
+
+(define-method get_sender
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_sender")
+ (return-type "const-gchar*")
+)
+
+(define-method set_sender
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_sender")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "value")
+ )
+)
+
+(define-method get_destination
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_destination")
+ (return-type "const-gchar*")
+)
+
+(define-method set_destination
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_destination")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "value")
+ )
+)
+
+(define-method get_error_name
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_error_name")
+ (return-type "const-gchar*")
+)
+
+(define-method set_error_name
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_error_name")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "value")
+ )
+)
+
+(define-method get_signature
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_signature")
+ (return-type "const-gchar*")
+)
+
+(define-method set_signature
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_signature")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "value")
+ )
+)
+
+(define-method get_num_unix_fds
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_num_unix_fds")
+ (return-type "guint32")
+)
+
+(define-method set_num_unix_fds
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_set_num_unix_fds")
+ (return-type "none")
+ (parameters
+ '("guint32" "value")
+ )
+)
+
+(define-method get_arg0
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_get_arg0")
+ (return-type "const-gchar*")
+)
+
+(define-function g_dbus_message_new_from_blob
+ (c-name "g_dbus_message_new_from_blob")
+ (return-type "GDBusMessage*")
+ (parameters
+ '("guchar*" "blob")
+ '("gsize" "blob_len")
+ '("GDBusCapabilityFlags" "capabilities")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_message_bytes_needed
+ (c-name "g_dbus_message_bytes_needed")
+ (return-type "gssize")
+ (parameters
+ '("guchar*" "blob")
+ '("gsize" "blob_len")
+ '("GError**" "error")
+ )
+)
+
+(define-method to_blob
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_to_blob")
+ (return-type "guchar*")
+ (parameters
+ '("gsize*" "out_size")
+ '("GDBusCapabilityFlags" "capabilities")
+ '("GError**" "error")
+ )
+)
+
+(define-method to_gerror
+ (of-object "GDBusMessage")
+ (c-name "g_dbus_message_to_gerror")
+ (return-type "gboolean")
+ (parameters
+ '("GError**" "error")
+ )
+)
+
+
+
+;; From gdbusmethodinvocation.h
+
+(define-function g_dbus_method_invocation_get_type
+ (c-name "g_dbus_method_invocation_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_method_invocation_new
+ (c-name "g_dbus_method_invocation_new")
+ (is-constructor-of "GDbusMethodInvocation")
+ (return-type "GDBusMethodInvocation*")
+ (parameters
+ '("const-gchar*" "sender")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("const-gchar*" "method_name")
+ '("const-GDBusMethodInfo*" "method_info")
+ '("GDBusConnection*" "connection")
+ '("GDBusMessage*" "message")
+ '("GVariant*" "parameters")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-method get_sender
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_get_sender")
+ (return-type "const-gchar*")
+)
+
+(define-method get_object_path
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_get_object_path")
+ (return-type "const-gchar*")
+)
+
+(define-method get_interface_name
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_get_interface_name")
+ (return-type "const-gchar*")
+)
+
+(define-method get_method_name
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_get_method_name")
+ (return-type "const-gchar*")
+)
+
+(define-method get_method_info
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_get_method_info")
+ (return-type "const-GDBusMethodInfo*")
+)
+
+(define-method get_connection
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_get_connection")
+ (return-type "GDBusConnection*")
+)
+
+(define-method get_message
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_get_message")
+ (return-type "GDBusMessage*")
+)
+
+(define-method get_parameters
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_get_parameters")
+ (return-type "GVariant*")
+)
+
+(define-method get_user_data
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_get_user_data")
+ (return-type "gpointer")
+)
+
+(define-method return_value
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_return_value")
+ (return-type "none")
+ (parameters
+ '("GVariant*" "parameters")
+ )
+)
+
+(define-method return_error
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_return_error")
+ (return-type "none")
+ (parameters
+ '("GQuark" "domain")
+ '("gint" "code")
+ '("const-gchar*" "format")
+ )
+ (varargs #t)
+)
+
+(define-method return_error_valist
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_return_error_valist")
+ (return-type "none")
+ (parameters
+ '("GQuark" "domain")
+ '("gint" "code")
+ '("const-gchar*" "format")
+ '("va_list" "var_args")
+ )
+)
+
+(define-method return_error_literal
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_return_error_literal")
+ (return-type "none")
+ (parameters
+ '("GQuark" "domain")
+ '("gint" "code")
+ '("const-gchar*" "message")
+ )
+)
+
+(define-method return_gerror
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_return_gerror")
+ (return-type "none")
+ (parameters
+ '("const-GError*" "error")
+ )
+)
+
+(define-method return_dbus_error
+ (of-object "GDBusMethodInvocation")
+ (c-name "g_dbus_method_invocation_return_dbus_error")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "error_name")
+ '("const-gchar*" "error_message")
+ )
+)
+
+
+
+;; From gdbusnameowning.h
+
+(define-function g_bus_own_name
+ (c-name "g_bus_own_name")
+ (return-type "guint")
+ (parameters
+ '("GBusType" "bus_type")
+ '("const-gchar*" "name")
+ '("GBusNameOwnerFlags" "flags")
+ '("GBusAcquiredCallback" "bus_acquired_handler")
+ '("GBusNameAcquiredCallback" "name_acquired_handler")
+ '("GBusNameLostCallback" "name_lost_handler")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ )
+)
+
+(define-function g_bus_own_name_on_connection
+ (c-name "g_bus_own_name_on_connection")
+ (return-type "guint")
+ (parameters
+ '("GDBusConnection*" "connection")
+ '("const-gchar*" "name")
+ '("GBusNameOwnerFlags" "flags")
+ '("GBusNameAcquiredCallback" "name_acquired_handler")
+ '("GBusNameLostCallback" "name_lost_handler")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ )
+)
+
+(define-function g_bus_own_name_with_closures
+ (c-name "g_bus_own_name_with_closures")
+ (return-type "guint")
+ (parameters
+ '("GBusType" "bus_type")
+ '("const-gchar*" "name")
+ '("GBusNameOwnerFlags" "flags")
+ '("GClosure*" "bus_acquired_closure")
+ '("GClosure*" "name_acquired_closure")
+ '("GClosure*" "name_lost_closure")
+ )
+)
+
+(define-function g_bus_own_name_on_connection_with_closures
+ (c-name "g_bus_own_name_on_connection_with_closures")
+ (return-type "guint")
+ (parameters
+ '("GDBusConnection*" "connection")
+ '("const-gchar*" "name")
+ '("GBusNameOwnerFlags" "flags")
+ '("GClosure*" "name_acquired_closure")
+ '("GClosure*" "name_lost_closure")
+ )
+)
+
+(define-function g_bus_unown_name
+ (c-name "g_bus_unown_name")
+ (return-type "none")
+ (parameters
+ '("guint" "owner_id")
+ )
+)
+
+
+
+;; From gdbusnamewatching.h
+
+(define-function g_bus_watch_name
+ (c-name "g_bus_watch_name")
+ (return-type "guint")
+ (parameters
+ '("GBusType" "bus_type")
+ '("const-gchar*" "name")
+ '("GBusNameWatcherFlags" "flags")
+ '("GBusNameAppearedCallback" "name_appeared_handler")
+ '("GBusNameVanishedCallback" "name_vanished_handler")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ )
+)
+
+(define-function g_bus_watch_name_on_connection
+ (c-name "g_bus_watch_name_on_connection")
+ (return-type "guint")
+ (parameters
+ '("GDBusConnection*" "connection")
+ '("const-gchar*" "name")
+ '("GBusNameWatcherFlags" "flags")
+ '("GBusNameAppearedCallback" "name_appeared_handler")
+ '("GBusNameVanishedCallback" "name_vanished_handler")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ )
+)
+
+(define-function g_bus_watch_name_with_closures
+ (c-name "g_bus_watch_name_with_closures")
+ (return-type "guint")
+ (parameters
+ '("GBusType" "bus_type")
+ '("const-gchar*" "name")
+ '("GBusNameWatcherFlags" "flags")
+ '("GClosure*" "name_appeared_closure")
+ '("GClosure*" "name_vanished_closure")
+ )
+)
+
+(define-function g_bus_watch_name_on_connection_with_closures
+ (c-name "g_bus_watch_name_on_connection_with_closures")
+ (return-type "guint")
+ (parameters
+ '("GDBusConnection*" "connection")
+ '("const-gchar*" "name")
+ '("GBusNameWatcherFlags" "flags")
+ '("GClosure*" "name_appeared_closure")
+ '("GClosure*" "name_vanished_closure")
+ )
+)
+
+(define-function g_bus_unwatch_name
+ (c-name "g_bus_unwatch_name")
+ (return-type "none")
+ (parameters
+ '("guint" "watcher_id")
+ )
+)
+
+
+
+;; From gdbusproxy.h
+
+(define-function g_dbus_proxy_get_type
+ (c-name "g_dbus_proxy_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_proxy_new
+ (c-name "g_dbus_proxy_new")
+ (return-type "none")
+ (parameters
+ '("GDBusConnection*" "connection")
+ '("GDBusProxyFlags" "flags")
+ '("GDBusInterfaceInfo*" "info")
+ '("const-gchar*" "name")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-function g_dbus_proxy_new_finish
+ (c-name "g_dbus_proxy_new_finish")
+ (return-type "GDBusProxy*")
+ (parameters
+ '("GAsyncResult*" "res")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_proxy_new_sync
+ (c-name "g_dbus_proxy_new_sync")
+ (return-type "GDBusProxy*")
+ (parameters
+ '("GDBusConnection*" "connection")
+ '("GDBusProxyFlags" "flags")
+ '("GDBusInterfaceInfo*" "info")
+ '("const-gchar*" "name")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_proxy_new_for_bus
+ (c-name "g_dbus_proxy_new_for_bus")
+ (return-type "none")
+ (parameters
+ '("GBusType" "bus_type")
+ '("GDBusProxyFlags" "flags")
+ '("GDBusInterfaceInfo*" "info")
+ '("const-gchar*" "name")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-function g_dbus_proxy_new_for_bus_finish
+ (c-name "g_dbus_proxy_new_for_bus_finish")
+ (return-type "GDBusProxy*")
+ (parameters
+ '("GAsyncResult*" "res")
+ '("GError**" "error")
+ )
+)
+
+(define-function g_dbus_proxy_new_for_bus_sync
+ (c-name "g_dbus_proxy_new_for_bus_sync")
+ (return-type "GDBusProxy*")
+ (parameters
+ '("GBusType" "bus_type")
+ '("GDBusProxyFlags" "flags")
+ '("GDBusInterfaceInfo*" "info")
+ '("const-gchar*" "name")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-method get_connection
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_connection")
+ (return-type "GDBusConnection*")
+)
+
+(define-method get_flags
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_flags")
+ (return-type "GDBusProxyFlags")
+)
+
+(define-method get_name
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_name")
+ (return-type "const-gchar*")
+)
+
+(define-method get_name_owner
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_name_owner")
+ (return-type "gchar*")
+)
+
+(define-method get_object_path
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_object_path")
+ (return-type "const-gchar*")
+)
+
+(define-method get_interface_name
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_interface_name")
+ (return-type "const-gchar*")
+)
+
+(define-method get_default_timeout
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_default_timeout")
+ (return-type "gint")
+)
+
+(define-method set_default_timeout
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_set_default_timeout")
+ (return-type "none")
+ (parameters
+ '("gint" "timeout_msec")
+ )
+)
+
+(define-method get_interface_info
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_interface_info")
+ (return-type "GDBusInterfaceInfo*")
+)
+
+(define-method set_interface_info
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_set_interface_info")
+ (return-type "none")
+ (parameters
+ '("GDBusInterfaceInfo*" "info")
+ )
+)
+
+(define-method get_cached_property
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_cached_property")
+ (return-type "GVariant*")
+ (parameters
+ '("const-gchar*" "property_name")
+ )
+)
+
+(define-method set_cached_property
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_set_cached_property")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "property_name")
+ '("GVariant*" "value")
+ )
+)
+
+(define-method get_cached_property_names
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_get_cached_property_names")
+ (return-type "gchar**")
+)
+
+(define-method call
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_call")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "method_name")
+ '("GVariant*" "parameters")
+ '("GDBusCallFlags" "flags")
+ '("gint" "timeout_msec")
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-method call_finish
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_call_finish")
+ (return-type "GVariant*")
+ (parameters
+ '("GAsyncResult*" "res")
+ '("GError**" "error")
+ )
+)
+
+(define-method call_sync
+ (of-object "GDBusProxy")
+ (c-name "g_dbus_proxy_call_sync")
+ (return-type "GVariant*")
+ (parameters
+ '("const-gchar*" "method_name")
+ '("GVariant*" "parameters")
+ '("GDBusCallFlags" "flags")
+ '("gint" "timeout_msec")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+
+
+;; From gdbusproxywatching.h
+
+(define-function g_bus_watch_proxy
+ (c-name "g_bus_watch_proxy")
+ (return-type "guint")
+ (parameters
+ '("GBusType" "bus_type")
+ '("const-gchar*" "name")
+ '("GBusNameWatcherFlags" "flags")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("GType" "interface_type")
+ '("GDBusProxyFlags" "proxy_flags")
+ '("GBusProxyAppearedCallback" "proxy_appeared_handler")
+ '("GBusProxyVanishedCallback" "proxy_vanished_handler")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ )
+)
+
+(define-function g_bus_watch_proxy_on_connection
+ (c-name "g_bus_watch_proxy_on_connection")
+ (return-type "guint")
+ (parameters
+ '("GDBusConnection*" "connection")
+ '("const-gchar*" "name")
+ '("GBusNameWatcherFlags" "flags")
+ '("const-gchar*" "object_path")
+ '("const-gchar*" "interface_name")
+ '("GType" "interface_type")
+ '("GDBusProxyFlags" "proxy_flags")
+ '("GBusProxyAppearedCallback" "proxy_appeared_handler")
+ '("GBusProxyVanishedCallback" "proxy_vanished_handler")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "user_data_free_func")
+ )
+)
+
+(define-function g_bus_unwatch_proxy
+ (c-name "g_bus_unwatch_proxy")
+ (return-type "none")
+ (parameters
+ '("guint" "watcher_id")
+ )
+)
+
+
+
+;; From gdbusserver.h
+
+(define-function g_dbus_server_get_type
+ (c-name "g_dbus_server_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_server_new_sync
+ (c-name "g_dbus_server_new_sync")
+ (return-type "GDBusServer*")
+ (parameters
+ '("const-gchar*" "address")
+ '("GDBusServerFlags" "flags")
+ '("const-gchar*" "guid")
+ '("GDBusAuthObserver*" "observer")
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-method get_client_address
+ (of-object "GDBusServer")
+ (c-name "g_dbus_server_get_client_address")
+ (return-type "const-gchar*")
+)
+
+(define-method get_guid
+ (of-object "GDBusServer")
+ (c-name "g_dbus_server_get_guid")
+ (return-type "const-gchar*")
+)
+
+(define-method get_flags
+ (of-object "GDBusServer")
+ (c-name "g_dbus_server_get_flags")
+ (return-type "GDBusServerFlags")
+)
+
+(define-method start
+ (of-object "GDBusServer")
+ (c-name "g_dbus_server_start")
+ (return-type "none")
+)
+
+(define-method stop
+ (of-object "GDBusServer")
+ (c-name "g_dbus_server_stop")
+ (return-type "none")
+)
+
+(define-method is_active
+ (of-object "GDBusServer")
+ (c-name "g_dbus_server_is_active")
+ (return-type "gboolean")
+)
+
+
+
+;; From gdbusutils.h
+
+(define-function g_dbus_is_guid
+ (c-name "g_dbus_is_guid")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "string")
+ )
+)
+
+(define-function g_dbus_generate_guid
+ (c-name "g_dbus_generate_guid")
+ (return-type "gchar*")
+)
+
+(define-function g_dbus_is_name
+ (c-name "g_dbus_is_name")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "string")
+ )
+)
+
+(define-function g_dbus_is_unique_name
+ (c-name "g_dbus_is_unique_name")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "string")
+ )
+)
+
+(define-function g_dbus_is_member_name
+ (c-name "g_dbus_is_member_name")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "string")
+ )
+)
+
+(define-function g_dbus_is_interface_name
+ (c-name "g_dbus_is_interface_name")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "string")
+ )
+)
+
+
+
;; From gdrive.h
(define-function g_drive_get_type
@@ -4207,6 +6470,11 @@
)
)
+(define-function g_file_attribute_matcher_get_type
+ (c-name "g_file_attribute_matcher_get_type")
+ (return-type "GType")
+)
+
(define-function g_file_attribute_matcher_new
(c-name "g_file_attribute_matcher_new")
(is-constructor-of "GFileAttributeMatcher")
@@ -5112,6 +7380,81 @@
(return-type "GType")
)
+(define-function g_unix_socket_address_type_get_type
+ (c-name "g_unix_socket_address_type_get_type")
+ (return-type "GType")
+)
+
+(define-function g_bus_type_get_type
+ (c-name "g_bus_type_get_type")
+ (return-type "GType")
+)
+
+(define-function g_bus_name_owner_flags_get_type
+ (c-name "g_bus_name_owner_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_bus_name_watcher_flags_get_type
+ (c-name "g_bus_name_watcher_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_proxy_flags_get_type
+ (c-name "g_dbus_proxy_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_error_get_type
+ (c-name "g_dbus_error_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_connection_flags_get_type
+ (c-name "g_dbus_connection_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_capability_flags_get_type
+ (c-name "g_dbus_capability_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_call_flags_get_type
+ (c-name "g_dbus_call_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_message_type_get_type
+ (c-name "g_dbus_message_type_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_message_flags_get_type
+ (c-name "g_dbus_message_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_message_header_field_get_type
+ (c-name "g_dbus_message_header_field_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_property_info_flags_get_type
+ (c-name "g_dbus_property_info_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_subtree_flags_get_type
+ (c-name "g_dbus_subtree_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_dbus_server_flags_get_type
+ (c-name "g_dbus_server_flags_get_type")
+ (return-type "GType")
+)
+
(define-function g_settings_bind_flags_get_type
(c-name "g_settings_bind_flags_get_type")
(return-type "GType")
@@ -6146,6 +8489,106 @@
+;; From gpermission.h
+
+(define-function g_permission_get_type
+ (c-name "g_permission_get_type")
+ (return-type "GType")
+)
+
+(define-method acquire
+ (of-object "GPermission")
+ (c-name "g_permission_acquire")
+ (return-type "gboolean")
+ (parameters
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-method acquire_async
+ (of-object "GPermission")
+ (c-name "g_permission_acquire_async")
+ (return-type "none")
+ (parameters
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-method acquire_finish
+ (of-object "GPermission")
+ (c-name "g_permission_acquire_finish")
+ (return-type "gboolean")
+ (parameters
+ '("GAsyncResult*" "result")
+ '("GError**" "error")
+ )
+)
+
+(define-method release
+ (of-object "GPermission")
+ (c-name "g_permission_release")
+ (return-type "gboolean")
+ (parameters
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-method release_async
+ (of-object "GPermission")
+ (c-name "g_permission_release_async")
+ (return-type "none")
+ (parameters
+ '("GCancellable*" "cancellable")
+ '("GAsyncReadyCallback" "callback")
+ '("gpointer" "user_data")
+ )
+)
+
+(define-method release_finish
+ (of-object "GPermission")
+ (c-name "g_permission_release_finish")
+ (return-type "gboolean")
+ (parameters
+ '("GAsyncResult*" "result")
+ '("GError**" "error")
+ )
+)
+
+(define-method get_allowed
+ (of-object "GPermission")
+ (c-name "g_permission_get_allowed")
+ (return-type "gboolean")
+)
+
+(define-method get_can_acquire
+ (of-object "GPermission")
+ (c-name "g_permission_get_can_acquire")
+ (return-type "gboolean")
+)
+
+(define-method get_can_release
+ (of-object "GPermission")
+ (c-name "g_permission_get_can_release")
+ (return-type "gboolean")
+)
+
+(define-method impl_update
+ (of-object "GPermission")
+ (c-name "g_permission_impl_update")
+ (return-type "none")
+ (parameters
+ '("gboolean" "allowed")
+ '("gboolean" "can_acquire")
+ '("gboolean" "can_release")
+ )
+)
+
+
+
;; From gresolver.h
(define-function g_resolver_get_type
@@ -6347,24 +8790,6 @@
(return-type "GType")
)
-(define-function g_settings_backend_setup
- (c-name "g_settings_backend_setup")
- (return-type "none")
- (parameters
- '("const-gchar*" "context")
- '("GSettingsBackend*" "backend")
- )
-)
-
-(define-function g_settings_backend_setup_keyfile
- (c-name "g_settings_backend_setup_keyfile")
- (return-type "none")
- (parameters
- '("const-gchar*" "context")
- '("const-gchar*" "filename")
- )
-)
-
(define-method changed
(of-object "GSettingsBackend")
(c-name "g_settings_backend_changed")
@@ -6385,6 +8810,17 @@
)
)
+(define-function g_settings_backend_flatten_tree
+ (c-name "g_settings_backend_flatten_tree")
+ (return-type "none")
+ (parameters
+ '("GTree*" "tree")
+ '("gchar**" "path")
+ '("const-gchar***" "keys")
+ '("GVariant***" "values")
+ )
+)
+
(define-method keys_changed
(of-object "GSettingsBackend")
(c-name "g_settings_backend_keys_changed")
@@ -6424,6 +8860,15 @@
)
)
+(define-function g_keyfile_settings_backend_new
+ (c-name "g_keyfile_settings_backend_new")
+ (is-constructor-of "GKeyfileSettingsBackend")
+ (return-type "GSettingsBackend*")
+ (parameters
+ '("const-gchar*" "filename")
+ )
+)
+
;; From gsettings.h
@@ -6451,29 +8896,21 @@
)
)
-(define-function g_settings_supports_context
- (c-name "g_settings_supports_context")
- (return-type "gboolean")
- (parameters
- '("const-gchar*" "context")
- )
-)
-
-(define-function g_settings_new_with_context
- (c-name "g_settings_new_with_context")
+(define-function g_settings_new_with_backend
+ (c-name "g_settings_new_with_backend")
(return-type "GSettings*")
(parameters
'("const-gchar*" "schema")
- '("const-gchar*" "context")
+ '("GSettingsBackend*" "backend")
)
)
-(define-function g_settings_new_with_context_and_path
- (c-name "g_settings_new_with_context_and_path")
+(define-function g_settings_new_with_backend_and_path
+ (c-name "g_settings_new_with_backend_and_path")
(return-type "GSettings*")
(parameters
'("const-gchar*" "schema")
- '("const-gchar*" "context")
+ '("GSettingsBackend*" "backend")
'("const-gchar*" "path")
)
)
@@ -6614,6 +9051,25 @@
)
)
+(define-method get_enum
+ (of-object "GSettings")
+ (c-name "g_settings_get_enum")
+ (return-type "gint")
+ (parameters
+ '("const-gchar*" "key")
+ )
+)
+
+(define-method set_enum
+ (of-object "GSettings")
+ (c-name "g_settings_set_enum")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "key")
+ '("gint" "value")
+ )
+)
+
(define-method get_child
(of-object "GSettings")
(c-name "g_settings_get_child")
@@ -6656,6 +9112,11 @@
(return-type "gboolean")
)
+(define-function g_settings_sync
+ (c-name "g_settings_sync")
+ (return-type "none")
+)
+
(define-method bind
(of-object "GSettings")
(c-name "g_settings_bind")
@@ -6914,6 +9375,24 @@
+;; From gsimplepermission.h
+
+(define-function g_simple_permission_get_type
+ (c-name "g_simple_permission_get_type")
+ (return-type "GType")
+)
+
+(define-function g_simple_permission_new
+ (c-name "g_simple_permission_new")
+ (is-constructor-of "GSimplePermission")
+ (return-type "GPermission*")
+ (parameters
+ '("gboolean" "allowed")
+ )
+)
+
+
+
;; From gsocketaddressenumerator.h
(define-function g_socket_address_enumerator_get_type
@@ -7410,6 +9889,21 @@
)
)
+(define-method get_timeout
+ (of-object "GSocket")
+ (c-name "g_socket_get_timeout")
+ (return-type "guint")
+)
+
+(define-method set_timeout
+ (of-object "GSocket")
+ (c-name "g_socket_set_timeout")
+ (return-type "none")
+ (parameters
+ '("guint" "timeout")
+ )
+)
+
(define-method is_connected
(of-object "GSocket")
(c-name "g_socket_is_connected")
@@ -8369,6 +10863,60 @@
)
)
+(define-method send_credentials
+ (of-object "GUnixConnection")
+ (c-name "g_unix_connection_send_credentials")
+ (return-type "gboolean")
+ (parameters
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+(define-method receive_credentials
+ (of-object "GUnixConnection")
+ (c-name "g_unix_connection_receive_credentials")
+ (return-type "GCredentials*")
+ (parameters
+ '("GCancellable*" "cancellable")
+ '("GError**" "error")
+ )
+)
+
+
+
+;; From gunixcredentialsmessage.h
+
+(define-function g_unix_credentials_message_get_type
+ (c-name "g_unix_credentials_message_get_type")
+ (return-type "GType")
+)
+
+(define-function g_unix_credentials_message_new
+ (c-name "g_unix_credentials_message_new")
+ (is-constructor-of "GUnixCredentialsMessage")
+ (return-type "GSocketControlMessage*")
+)
+
+(define-function g_unix_credentials_message_new_with_credentials
+ (c-name "g_unix_credentials_message_new_with_credentials")
+ (return-type "GSocketControlMessage*")
+ (parameters
+ '("GCredentials*" "credentials")
+ )
+)
+
+(define-method get_credentials
+ (of-object "GUnixCredentialsMessage")
+ (c-name "g_unix_credentials_message_get_credentials")
+ (return-type "GCredentials*")
+)
+
+(define-function g_unix_credentials_message_is_supported
+ (c-name "g_unix_credentials_message_is_supported")
+ (return-type "gboolean")
+)
+
;; From gunixfdlist.h
@@ -8819,7 +11367,17 @@
(return-type "GSocketAddress*")
(parameters
'("const-gchar*" "path")
- '("int" "path_len")
+ '("gint" "path_len")
+ )
+)
+
+(define-function g_unix_socket_address_new_with_type
+ (c-name "g_unix_socket_address_new_with_type")
+ (return-type "GSocketAddress*")
+ (parameters
+ '("const-gchar*" "path")
+ '("gint" "path_len")
+ '("GUnixSocketAddressType" "type")
)
)
@@ -8835,6 +11393,12 @@
(return-type "gsize")
)
+(define-method get_address_type
+ (of-object "GUnixSocketAddress")
+ (c-name "g_unix_socket_address_get_address_type")
+ (return-type "GUnixSocketAddressType")
+)
+
(define-method get_is_abstract
(of-object "GUnixSocketAddress")
(c-name "g_unix_socket_address_get_is_abstract")
diff --git a/gio/src/settings.ccg b/gio/src/settings.ccg
index 6fceed5..342b70f 100644
--- a/gio/src/settings.ccg
+++ b/gio/src/settings.ccg
@@ -3,12 +3,6 @@
namespace Gio
{
-Glib::RefPtr<Settings> Settings::create_with_context(const Glib::ustring& schema,
- const Glib::ustring& context)
-{
- return Glib::RefPtr<Settings>(new Settings(g_settings_new_with_context(schema.c_str(), context.c_str())));
-}
-
void Settings::bind(const Glib::ustring& key,
const Glib::PropertyProxy_Base& property_proxy,
SettingsBindFlags flags)
diff --git a/gio/src/settings.hg b/gio/src/settings.hg
index e6a61e5..1a84a84 100644
--- a/gio/src/settings.hg
+++ b/gio/src/settings.hg
@@ -16,6 +16,7 @@
*/
#include <glibmm/object.h>
+#include <giomm/settingsbackend.h>
_DEFS(giomm,gio)
_PINCLUDE(glibmm/private/object_p.h)
@@ -39,15 +40,14 @@ class Settings : public Glib::Object
protected:
_WRAP_CTOR(Settings(const Glib::ustring& schema), g_settings_new)
_WRAP_CTOR(Settings(const Glib::ustring& schema, const Glib::ustring& path), g_settings_new_with_path)
- // can't wrap both new_with_path and new_with_context since they both have the
- // same signature...
- _WRAP_CTOR(Settings(const Glib::ustring& schema, const Glib::ustring& context, const Glib::ustring& path), g_settings_new_with_context_and_path)
+ _WRAP_CTOR(Settings(const Glib::ustring& schema, const Glib::RefPtr<SettingsBackend>& backend), g_settings_new_with_backend)
+ _WRAP_CTOR(Settings(const Glib::ustring& schema, const Glib::RefPtr<SettingsBackend>& backend, const Glib::ustring& path), g_settings_new_with_backend_and_path)
public:
_WRAP_CREATE(const Glib::ustring& schema)
_WRAP_CREATE(const Glib::ustring& schema, const Glib::ustring& path)
- _WRAP_CREATE(const Glib::ustring& schema, const Glib::ustring& context, const Glib::ustring& path)
- static Glib::RefPtr<Settings> create_with_context(const Glib::ustring& schema, const Glib::ustring& context);
+ _WRAP_CREATE(const Glib::ustring& schema, const Glib::RefPtr<SettingsBackend>& backend)
+ _WRAP_CREATE(const Glib::ustring& schema, const Glib::RefPtr<SettingsBackend>& backend, const Glib::ustring& path)
// FIXME: implement the GVariant stuff
diff --git a/gio/src/settingsbackend.ccg b/gio/src/settingsbackend.ccg
new file mode 100644
index 0000000..5e09452
--- /dev/null
+++ b/gio/src/settingsbackend.ccg
@@ -0,0 +1,23 @@
+// -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+
+/* Copyright (C) 2007 The giomm Development Team
+ *
+ * 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, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+namespace Gio
+{
+
+} //namespace Gio
diff --git a/gio/src/settingsbackend.hg b/gio/src/settingsbackend.hg
new file mode 100644
index 0000000..634d4af
--- /dev/null
+++ b/gio/src/settingsbackend.hg
@@ -0,0 +1,66 @@
+// -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+
+/* Copyright (C) 2010 The giomm Development Team
+ *
+ * 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, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <glibmm/interface.h>
+#include <glibmm/object.h>
+
+_DEFS(giomm,gio)
+_PINCLUDE(glibmm/private/interface_p.h)
+
+#m4 _PUSH(SECTION_CC_PRE_INCLUDES)
+//Allow us to use g_settings_backend_get_type.
+//TODO: Find out if we should be able to implement backends outside of gio.
+//And if not, add an option to _CLASS_INTERFACE to avoid using it.
+#define G_SETTINGS_ENABLE_BACKEND 1
+#include <gio/gsettingsbackend.h>
+#include <gio/gio.h>
+#m4 _POP()
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GSettingsBackendClass GSettingsBackendClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+namespace Gio
+{
+
+/** TODO
+ */
+class SettingsBackend : public Glib::Interface
+{
+ _CLASS_INTERFACE(SettingsBackend, GSettingsBackend, G_SETTINGS_BACKEND, GSettingsBackendClass)
+
+public:
+
+ _WRAP_METHOD(void backend_changed(const Glib::ustring& key, gpointer origin_tag), g_settings_backend_changed)
+ _WRAP_METHOD(void path_changed(const Glib::ustring& path, gpointer origin_tag), g_settings_backend_path_changed)
+
+ //TODO: Use an ArrayHandle?
+ //_WRAP_METHOD(void keys_changed(const Glib::ustring& path, gchar const * const *items, gpointer origin_tag), g_settings_backend_keys_changed)
+
+ _WRAP_METHOD(void path_writable_changed(const Glib::ustring& path), g_settings_backend_path_writable_changed)
+ _WRAP_METHOD(void writable_changed(const Glib::ustring& key), g_settings_backend_writable_changed)
+
+ //TODO: Use the glibmm wrapper of GTree:
+ _WRAP_METHOD(void hanged_tree(GTree *tree, gpointer origin_tag), g_settings_backend_changed_tree)
+
+ //TODO: Vfuncs?
+};
+
+} // namespace Gio
diff --git a/glib/src/glib_functions.defs b/glib/src/glib_functions.defs
index c8ba98c..d705eb8 100644
--- a/glib/src/glib_functions.defs
+++ b/glib/src/glib_functions.defs
@@ -1,7 +1,120 @@
;; -*- scheme -*-
; object definitions ...
+(define-object Module
+ (in-module "GType")
+ (parent "GObject")
+ (c-name "GTypeModule")
+ (gtype-id "G_TYPE_TYPE_MODULE")
+)
+
+(define-object Plugin
+ (in-module "GType")
+ (c-name "GTypePlugin")
+ (gtype-id "G_TYPE_TYPE_PLUGIN")
+)
+
;; Enumerations and flags ...
+(define-flags Flags
+ (in-module "GBinding")
+ (c-name "GBindingFlags")
+ (gtype-id "G_TYPE_BINDING_FLAGS")
+ (values
+ '("default" "G_BINDING_DEFAULT")
+ '("bidirectional" "G_BINDING_BIDIRECTIONAL")
+ )
+)
+
+(define-flags Flags
+ (in-module "GParam")
+ (c-name "GParamFlags")
+ (gtype-id "G_TYPE_PARAM_FLAGS")
+ (values
+ '("readable" "G_PARAM_READABLE")
+ '("writable" "G_PARAM_WRITABLE")
+ '("construct" "G_PARAM_CONSTRUCT")
+ '("construct-only" "G_PARAM_CONSTRUCT_ONLY")
+ '("lax-validation" "G_PARAM_LAX_VALIDATION")
+ '("static-name" "G_PARAM_STATIC_NAME")
+ '("private" "G_PARAM_PRIVATE")
+ '("static-nick" "G_PARAM_STATIC_NICK")
+ '("static-blurb" "G_PARAM_STATIC_BLURB")
+ )
+)
+
+(define-flags Flags
+ (in-module "GSignal")
+ (c-name "GSignalFlags")
+ (gtype-id "G_TYPE_SIGNAL_FLAGS")
+ (values
+ '("run-first" "G_SIGNAL_RUN_FIRST")
+ '("run-last" "G_SIGNAL_RUN_LAST")
+ '("run-cleanup" "G_SIGNAL_RUN_CLEANUP")
+ '("no-recurse" "G_SIGNAL_NO_RECURSE")
+ '("detailed" "G_SIGNAL_DETAILED")
+ '("action" "G_SIGNAL_ACTION")
+ '("no-hooks" "G_SIGNAL_NO_HOOKS")
+ )
+)
+
+(define-flags Flags
+ (in-module "GConnect")
+ (c-name "GConnectFlags")
+ (gtype-id "G_TYPE_CONNECT_FLAGS")
+ (values
+ '("after" "G_CONNECT_AFTER")
+ '("swapped" "G_CONNECT_SWAPPED")
+ )
+)
+
+(define-flags MatchType
+ (in-module "GSignal")
+ (c-name "GSignalMatchType")
+ (gtype-id "G_TYPE_SIGNAL_MATCH_TYPE")
+ (values
+ '("id" "G_SIGNAL_MATCH_ID")
+ '("detail" "G_SIGNAL_MATCH_DETAIL")
+ '("closure" "G_SIGNAL_MATCH_CLOSURE")
+ '("func" "G_SIGNAL_MATCH_FUNC")
+ '("data" "G_SIGNAL_MATCH_DATA")
+ '("unblocked" "G_SIGNAL_MATCH_UNBLOCKED")
+ )
+)
+
+(define-flags DebugFlags
+ (in-module "GType")
+ (c-name "GTypeDebugFlags")
+ (gtype-id "G_TYPE_TYPE_DEBUG_FLAGS")
+ (values
+ '("none" "G_TYPE_DEBUG_NONE")
+ '("objects" "G_TYPE_DEBUG_OBJECTS")
+ '("signals" "G_TYPE_DEBUG_SIGNALS")
+ '("mask" "G_TYPE_DEBUG_MASK")
+ )
+)
+
+(define-flags FundamentalFlags
+ (in-module "GType")
+ (c-name "GTypeFundamentalFlags")
+ (gtype-id "G_TYPE_TYPE_FUNDAMENTAL_FLAGS")
+ (values
+ '("classed" "G_TYPE_FLAG_CLASSED")
+ '("instantiatable" "G_TYPE_FLAG_INSTANTIATABLE")
+ '("derivable" "G_TYPE_FLAG_DERIVABLE")
+ '("deep-derivable" "G_TYPE_FLAG_DEEP_DERIVABLE")
+ )
+)
+
+(define-flags Flags
+ (in-module "GType")
+ (c-name "GTypeFlags")
+ (gtype-id "G_TYPE_TYPE_FLAGS")
+ (values
+ '("abstract" "G_TYPE_FLAG_ABSTRACT")
+ '("value-abstract" "G_TYPE_FLAG_VALUE_ABSTRACT")
+ )
+)
+
(define-enum FileError
(in-module "GBookmark")
(c-name "GBookmarkFileError")
@@ -607,7 +720,7 @@
(c-name "GThreadError")
(gtype-id "G_TYPE_THREAD_ERROR")
(values
- '("n" "G_THREAD_ERROR_AGAIN")
+ '("again" "G_THREAD_ERROR_AGAIN")
)
)
@@ -862,6 +975,3079 @@
)
)
+(define-flags Flags
+ (in-module "GModule")
+ (c-name "GModuleFlags")
+ (gtype-id "G_TYPE_MODULE_FLAGS")
+ (values
+ '("lazy" "G_MODULE_BIND_LAZY")
+ '("local" "G_MODULE_BIND_LOCAL")
+ '("mask" "G_MODULE_BIND_MASK")
+ )
+)
+
+
+;; From gbinding.h
+
+(define-function g_binding_flags_get_type
+ (c-name "g_binding_flags_get_type")
+ (return-type "GType")
+)
+
+(define-function g_binding_get_type
+ (c-name "g_binding_get_type")
+ (return-type "GType")
+)
+
+(define-method get_flags
+ (of-object "GBinding")
+ (c-name "g_binding_get_flags")
+ (return-type "GBindingFlags")
+)
+
+(define-method get_source
+ (of-object "GBinding")
+ (c-name "g_binding_get_source")
+ (return-type "GObject*")
+)
+
+(define-method get_target
+ (of-object "GBinding")
+ (c-name "g_binding_get_target")
+ (return-type "GObject*")
+)
+
+(define-method get_source_property
+ (of-object "GBinding")
+ (c-name "g_binding_get_source_property")
+ (return-type "const-gchar*")
+)
+
+(define-method get_target_property
+ (of-object "GBinding")
+ (c-name "g_binding_get_target_property")
+ (return-type "const-gchar*")
+)
+
+(define-function g_object_bind_property
+ (c-name "g_object_bind_property")
+ (return-type "GBinding*")
+ (parameters
+ '("gpointer" "source")
+ '("const-gchar*" "source_property")
+ '("gpointer" "target")
+ '("const-gchar*" "target_property")
+ '("GBindingFlags" "flags")
+ )
+)
+
+(define-function g_object_bind_property_full
+ (c-name "g_object_bind_property_full")
+ (return-type "GBinding*")
+ (parameters
+ '("gpointer" "source")
+ '("const-gchar*" "source_property")
+ '("gpointer" "target")
+ '("const-gchar*" "target_property")
+ '("GBindingFlags" "flags")
+ '("GBindingTransformFunc" "transform_to")
+ '("GBindingTransformFunc" "transform_from")
+ '("gpointer" "user_data")
+ '("GDestroyNotify" "notify")
+ )
+)
+
+
+
+;; From gboxed.h
+
+(define-function g_boxed_copy
+ (c-name "g_boxed_copy")
+ (return-type "gpointer")
+ (parameters
+ '("GType" "boxed_type")
+ '("gconstpointer" "src_boxed")
+ )
+)
+
+(define-function g_boxed_free
+ (c-name "g_boxed_free")
+ (return-type "none")
+ (parameters
+ '("GType" "boxed_type")
+ '("gpointer" "boxed")
+ )
+)
+
+(define-method set_boxed
+ (of-object "GValue")
+ (c-name "g_value_set_boxed")
+ (return-type "none")
+ (parameters
+ '("gconstpointer" "v_boxed")
+ )
+)
+
+(define-method set_static_boxed
+ (of-object "GValue")
+ (c-name "g_value_set_static_boxed")
+ (return-type "none")
+ (parameters
+ '("gconstpointer" "v_boxed")
+ )
+)
+
+(define-method get_boxed
+ (of-object "GValue")
+ (c-name "g_value_get_boxed")
+ (return-type "gpointer")
+)
+
+(define-method dup_boxed
+ (of-object "GValue")
+ (c-name "g_value_dup_boxed")
+ (return-type "gpointer")
+)
+
+(define-function g_boxed_type_register_static
+ (c-name "g_boxed_type_register_static")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "name")
+ '("GBoxedCopyFunc" "boxed_copy")
+ '("GBoxedFreeFunc" "boxed_free")
+ )
+)
+
+(define-method take_boxed
+ (of-object "GValue")
+ (c-name "g_value_take_boxed")
+ (return-type "none")
+ (parameters
+ '("gconstpointer" "v_boxed")
+ )
+)
+
+(define-method set_boxed_take_ownership
+ (of-object "GValue")
+ (c-name "g_value_set_boxed_take_ownership")
+ (return-type "none")
+ (parameters
+ '("gconstpointer" "v_boxed")
+ )
+)
+
+(define-function g_closure_get_type
+ (c-name "g_closure_get_type")
+ (return-type "GType")
+)
+
+(define-function g_value_get_type
+ (c-name "g_value_get_type")
+ (return-type "GType")
+)
+
+(define-function g_value_array_get_type
+ (c-name "g_value_array_get_type")
+ (return-type "GType")
+)
+
+(define-function g_date_get_type
+ (c-name "g_date_get_type")
+ (return-type "GType")
+)
+
+(define-function g_strv_get_type
+ (c-name "g_strv_get_type")
+ (return-type "GType")
+)
+
+(define-function g_gstring_get_type
+ (c-name "g_gstring_get_type")
+ (return-type "GType")
+)
+
+(define-function g_hash_table_get_type
+ (c-name "g_hash_table_get_type")
+ (return-type "GType")
+)
+
+(define-function g_array_get_type
+ (c-name "g_array_get_type")
+ (return-type "GType")
+)
+
+(define-function g_byte_array_get_type
+ (c-name "g_byte_array_get_type")
+ (return-type "GType")
+)
+
+(define-function g_ptr_array_get_type
+ (c-name "g_ptr_array_get_type")
+ (return-type "GType")
+)
+
+(define-function g_variant_type_get_gtype
+ (c-name "g_variant_type_get_gtype")
+ (return-type "GType")
+)
+
+(define-function g_regex_get_type
+ (c-name "g_regex_get_type")
+ (return-type "GType")
+)
+
+(define-function g_error_get_type
+ (c-name "g_error_get_type")
+ (return-type "GType")
+)
+
+(define-function g_variant_get_gtype
+ (c-name "g_variant_get_gtype")
+ (return-type "GType")
+)
+
+
+
+;; From gclosure.h
+
+(define-function g_cclosure_new
+ (c-name "g_cclosure_new")
+ (is-constructor-of "GCclosure")
+ (return-type "GClosure*")
+ (parameters
+ '("GCallback" "callback_func")
+ '("gpointer" "user_data")
+ '("GClosureNotify" "destroy_data")
+ )
+)
+
+(define-function g_cclosure_new_swap
+ (c-name "g_cclosure_new_swap")
+ (return-type "GClosure*")
+ (parameters
+ '("GCallback" "callback_func")
+ '("gpointer" "user_data")
+ '("GClosureNotify" "destroy_data")
+ )
+)
+
+(define-function g_signal_type_cclosure_new
+ (c-name "g_signal_type_cclosure_new")
+ (is-constructor-of "GSignalTypeCclosure")
+ (return-type "GClosure*")
+ (parameters
+ '("GType" "itype")
+ '("guint" "struct_offset")
+ )
+)
+
+(define-method ref
+ (of-object "GClosure")
+ (c-name "g_closure_ref")
+ (return-type "GClosure*")
+)
+
+(define-method sink
+ (of-object "GClosure")
+ (c-name "g_closure_sink")
+ (return-type "none")
+)
+
+(define-method unref
+ (of-object "GClosure")
+ (c-name "g_closure_unref")
+ (return-type "none")
+)
+
+(define-function g_closure_new_simple
+ (c-name "g_closure_new_simple")
+ (return-type "GClosure*")
+ (parameters
+ '("guint" "sizeof_closure")
+ '("gpointer" "data")
+ )
+)
+
+(define-method add_finalize_notifier
+ (of-object "GClosure")
+ (c-name "g_closure_add_finalize_notifier")
+ (return-type "none")
+ (parameters
+ '("gpointer" "notify_data")
+ '("GClosureNotify" "notify_func")
+ )
+)
+
+(define-method remove_finalize_notifier
+ (of-object "GClosure")
+ (c-name "g_closure_remove_finalize_notifier")
+ (return-type "none")
+ (parameters
+ '("gpointer" "notify_data")
+ '("GClosureNotify" "notify_func")
+ )
+)
+
+(define-method add_invalidate_notifier
+ (of-object "GClosure")
+ (c-name "g_closure_add_invalidate_notifier")
+ (return-type "none")
+ (parameters
+ '("gpointer" "notify_data")
+ '("GClosureNotify" "notify_func")
+ )
+)
+
+(define-method remove_invalidate_notifier
+ (of-object "GClosure")
+ (c-name "g_closure_remove_invalidate_notifier")
+ (return-type "none")
+ (parameters
+ '("gpointer" "notify_data")
+ '("GClosureNotify" "notify_func")
+ )
+)
+
+(define-method add_marshal_guards
+ (of-object "GClosure")
+ (c-name "g_closure_add_marshal_guards")
+ (return-type "none")
+ (parameters
+ '("gpointer" "pre_marshal_data")
+ '("GClosureNotify" "pre_marshal_notify")
+ '("gpointer" "post_marshal_data")
+ '("GClosureNotify" "post_marshal_notify")
+ )
+)
+
+(define-method set_marshal
+ (of-object "GClosure")
+ (c-name "g_closure_set_marshal")
+ (return-type "none")
+ (parameters
+ '("GClosureMarshal" "marshal")
+ )
+)
+
+(define-method set_meta_marshal
+ (of-object "GClosure")
+ (c-name "g_closure_set_meta_marshal")
+ (return-type "none")
+ (parameters
+ '("gpointer" "marshal_data")
+ '("GClosureMarshal" "meta_marshal")
+ )
+)
+
+(define-method invalidate
+ (of-object "GClosure")
+ (c-name "g_closure_invalidate")
+ (return-type "none")
+)
+
+(define-method invoke
+ (of-object "GClosure")
+ (c-name "g_closure_invoke")
+ (return-type "none")
+ (parameters
+ '("GValue*" "return_value")
+ '("guint" "n_param_values")
+ '("const-GValue*" "param_values")
+ '("gpointer" "invocation_hint")
+ )
+)
+
+
+
+;; From genums.h
+
+(define-function g_enum_get_value
+ (c-name "g_enum_get_value")
+ (return-type "GEnumValue*")
+ (parameters
+ '("GEnumClass*" "enum_class")
+ '("gint" "value")
+ )
+)
+
+(define-function g_enum_get_value_by_name
+ (c-name "g_enum_get_value_by_name")
+ (return-type "GEnumValue*")
+ (parameters
+ '("GEnumClass*" "enum_class")
+ '("const-gchar*" "name")
+ )
+)
+
+(define-function g_enum_get_value_by_nick
+ (c-name "g_enum_get_value_by_nick")
+ (return-type "GEnumValue*")
+ (parameters
+ '("GEnumClass*" "enum_class")
+ '("const-gchar*" "nick")
+ )
+)
+
+(define-function g_flags_get_first_value
+ (c-name "g_flags_get_first_value")
+ (return-type "GFlagsValue*")
+ (parameters
+ '("GFlagsClass*" "flags_class")
+ '("guint" "value")
+ )
+)
+
+(define-function g_flags_get_value_by_name
+ (c-name "g_flags_get_value_by_name")
+ (return-type "GFlagsValue*")
+ (parameters
+ '("GFlagsClass*" "flags_class")
+ '("const-gchar*" "name")
+ )
+)
+
+(define-function g_flags_get_value_by_nick
+ (c-name "g_flags_get_value_by_nick")
+ (return-type "GFlagsValue*")
+ (parameters
+ '("GFlagsClass*" "flags_class")
+ '("const-gchar*" "nick")
+ )
+)
+
+(define-method set_enum
+ (of-object "GValue")
+ (c-name "g_value_set_enum")
+ (return-type "none")
+ (parameters
+ '("gint" "v_enum")
+ )
+)
+
+(define-method get_enum
+ (of-object "GValue")
+ (c-name "g_value_get_enum")
+ (return-type "gint")
+)
+
+(define-method set_flags
+ (of-object "GValue")
+ (c-name "g_value_set_flags")
+ (return-type "none")
+ (parameters
+ '("guint" "v_flags")
+ )
+)
+
+(define-method get_flags
+ (of-object "GValue")
+ (c-name "g_value_get_flags")
+ (return-type "guint")
+)
+
+(define-function g_enum_register_static
+ (c-name "g_enum_register_static")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-GEnumValue*" "const_static_values")
+ )
+)
+
+(define-function g_flags_register_static
+ (c-name "g_flags_register_static")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-GFlagsValue*" "const_static_values")
+ )
+)
+
+(define-function g_enum_complete_type_info
+ (c-name "g_enum_complete_type_info")
+ (return-type "none")
+ (parameters
+ '("GType" "g_enum_type")
+ '("GTypeInfo*" "info")
+ '("const-GEnumValue*" "const_values")
+ )
+)
+
+(define-function g_flags_complete_type_info
+ (c-name "g_flags_complete_type_info")
+ (return-type "none")
+ (parameters
+ '("GType" "g_flags_type")
+ '("GTypeInfo*" "info")
+ '("const-GFlagsValue*" "const_values")
+ )
+)
+
+
+
+;; From gmarshal.h
+
+
+
+;; From gobject.h
+
+(define-function g_initially_unowned_get_type
+ (c-name "g_initially_unowned_get_type")
+ (return-type "GType")
+)
+
+(define-method install_property
+ (of-object "GObjectClass")
+ (c-name "g_object_class_install_property")
+ (return-type "none")
+ (parameters
+ '("guint" "property_id")
+ '("GParamSpec*" "pspec")
+ )
+)
+
+(define-method find_property
+ (of-object "GObjectClass")
+ (c-name "g_object_class_find_property")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "property_name")
+ )
+)
+
+(define-method list_properties
+ (of-object "GObjectClass")
+ (c-name "g_object_class_list_properties")
+ (return-type "GParamSpec**")
+ (parameters
+ '("guint*" "n_properties")
+ )
+)
+
+(define-method override_property
+ (of-object "GObjectClass")
+ (c-name "g_object_class_override_property")
+ (return-type "none")
+ (parameters
+ '("guint" "property_id")
+ '("const-gchar*" "name")
+ )
+)
+
+(define-function g_object_interface_install_property
+ (c-name "g_object_interface_install_property")
+ (return-type "none")
+ (parameters
+ '("gpointer" "g_iface")
+ '("GParamSpec*" "pspec")
+ )
+)
+
+(define-function g_object_interface_find_property
+ (c-name "g_object_interface_find_property")
+ (return-type "GParamSpec*")
+ (parameters
+ '("gpointer" "g_iface")
+ '("const-gchar*" "property_name")
+ )
+)
+
+(define-function g_object_interface_list_properties
+ (c-name "g_object_interface_list_properties")
+ (return-type "GParamSpec**")
+ (parameters
+ '("gpointer" "g_iface")
+ '("guint*" "n_properties_p")
+ )
+)
+
+(define-function g_object_get_type
+ (c-name "g_object_get_type")
+ (return-type "GType")
+)
+
+(define-function g_object_new
+ (c-name "g_object_new")
+ (return-type "gpointer")
+ (parameters
+ '("GType" "object_type")
+ '("const-gchar*" "first_property_name")
+ )
+ (varargs #t)
+)
+
+(define-function g_object_newv
+ (c-name "g_object_newv")
+ (return-type "gpointer")
+ (parameters
+ '("GType" "object_type")
+ '("guint" "n_parameters")
+ '("GParameter*" "parameters")
+ )
+)
+
+(define-function g_object_new_valist
+ (c-name "g_object_new_valist")
+ (return-type "GObject*")
+ (parameters
+ '("GType" "object_type")
+ '("const-gchar*" "first_property_name")
+ '("va_list" "var_args")
+ )
+)
+
+(define-function g_object_set
+ (c-name "g_object_set")
+ (return-type "none")
+ (parameters
+ '("gpointer" "object")
+ '("const-gchar*" "first_property_name")
+ )
+ (varargs #t)
+)
+
+(define-function g_object_get
+ (c-name "g_object_get")
+ (return-type "none")
+ (parameters
+ '("gpointer" "object")
+ '("const-gchar*" "first_property_name")
+ )
+ (varargs #t)
+)
+
+(define-function g_object_connect
+ (c-name "g_object_connect")
+ (return-type "gpointer")
+ (parameters
+ '("gpointer" "object")
+ '("const-gchar*" "signal_spec")
+ )
+ (varargs #t)
+)
+
+(define-function g_object_disconnect
+ (c-name "g_object_disconnect")
+ (return-type "none")
+ (parameters
+ '("gpointer" "object")
+ '("const-gchar*" "signal_spec")
+ )
+ (varargs #t)
+)
+
+(define-method set_valist
+ (of-object "GObject")
+ (c-name "g_object_set_valist")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "first_property_name")
+ '("va_list" "var_args")
+ )
+)
+
+(define-method get_valist
+ (of-object "GObject")
+ (c-name "g_object_get_valist")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "first_property_name")
+ '("va_list" "var_args")
+ )
+)
+
+(define-method set_property
+ (of-object "GObject")
+ (c-name "g_object_set_property")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "property_name")
+ '("const-GValue*" "value")
+ )
+)
+
+(define-method get_property
+ (of-object "GObject")
+ (c-name "g_object_get_property")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "property_name")
+ '("GValue*" "value")
+ )
+)
+
+(define-method freeze_notify
+ (of-object "GObject")
+ (c-name "g_object_freeze_notify")
+ (return-type "none")
+)
+
+(define-method notify
+ (of-object "GObject")
+ (c-name "g_object_notify")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "property_name")
+ )
+)
+
+(define-method notify_by_pspec
+ (of-object "GObject")
+ (c-name "g_object_notify_by_pspec")
+ (return-type "none")
+ (parameters
+ '("GParamSpec*" "pspec")
+ )
+)
+
+(define-method thaw_notify
+ (of-object "GObject")
+ (c-name "g_object_thaw_notify")
+ (return-type "none")
+)
+
+(define-function g_object_is_floating
+ (c-name "g_object_is_floating")
+ (return-type "gboolean")
+ (parameters
+ '("gpointer" "object")
+ )
+)
+
+(define-function g_object_ref_sink
+ (c-name "g_object_ref_sink")
+ (return-type "gpointer")
+ (parameters
+ '("gpointer" "object")
+ )
+)
+
+(define-function g_object_ref
+ (c-name "g_object_ref")
+ (return-type "gpointer")
+ (parameters
+ '("gpointer" "object")
+ )
+)
+
+(define-function g_object_unref
+ (c-name "g_object_unref")
+ (return-type "none")
+ (parameters
+ '("gpointer" "object")
+ )
+)
+
+(define-method weak_ref
+ (of-object "GObject")
+ (c-name "g_object_weak_ref")
+ (return-type "none")
+ (parameters
+ '("GWeakNotify" "notify")
+ '("gpointer" "data")
+ )
+)
+
+(define-method weak_unref
+ (of-object "GObject")
+ (c-name "g_object_weak_unref")
+ (return-type "none")
+ (parameters
+ '("GWeakNotify" "notify")
+ '("gpointer" "data")
+ )
+)
+
+(define-method add_weak_pointer
+ (of-object "GObject")
+ (c-name "g_object_add_weak_pointer")
+ (return-type "none")
+ (parameters
+ '("gpointer*" "weak_pointer_location")
+ )
+)
+
+(define-method remove_weak_pointer
+ (of-object "GObject")
+ (c-name "g_object_remove_weak_pointer")
+ (return-type "none")
+ (parameters
+ '("gpointer*" "weak_pointer_location")
+ )
+)
+
+(define-method add_toggle_ref
+ (of-object "GObject")
+ (c-name "g_object_add_toggle_ref")
+ (return-type "none")
+ (parameters
+ '("GToggleNotify" "notify")
+ '("gpointer" "data")
+ )
+)
+
+(define-method remove_toggle_ref
+ (of-object "GObject")
+ (c-name "g_object_remove_toggle_ref")
+ (return-type "none")
+ (parameters
+ '("GToggleNotify" "notify")
+ '("gpointer" "data")
+ )
+)
+
+(define-method get_qdata
+ (of-object "GObject")
+ (c-name "g_object_get_qdata")
+ (return-type "gpointer")
+ (parameters
+ '("GQuark" "quark")
+ )
+)
+
+(define-method set_qdata
+ (of-object "GObject")
+ (c-name "g_object_set_qdata")
+ (return-type "none")
+ (parameters
+ '("GQuark" "quark")
+ '("gpointer" "data")
+ )
+)
+
+(define-method set_qdata_full
+ (of-object "GObject")
+ (c-name "g_object_set_qdata_full")
+ (return-type "none")
+ (parameters
+ '("GQuark" "quark")
+ '("gpointer" "data")
+ '("GDestroyNotify" "destroy")
+ )
+)
+
+(define-method steal_qdata
+ (of-object "GObject")
+ (c-name "g_object_steal_qdata")
+ (return-type "gpointer")
+ (parameters
+ '("GQuark" "quark")
+ )
+)
+
+(define-method get_data
+ (of-object "GObject")
+ (c-name "g_object_get_data")
+ (return-type "gpointer")
+ (parameters
+ '("const-gchar*" "key")
+ )
+)
+
+(define-method set_data
+ (of-object "GObject")
+ (c-name "g_object_set_data")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "key")
+ '("gpointer" "data")
+ )
+)
+
+(define-method set_data_full
+ (of-object "GObject")
+ (c-name "g_object_set_data_full")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "key")
+ '("gpointer" "data")
+ '("GDestroyNotify" "destroy")
+ )
+)
+
+(define-method steal_data
+ (of-object "GObject")
+ (c-name "g_object_steal_data")
+ (return-type "gpointer")
+ (parameters
+ '("const-gchar*" "key")
+ )
+)
+
+(define-method watch_closure
+ (of-object "GObject")
+ (c-name "g_object_watch_closure")
+ (return-type "none")
+ (parameters
+ '("GClosure*" "closure")
+ )
+)
+
+(define-function g_cclosure_new_object
+ (c-name "g_cclosure_new_object")
+ (return-type "GClosure*")
+ (parameters
+ '("GCallback" "callback_func")
+ '("GObject*" "object")
+ )
+)
+
+(define-function g_cclosure_new_object_swap
+ (c-name "g_cclosure_new_object_swap")
+ (return-type "GClosure*")
+ (parameters
+ '("GCallback" "callback_func")
+ '("GObject*" "object")
+ )
+)
+
+(define-function g_closure_new_object
+ (c-name "g_closure_new_object")
+ (return-type "GClosure*")
+ (parameters
+ '("guint" "sizeof_closure")
+ '("GObject*" "object")
+ )
+)
+
+(define-method set_object
+ (of-object "GValue")
+ (c-name "g_value_set_object")
+ (return-type "none")
+ (parameters
+ '("gpointer" "v_object")
+ )
+)
+
+(define-method get_object
+ (of-object "GValue")
+ (c-name "g_value_get_object")
+ (return-type "gpointer")
+)
+
+(define-method dup_object
+ (of-object "GValue")
+ (c-name "g_value_dup_object")
+ (return-type "gpointer")
+)
+
+(define-function g_signal_connect_object
+ (c-name "g_signal_connect_object")
+ (return-type "gulong")
+ (parameters
+ '("gpointer" "instance")
+ '("const-gchar*" "detailed_signal")
+ '("GCallback" "c_handler")
+ '("gpointer" "gobject")
+ '("GConnectFlags" "connect_flags")
+ )
+)
+
+(define-method force_floating
+ (of-object "GObject")
+ (c-name "g_object_force_floating")
+ (return-type "none")
+)
+
+(define-method run_dispose
+ (of-object "GObject")
+ (c-name "g_object_run_dispose")
+ (return-type "none")
+)
+
+(define-method take_object
+ (of-object "GValue")
+ (c-name "g_value_take_object")
+ (return-type "none")
+ (parameters
+ '("gpointer" "v_object")
+ )
+)
+
+(define-method set_object_take_ownership
+ (of-object "GValue")
+ (c-name "g_value_set_object_take_ownership")
+ (return-type "none")
+ (parameters
+ '("gpointer" "v_object")
+ )
+)
+
+(define-function g_object_compat_control
+ (c-name "g_object_compat_control")
+ (return-type "gsize")
+ (parameters
+ '("gsize" "what")
+ '("gpointer" "data")
+ )
+)
+
+
+
+;; From gparam.h
+
+(define-method ref
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_ref")
+ (return-type "GParamSpec*")
+)
+
+(define-method unref
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_unref")
+ (return-type "none")
+)
+
+(define-method sink
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_sink")
+ (return-type "none")
+)
+
+(define-method ref_sink
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_ref_sink")
+ (return-type "GParamSpec*")
+)
+
+(define-method get_qdata
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_get_qdata")
+ (return-type "gpointer")
+ (parameters
+ '("GQuark" "quark")
+ )
+)
+
+(define-method set_qdata
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_set_qdata")
+ (return-type "none")
+ (parameters
+ '("GQuark" "quark")
+ '("gpointer" "data")
+ )
+)
+
+(define-method set_qdata_full
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_set_qdata_full")
+ (return-type "none")
+ (parameters
+ '("GQuark" "quark")
+ '("gpointer" "data")
+ '("GDestroyNotify" "destroy")
+ )
+)
+
+(define-method steal_qdata
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_steal_qdata")
+ (return-type "gpointer")
+ (parameters
+ '("GQuark" "quark")
+ )
+)
+
+(define-method get_redirect_target
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_get_redirect_target")
+ (return-type "GParamSpec*")
+)
+
+(define-function g_param_value_set_default
+ (c-name "g_param_value_set_default")
+ (return-type "none")
+ (parameters
+ '("GParamSpec*" "pspec")
+ '("GValue*" "value")
+ )
+)
+
+(define-function g_param_value_defaults
+ (c-name "g_param_value_defaults")
+ (return-type "gboolean")
+ (parameters
+ '("GParamSpec*" "pspec")
+ '("GValue*" "value")
+ )
+)
+
+(define-function g_param_value_validate
+ (c-name "g_param_value_validate")
+ (return-type "gboolean")
+ (parameters
+ '("GParamSpec*" "pspec")
+ '("GValue*" "value")
+ )
+)
+
+(define-function g_param_value_convert
+ (c-name "g_param_value_convert")
+ (return-type "gboolean")
+ (parameters
+ '("GParamSpec*" "pspec")
+ '("const-GValue*" "src_value")
+ '("GValue*" "dest_value")
+ '("gboolean" "strict_validation")
+ )
+)
+
+(define-function g_param_values_cmp
+ (c-name "g_param_values_cmp")
+ (return-type "gint")
+ (parameters
+ '("GParamSpec*" "pspec")
+ '("const-GValue*" "value1")
+ '("const-GValue*" "value2")
+ )
+)
+
+(define-method get_name
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_get_name")
+ (return-type "const-gchar*")
+)
+
+(define-method get_nick
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_get_nick")
+ (return-type "const-gchar*")
+)
+
+(define-method get_blurb
+ (of-object "GParamSpec")
+ (c-name "g_param_spec_get_blurb")
+ (return-type "const-gchar*")
+)
+
+(define-method set_param
+ (of-object "GValue")
+ (c-name "g_value_set_param")
+ (return-type "none")
+ (parameters
+ '("GParamSpec*" "param")
+ )
+)
+
+(define-method get_param
+ (of-object "GValue")
+ (c-name "g_value_get_param")
+ (return-type "GParamSpec*")
+)
+
+(define-method dup_param
+ (of-object "GValue")
+ (c-name "g_value_dup_param")
+ (return-type "GParamSpec*")
+)
+
+(define-method take_param
+ (of-object "GValue")
+ (c-name "g_value_take_param")
+ (return-type "none")
+ (parameters
+ '("GParamSpec*" "param")
+ )
+)
+
+(define-method set_param_take_ownership
+ (of-object "GValue")
+ (c-name "g_value_set_param_take_ownership")
+ (return-type "none")
+ (parameters
+ '("GParamSpec*" "param")
+ )
+)
+
+(define-function g_param_type_register_static
+ (c-name "g_param_type_register_static")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-GParamSpecTypeInfo*" "pspec_info")
+ )
+)
+
+(define-function g_param_spec_internal
+ (c-name "g_param_spec_internal")
+ (return-type "gpointer")
+ (parameters
+ '("GType" "param_type")
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_pool_new
+ (c-name "g_param_spec_pool_new")
+ (is-constructor-of "GParamSpecPool")
+ (return-type "GParamSpecPool*")
+ (parameters
+ '("gboolean" "type_prefixing")
+ )
+)
+
+(define-method insert
+ (of-object "GParamSpecPool")
+ (c-name "g_param_spec_pool_insert")
+ (return-type "none")
+ (parameters
+ '("GParamSpec*" "pspec")
+ '("GType" "owner_type")
+ )
+)
+
+(define-method remove
+ (of-object "GParamSpecPool")
+ (c-name "g_param_spec_pool_remove")
+ (return-type "none")
+ (parameters
+ '("GParamSpec*" "pspec")
+ )
+)
+
+(define-method lookup
+ (of-object "GParamSpecPool")
+ (c-name "g_param_spec_pool_lookup")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "param_name")
+ '("GType" "owner_type")
+ '("gboolean" "walk_ancestors")
+ )
+)
+
+(define-method list_owned
+ (of-object "GParamSpecPool")
+ (c-name "g_param_spec_pool_list_owned")
+ (return-type "GList*")
+ (parameters
+ '("GType" "owner_type")
+ )
+)
+
+(define-method list
+ (of-object "GParamSpecPool")
+ (c-name "g_param_spec_pool_list")
+ (return-type "GParamSpec**")
+ (parameters
+ '("GType" "owner_type")
+ '("guint*" "n_pspecs_p")
+ )
+)
+
+
+
+;; From gparamspecs.h
+
+(define-function g_param_spec_char
+ (c-name "g_param_spec_char")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("gint8" "minimum")
+ '("gint8" "maximum")
+ '("gint8" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_uchar
+ (c-name "g_param_spec_uchar")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("guint8" "minimum")
+ '("guint8" "maximum")
+ '("guint8" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_boolean
+ (c-name "g_param_spec_boolean")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("gboolean" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_int
+ (c-name "g_param_spec_int")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("gint" "minimum")
+ '("gint" "maximum")
+ '("gint" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_uint
+ (c-name "g_param_spec_uint")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("guint" "minimum")
+ '("guint" "maximum")
+ '("guint" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_long
+ (c-name "g_param_spec_long")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("glong" "minimum")
+ '("glong" "maximum")
+ '("glong" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_ulong
+ (c-name "g_param_spec_ulong")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("gulong" "minimum")
+ '("gulong" "maximum")
+ '("gulong" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_int64
+ (c-name "g_param_spec_int64")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("gint64" "minimum")
+ '("gint64" "maximum")
+ '("gint64" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_uint64
+ (c-name "g_param_spec_uint64")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("guint64" "minimum")
+ '("guint64" "maximum")
+ '("guint64" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_unichar
+ (c-name "g_param_spec_unichar")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("gunichar" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_enum
+ (c-name "g_param_spec_enum")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("GType" "enum_type")
+ '("gint" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_flags
+ (c-name "g_param_spec_flags")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("GType" "flags_type")
+ '("guint" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_float
+ (c-name "g_param_spec_float")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("gfloat" "minimum")
+ '("gfloat" "maximum")
+ '("gfloat" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_double
+ (c-name "g_param_spec_double")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("gdouble" "minimum")
+ '("gdouble" "maximum")
+ '("gdouble" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_string
+ (c-name "g_param_spec_string")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("const-gchar*" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_param
+ (c-name "g_param_spec_param")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("GType" "param_type")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_boxed
+ (c-name "g_param_spec_boxed")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("GType" "boxed_type")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_pointer
+ (c-name "g_param_spec_pointer")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_value_array
+ (c-name "g_param_spec_value_array")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("GParamSpec*" "element_spec")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_object
+ (c-name "g_param_spec_object")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("GType" "object_type")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_override
+ (c-name "g_param_spec_override")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("GParamSpec*" "overridden")
+ )
+)
+
+(define-function g_param_spec_gtype
+ (c-name "g_param_spec_gtype")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("GType" "is_a_type")
+ '("GParamFlags" "flags")
+ )
+)
+
+(define-function g_param_spec_variant
+ (c-name "g_param_spec_variant")
+ (return-type "GParamSpec*")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-gchar*" "nick")
+ '("const-gchar*" "blurb")
+ '("const-GVariantType*" "type")
+ '("GVariant*" "default_value")
+ '("GParamFlags" "flags")
+ )
+)
+
+
+
+;; From gsignal.h
+
+(define-function g_signal_newv
+ (c-name "g_signal_newv")
+ (return-type "guint")
+ (parameters
+ '("const-gchar*" "signal_name")
+ '("GType" "itype")
+ '("GSignalFlags" "signal_flags")
+ '("GClosure*" "class_closure")
+ '("GSignalAccumulator" "accumulator")
+ '("gpointer" "accu_data")
+ '("GSignalCMarshaller" "c_marshaller")
+ '("GType" "return_type")
+ '("guint" "n_params")
+ '("GType*" "param_types")
+ )
+)
+
+(define-function g_signal_new_valist
+ (c-name "g_signal_new_valist")
+ (return-type "guint")
+ (parameters
+ '("const-gchar*" "signal_name")
+ '("GType" "itype")
+ '("GSignalFlags" "signal_flags")
+ '("GClosure*" "class_closure")
+ '("GSignalAccumulator" "accumulator")
+ '("gpointer" "accu_data")
+ '("GSignalCMarshaller" "c_marshaller")
+ '("GType" "return_type")
+ '("guint" "n_params")
+ '("va_list" "args")
+ )
+)
+
+(define-function g_signal_new
+ (c-name "g_signal_new")
+ (return-type "guint")
+ (parameters
+ '("const-gchar*" "signal_name")
+ '("GType" "itype")
+ '("GSignalFlags" "signal_flags")
+ '("guint" "class_offset")
+ '("GSignalAccumulator" "accumulator")
+ '("gpointer" "accu_data")
+ '("GSignalCMarshaller" "c_marshaller")
+ '("GType" "return_type")
+ '("guint" "n_params")
+ )
+ (varargs #t)
+)
+
+(define-function g_signal_new_class_handler
+ (c-name "g_signal_new_class_handler")
+ (return-type "guint")
+ (parameters
+ '("const-gchar*" "signal_name")
+ '("GType" "itype")
+ '("GSignalFlags" "signal_flags")
+ '("GCallback" "class_handler")
+ '("GSignalAccumulator" "accumulator")
+ '("gpointer" "accu_data")
+ '("GSignalCMarshaller" "c_marshaller")
+ '("GType" "return_type")
+ '("guint" "n_params")
+ )
+ (varargs #t)
+)
+
+(define-function g_signal_emitv
+ (c-name "g_signal_emitv")
+ (return-type "none")
+ (parameters
+ '("const-GValue*" "instance_and_params")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ '("GValue*" "return_value")
+ )
+)
+
+(define-function g_signal_emit_valist
+ (c-name "g_signal_emit_valist")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ '("va_list" "var_args")
+ )
+)
+
+(define-function g_signal_emit
+ (c-name "g_signal_emit")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ )
+ (varargs #t)
+)
+
+(define-function g_signal_emit_by_name
+ (c-name "g_signal_emit_by_name")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ '("const-gchar*" "detailed_signal")
+ )
+ (varargs #t)
+)
+
+(define-function g_signal_lookup
+ (c-name "g_signal_lookup")
+ (return-type "guint")
+ (parameters
+ '("const-gchar*" "name")
+ '("GType" "itype")
+ )
+)
+
+(define-function g_signal_name
+ (c-name "g_signal_name")
+ (return-type "const-gchar*")
+ (parameters
+ '("guint" "signal_id")
+ )
+)
+
+(define-function g_signal_query
+ (c-name "g_signal_query")
+ (return-type "none")
+ (parameters
+ '("guint" "signal_id")
+ '("GSignalQuery*" "query")
+ )
+)
+
+(define-function g_signal_list_ids
+ (c-name "g_signal_list_ids")
+ (return-type "guint*")
+ (parameters
+ '("GType" "itype")
+ '("guint*" "n_ids")
+ )
+)
+
+(define-function g_signal_parse_name
+ (c-name "g_signal_parse_name")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "detailed_signal")
+ '("GType" "itype")
+ '("guint*" "signal_id_p")
+ '("GQuark*" "detail_p")
+ '("gboolean" "force_detail_quark")
+ )
+)
+
+(define-function g_signal_get_invocation_hint
+ (c-name "g_signal_get_invocation_hint")
+ (return-type "GSignalInvocationHint*")
+ (parameters
+ '("gpointer" "instance")
+ )
+)
+
+(define-function g_signal_stop_emission
+ (c-name "g_signal_stop_emission")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ )
+)
+
+(define-function g_signal_stop_emission_by_name
+ (c-name "g_signal_stop_emission_by_name")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ '("const-gchar*" "detailed_signal")
+ )
+)
+
+(define-function g_signal_add_emission_hook
+ (c-name "g_signal_add_emission_hook")
+ (return-type "gulong")
+ (parameters
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ '("GSignalEmissionHook" "hook_func")
+ '("gpointer" "hook_data")
+ '("GDestroyNotify" "data_destroy")
+ )
+)
+
+(define-function g_signal_remove_emission_hook
+ (c-name "g_signal_remove_emission_hook")
+ (return-type "none")
+ (parameters
+ '("guint" "signal_id")
+ '("gulong" "hook_id")
+ )
+)
+
+(define-function g_signal_has_handler_pending
+ (c-name "g_signal_has_handler_pending")
+ (return-type "gboolean")
+ (parameters
+ '("gpointer" "instance")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ '("gboolean" "may_be_blocked")
+ )
+)
+
+(define-function g_signal_connect_closure_by_id
+ (c-name "g_signal_connect_closure_by_id")
+ (return-type "gulong")
+ (parameters
+ '("gpointer" "instance")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ '("GClosure*" "closure")
+ '("gboolean" "after")
+ )
+)
+
+(define-function g_signal_connect_closure
+ (c-name "g_signal_connect_closure")
+ (return-type "gulong")
+ (parameters
+ '("gpointer" "instance")
+ '("const-gchar*" "detailed_signal")
+ '("GClosure*" "closure")
+ '("gboolean" "after")
+ )
+)
+
+(define-function g_signal_connect_data
+ (c-name "g_signal_connect_data")
+ (return-type "gulong")
+ (parameters
+ '("gpointer" "instance")
+ '("const-gchar*" "detailed_signal")
+ '("GCallback" "c_handler")
+ '("gpointer" "data")
+ '("GClosureNotify" "destroy_data")
+ '("GConnectFlags" "connect_flags")
+ )
+)
+
+(define-function g_signal_handler_block
+ (c-name "g_signal_handler_block")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ '("gulong" "handler_id")
+ )
+)
+
+(define-function g_signal_handler_unblock
+ (c-name "g_signal_handler_unblock")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ '("gulong" "handler_id")
+ )
+)
+
+(define-function g_signal_handler_disconnect
+ (c-name "g_signal_handler_disconnect")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ '("gulong" "handler_id")
+ )
+)
+
+(define-function g_signal_handler_is_connected
+ (c-name "g_signal_handler_is_connected")
+ (return-type "gboolean")
+ (parameters
+ '("gpointer" "instance")
+ '("gulong" "handler_id")
+ )
+)
+
+(define-function g_signal_handler_find
+ (c-name "g_signal_handler_find")
+ (return-type "gulong")
+ (parameters
+ '("gpointer" "instance")
+ '("GSignalMatchType" "mask")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ '("GClosure*" "closure")
+ '("gpointer" "func")
+ '("gpointer" "data")
+ )
+)
+
+(define-function g_signal_handlers_block_matched
+ (c-name "g_signal_handlers_block_matched")
+ (return-type "guint")
+ (parameters
+ '("gpointer" "instance")
+ '("GSignalMatchType" "mask")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ '("GClosure*" "closure")
+ '("gpointer" "func")
+ '("gpointer" "data")
+ )
+)
+
+(define-function g_signal_handlers_unblock_matched
+ (c-name "g_signal_handlers_unblock_matched")
+ (return-type "guint")
+ (parameters
+ '("gpointer" "instance")
+ '("GSignalMatchType" "mask")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ '("GClosure*" "closure")
+ '("gpointer" "func")
+ '("gpointer" "data")
+ )
+)
+
+(define-function g_signal_handlers_disconnect_matched
+ (c-name "g_signal_handlers_disconnect_matched")
+ (return-type "guint")
+ (parameters
+ '("gpointer" "instance")
+ '("GSignalMatchType" "mask")
+ '("guint" "signal_id")
+ '("GQuark" "detail")
+ '("GClosure*" "closure")
+ '("gpointer" "func")
+ '("gpointer" "data")
+ )
+)
+
+(define-function g_signal_override_class_closure
+ (c-name "g_signal_override_class_closure")
+ (return-type "none")
+ (parameters
+ '("guint" "signal_id")
+ '("GType" "instance_type")
+ '("GClosure*" "class_closure")
+ )
+)
+
+(define-function g_signal_override_class_handler
+ (c-name "g_signal_override_class_handler")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "signal_name")
+ '("GType" "instance_type")
+ '("GCallback" "class_handler")
+ )
+)
+
+(define-function g_signal_chain_from_overridden
+ (c-name "g_signal_chain_from_overridden")
+ (return-type "none")
+ (parameters
+ '("const-GValue*" "instance_and_params")
+ '("GValue*" "return_value")
+ )
+)
+
+(define-function g_signal_chain_from_overridden_handler
+ (c-name "g_signal_chain_from_overridden_handler")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ )
+ (varargs #t)
+)
+
+(define-function g_signal_accumulator_true_handled
+ (c-name "g_signal_accumulator_true_handled")
+ (return-type "gboolean")
+ (parameters
+ '("GSignalInvocationHint*" "ihint")
+ '("GValue*" "return_accu")
+ '("const-GValue*" "handler_return")
+ '("gpointer" "dummy")
+ )
+)
+
+(define-function g_signal_handlers_destroy
+ (c-name "g_signal_handlers_destroy")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ )
+)
+
+
+
+;; From gsourceclosure.h
+
+(define-method set_closure
+ (of-object "GSource")
+ (c-name "g_source_set_closure")
+ (return-type "none")
+ (parameters
+ '("GClosure*" "closure")
+ )
+)
+
+(define-function g_io_channel_get_type
+ (c-name "g_io_channel_get_type")
+ (return-type "GType")
+)
+
+(define-function g_io_condition_get_type
+ (c-name "g_io_condition_get_type")
+ (return-type "GType")
+)
+
+
+
+;; From gtype.h
+
+(define-function g_type_init
+ (c-name "g_type_init")
+ (return-type "none")
+)
+
+(define-function g_type_init_with_debug_flags
+ (c-name "g_type_init_with_debug_flags")
+ (return-type "none")
+ (parameters
+ '("GTypeDebugFlags" "debug_flags")
+ )
+)
+
+(define-method name
+ (of-object "GType")
+ (c-name "g_type_name")
+ (return-type "const-gchar*")
+)
+
+(define-method qname
+ (of-object "GType")
+ (c-name "g_type_qname")
+ (return-type "GQuark")
+)
+
+(define-function g_type_from_name
+ (c-name "g_type_from_name")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method parent
+ (of-object "GType")
+ (c-name "g_type_parent")
+ (return-type "GType")
+)
+
+(define-method depth
+ (of-object "GType")
+ (c-name "g_type_depth")
+ (return-type "guint")
+)
+
+(define-method next_base
+ (of-object "GType")
+ (c-name "g_type_next_base")
+ (return-type "GType")
+ (parameters
+ '("GType" "root_type")
+ )
+)
+
+(define-method is_a
+ (of-object "GType")
+ (c-name "g_type_is_a")
+ (return-type "gboolean")
+ (parameters
+ '("GType" "is_a_type")
+ )
+)
+
+(define-method class_ref
+ (of-object "GType")
+ (c-name "g_type_class_ref")
+ (return-type "gpointer")
+)
+
+(define-method class_peek
+ (of-object "GType")
+ (c-name "g_type_class_peek")
+ (return-type "gpointer")
+)
+
+(define-method class_peek_static
+ (of-object "GType")
+ (c-name "g_type_class_peek_static")
+ (return-type "gpointer")
+)
+
+(define-function g_type_class_unref
+ (c-name "g_type_class_unref")
+ (return-type "none")
+ (parameters
+ '("gpointer" "g_class")
+ )
+)
+
+(define-function g_type_class_peek_parent
+ (c-name "g_type_class_peek_parent")
+ (return-type "gpointer")
+ (parameters
+ '("gpointer" "g_class")
+ )
+)
+
+(define-function g_type_interface_peek
+ (c-name "g_type_interface_peek")
+ (return-type "gpointer")
+ (parameters
+ '("gpointer" "instance_class")
+ '("GType" "iface_type")
+ )
+)
+
+(define-function g_type_interface_peek_parent
+ (c-name "g_type_interface_peek_parent")
+ (return-type "gpointer")
+ (parameters
+ '("gpointer" "g_iface")
+ )
+)
+
+(define-method default_interface_ref
+ (of-object "GType")
+ (c-name "g_type_default_interface_ref")
+ (return-type "gpointer")
+)
+
+(define-method default_interface_peek
+ (of-object "GType")
+ (c-name "g_type_default_interface_peek")
+ (return-type "gpointer")
+)
+
+(define-function g_type_default_interface_unref
+ (c-name "g_type_default_interface_unref")
+ (return-type "none")
+ (parameters
+ '("gpointer" "g_iface")
+ )
+)
+
+(define-method children
+ (of-object "GType")
+ (c-name "g_type_children")
+ (return-type "GType*")
+ (parameters
+ '("guint*" "n_children")
+ )
+)
+
+(define-method interfaces
+ (of-object "GType")
+ (c-name "g_type_interfaces")
+ (return-type "GType*")
+ (parameters
+ '("guint*" "n_interfaces")
+ )
+)
+
+(define-method set_qdata
+ (of-object "GType")
+ (c-name "g_type_set_qdata")
+ (return-type "none")
+ (parameters
+ '("GQuark" "quark")
+ '("gpointer" "data")
+ )
+)
+
+(define-method get_qdata
+ (of-object "GType")
+ (c-name "g_type_get_qdata")
+ (return-type "gpointer")
+ (parameters
+ '("GQuark" "quark")
+ )
+)
+
+(define-method query
+ (of-object "GType")
+ (c-name "g_type_query")
+ (return-type "none")
+ (parameters
+ '("GTypeQuery*" "query")
+ )
+)
+
+(define-method register_static
+ (of-object "GType")
+ (c-name "g_type_register_static")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "type_name")
+ '("const-GTypeInfo*" "info")
+ '("GTypeFlags" "flags")
+ )
+)
+
+(define-method register_static_simple
+ (of-object "GType")
+ (c-name "g_type_register_static_simple")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "type_name")
+ '("guint" "class_size")
+ '("GClassInitFunc" "class_init")
+ '("guint" "instance_size")
+ '("GInstanceInitFunc" "instance_init")
+ '("GTypeFlags" "flags")
+ )
+)
+
+(define-method register_dynamic
+ (of-object "GType")
+ (c-name "g_type_register_dynamic")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "type_name")
+ '("GTypePlugin*" "plugin")
+ '("GTypeFlags" "flags")
+ )
+)
+
+(define-method register_fundamental
+ (of-object "GType")
+ (c-name "g_type_register_fundamental")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "type_name")
+ '("const-GTypeInfo*" "info")
+ '("const-GTypeFundamentalInfo*" "finfo")
+ '("GTypeFlags" "flags")
+ )
+)
+
+(define-method add_interface_static
+ (of-object "GType")
+ (c-name "g_type_add_interface_static")
+ (return-type "none")
+ (parameters
+ '("GType" "interface_type")
+ '("const-GInterfaceInfo*" "info")
+ )
+)
+
+(define-method add_interface_dynamic
+ (of-object "GType")
+ (c-name "g_type_add_interface_dynamic")
+ (return-type "none")
+ (parameters
+ '("GType" "interface_type")
+ '("GTypePlugin*" "plugin")
+ )
+)
+
+(define-method interface_add_prerequisite
+ (of-object "GType")
+ (c-name "g_type_interface_add_prerequisite")
+ (return-type "none")
+ (parameters
+ '("GType" "prerequisite_type")
+ )
+)
+
+(define-method interface_prerequisites
+ (of-object "GType")
+ (c-name "g_type_interface_prerequisites")
+ (return-type "GType*")
+ (parameters
+ '("guint*" "n_prerequisites")
+ )
+)
+
+(define-function g_type_class_add_private
+ (c-name "g_type_class_add_private")
+ (return-type "none")
+ (parameters
+ '("gpointer" "g_class")
+ '("gsize" "private_size")
+ )
+)
+
+(define-method get_private
+ (of-object "GTypeInstance")
+ (c-name "g_type_instance_get_private")
+ (return-type "gpointer")
+ (parameters
+ '("GType" "private_type")
+ )
+)
+
+(define-method add_class_private
+ (of-object "GType")
+ (c-name "g_type_add_class_private")
+ (return-type "none")
+ (parameters
+ '("gsize" "private_size")
+ )
+)
+
+(define-method get_private
+ (of-object "GTypeClass")
+ (c-name "g_type_class_get_private")
+ (return-type "gpointer")
+ (parameters
+ '("GType" "private_type")
+ )
+)
+
+(define-method get_plugin
+ (of-object "GType")
+ (c-name "g_type_get_plugin")
+ (return-type "GTypePlugin*")
+)
+
+(define-method interface_get_plugin
+ (of-object "GType")
+ (c-name "g_type_interface_get_plugin")
+ (return-type "GTypePlugin*")
+ (parameters
+ '("GType" "interface_type")
+ )
+)
+
+(define-function g_type_fundamental_next
+ (c-name "g_type_fundamental_next")
+ (return-type "GType")
+)
+
+(define-method fundamental
+ (of-object "GType")
+ (c-name "g_type_fundamental")
+ (return-type "GType")
+)
+
+(define-method create_instance
+ (of-object "GType")
+ (c-name "g_type_create_instance")
+ (return-type "GTypeInstance*")
+)
+
+(define-function g_type_free_instance
+ (c-name "g_type_free_instance")
+ (return-type "none")
+ (parameters
+ '("GTypeInstance*" "instance")
+ )
+)
+
+(define-function g_type_add_class_cache_func
+ (c-name "g_type_add_class_cache_func")
+ (return-type "none")
+ (parameters
+ '("gpointer" "cache_data")
+ '("GTypeClassCacheFunc" "cache_func")
+ )
+)
+
+(define-function g_type_remove_class_cache_func
+ (c-name "g_type_remove_class_cache_func")
+ (return-type "none")
+ (parameters
+ '("gpointer" "cache_data")
+ '("GTypeClassCacheFunc" "cache_func")
+ )
+)
+
+(define-function g_type_class_unref_uncached
+ (c-name "g_type_class_unref_uncached")
+ (return-type "none")
+ (parameters
+ '("gpointer" "g_class")
+ )
+)
+
+(define-function g_type_add_interface_check
+ (c-name "g_type_add_interface_check")
+ (return-type "none")
+ (parameters
+ '("gpointer" "check_data")
+ '("GTypeInterfaceCheckFunc" "check_func")
+ )
+)
+
+(define-function g_type_remove_interface_check
+ (c-name "g_type_remove_interface_check")
+ (return-type "none")
+ (parameters
+ '("gpointer" "check_data")
+ '("GTypeInterfaceCheckFunc" "check_func")
+ )
+)
+
+(define-method value_table_peek
+ (of-object "GType")
+ (c-name "g_type_value_table_peek")
+ (return-type "GTypeValueTable*")
+)
+
+(define-function g_type_check_instance
+ (c-name "g_type_check_instance")
+ (return-type "gboolean")
+ (parameters
+ '("GTypeInstance*" "instance")
+ )
+)
+
+(define-function g_type_check_instance_cast
+ (c-name "g_type_check_instance_cast")
+ (return-type "GTypeInstance*")
+ (parameters
+ '("GTypeInstance*" "instance")
+ '("GType" "iface_type")
+ )
+)
+
+(define-function g_type_check_instance_is_a
+ (c-name "g_type_check_instance_is_a")
+ (return-type "gboolean")
+ (parameters
+ '("GTypeInstance*" "instance")
+ '("GType" "iface_type")
+ )
+)
+
+(define-function g_type_check_class_cast
+ (c-name "g_type_check_class_cast")
+ (return-type "GTypeClass*")
+ (parameters
+ '("GTypeClass*" "g_class")
+ '("GType" "is_a_type")
+ )
+)
+
+(define-function g_type_check_class_is_a
+ (c-name "g_type_check_class_is_a")
+ (return-type "gboolean")
+ (parameters
+ '("GTypeClass*" "g_class")
+ '("GType" "is_a_type")
+ )
+)
+
+(define-method check_is_value_type
+ (of-object "GType")
+ (c-name "g_type_check_is_value_type")
+ (return-type "gboolean")
+)
+
+(define-function g_type_check_value
+ (c-name "g_type_check_value")
+ (return-type "gboolean")
+ (parameters
+ '("GValue*" "value")
+ )
+)
+
+(define-function g_type_check_value_holds
+ (c-name "g_type_check_value_holds")
+ (return-type "gboolean")
+ (parameters
+ '("GValue*" "value")
+ '("GType" "type")
+ )
+)
+
+(define-method test_flags
+ (of-object "GType")
+ (c-name "g_type_test_flags")
+ (return-type "gboolean")
+ (parameters
+ '("guint" "flags")
+ )
+)
+
+(define-function g_type_name_from_instance
+ (c-name "g_type_name_from_instance")
+ (return-type "const-gchar*")
+ (parameters
+ '("GTypeInstance*" "instance")
+ )
+)
+
+(define-function g_type_name_from_class
+ (c-name "g_type_name_from_class")
+ (return-type "const-gchar*")
+ (parameters
+ '("GTypeClass*" "g_class")
+ )
+)
+
+
+
+;; From gtypemodule.h
+
+(define-function g_type_module_get_type
+ (c-name "g_type_module_get_type")
+ (return-type "GType")
+)
+
+(define-method use
+ (of-object "GTypeModule")
+ (c-name "g_type_module_use")
+ (return-type "gboolean")
+)
+
+(define-method unuse
+ (of-object "GTypeModule")
+ (c-name "g_type_module_unuse")
+ (return-type "none")
+)
+
+(define-method set_name
+ (of-object "GTypeModule")
+ (c-name "g_type_module_set_name")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-method register_type
+ (of-object "GTypeModule")
+ (c-name "g_type_module_register_type")
+ (return-type "GType")
+ (parameters
+ '("GType" "parent_type")
+ '("const-gchar*" "type_name")
+ '("const-GTypeInfo*" "type_info")
+ '("GTypeFlags" "flags")
+ )
+)
+
+(define-method add_interface
+ (of-object "GTypeModule")
+ (c-name "g_type_module_add_interface")
+ (return-type "none")
+ (parameters
+ '("GType" "instance_type")
+ '("GType" "interface_type")
+ '("const-GInterfaceInfo*" "interface_info")
+ )
+)
+
+(define-method register_enum
+ (of-object "GTypeModule")
+ (c-name "g_type_module_register_enum")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-GEnumValue*" "const_static_values")
+ )
+)
+
+(define-method register_flags
+ (of-object "GTypeModule")
+ (c-name "g_type_module_register_flags")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "name")
+ '("const-GFlagsValue*" "const_static_values")
+ )
+)
+
+
+
+;; From gtypeplugin.h
+
+(define-function g_type_plugin_get_type
+ (c-name "g_type_plugin_get_type")
+ (return-type "GType")
+)
+
+(define-method use
+ (of-object "GTypePlugin")
+ (c-name "g_type_plugin_use")
+ (return-type "none")
+)
+
+(define-method unuse
+ (of-object "GTypePlugin")
+ (c-name "g_type_plugin_unuse")
+ (return-type "none")
+)
+
+(define-method complete_type_info
+ (of-object "GTypePlugin")
+ (c-name "g_type_plugin_complete_type_info")
+ (return-type "none")
+ (parameters
+ '("GType" "g_type")
+ '("GTypeInfo*" "info")
+ '("GTypeValueTable*" "value_table")
+ )
+)
+
+(define-method complete_interface_info
+ (of-object "GTypePlugin")
+ (c-name "g_type_plugin_complete_interface_info")
+ (return-type "none")
+ (parameters
+ '("GType" "instance_type")
+ '("GType" "interface_type")
+ '("GInterfaceInfo*" "info")
+ )
+)
+
+
+
+;; From gvaluearray.h
+
+(define-method get_nth
+ (of-object "GValueArray")
+ (c-name "g_value_array_get_nth")
+ (return-type "GValue*")
+ (parameters
+ '("guint" "index_")
+ )
+)
+
+(define-function g_value_array_new
+ (c-name "g_value_array_new")
+ (is-constructor-of "GValueArray")
+ (return-type "GValueArray*")
+ (parameters
+ '("guint" "n_prealloced")
+ )
+)
+
+(define-method free
+ (of-object "GValueArray")
+ (c-name "g_value_array_free")
+ (return-type "none")
+)
+
+(define-method copy
+ (of-object "GValueArray")
+ (c-name "g_value_array_copy")
+ (return-type "GValueArray*")
+)
+
+(define-method prepend
+ (of-object "GValueArray")
+ (c-name "g_value_array_prepend")
+ (return-type "GValueArray*")
+ (parameters
+ '("const-GValue*" "value")
+ )
+)
+
+(define-method append
+ (of-object "GValueArray")
+ (c-name "g_value_array_append")
+ (return-type "GValueArray*")
+ (parameters
+ '("const-GValue*" "value")
+ )
+)
+
+(define-method insert
+ (of-object "GValueArray")
+ (c-name "g_value_array_insert")
+ (return-type "GValueArray*")
+ (parameters
+ '("guint" "index_")
+ '("const-GValue*" "value")
+ )
+)
+
+(define-method remove
+ (of-object "GValueArray")
+ (c-name "g_value_array_remove")
+ (return-type "GValueArray*")
+ (parameters
+ '("guint" "index_")
+ )
+)
+
+(define-method sort
+ (of-object "GValueArray")
+ (c-name "g_value_array_sort")
+ (return-type "GValueArray*")
+ (parameters
+ '("GCompareFunc" "compare_func")
+ )
+)
+
+(define-method sort_with_data
+ (of-object "GValueArray")
+ (c-name "g_value_array_sort_with_data")
+ (return-type "GValueArray*")
+ (parameters
+ '("GCompareDataFunc" "compare_func")
+ '("gpointer" "user_data")
+ )
+)
+
+
+
+;; From gvaluecollector.h
+
+
+
+;; From gvalue.h
+
+(define-method init
+ (of-object "GValue")
+ (c-name "g_value_init")
+ (return-type "GValue*")
+ (parameters
+ '("GType" "g_type")
+ )
+)
+
+(define-method copy
+ (of-object "GValue")
+ (c-name "g_value_copy")
+ (return-type "none")
+ (parameters
+ '("GValue*" "dest_value")
+ )
+)
+
+(define-method reset
+ (of-object "GValue")
+ (c-name "g_value_reset")
+ (return-type "GValue*")
+)
+
+(define-method unset
+ (of-object "GValue")
+ (c-name "g_value_unset")
+ (return-type "none")
+)
+
+(define-method set_instance
+ (of-object "GValue")
+ (c-name "g_value_set_instance")
+ (return-type "none")
+ (parameters
+ '("gpointer" "instance")
+ )
+)
+
+(define-method fits_pointer
+ (of-object "GValue")
+ (c-name "g_value_fits_pointer")
+ (return-type "gboolean")
+)
+
+(define-method peek_pointer
+ (of-object "GValue")
+ (c-name "g_value_peek_pointer")
+ (return-type "gpointer")
+)
+
+(define-function g_value_type_compatible
+ (c-name "g_value_type_compatible")
+ (return-type "gboolean")
+ (parameters
+ '("GType" "src_type")
+ '("GType" "dest_type")
+ )
+)
+
+(define-function g_value_type_transformable
+ (c-name "g_value_type_transformable")
+ (return-type "gboolean")
+ (parameters
+ '("GType" "src_type")
+ '("GType" "dest_type")
+ )
+)
+
+(define-method transform
+ (of-object "GValue")
+ (c-name "g_value_transform")
+ (return-type "gboolean")
+ (parameters
+ '("GValue*" "dest_value")
+ )
+)
+
+(define-function g_value_register_transform_func
+ (c-name "g_value_register_transform_func")
+ (return-type "none")
+ (parameters
+ '("GType" "src_type")
+ '("GType" "dest_type")
+ '("GValueTransform" "transform_func")
+ )
+)
+
+
+
+;; From gvaluetypes.h
+
+(define-method set_char
+ (of-object "GValue")
+ (c-name "g_value_set_char")
+ (return-type "none")
+ (parameters
+ '("gchar" "v_char")
+ )
+)
+
+(define-method get_char
+ (of-object "GValue")
+ (c-name "g_value_get_char")
+ (return-type "gchar")
+)
+
+(define-method set_uchar
+ (of-object "GValue")
+ (c-name "g_value_set_uchar")
+ (return-type "none")
+ (parameters
+ '("guchar" "v_uchar")
+ )
+)
+
+(define-method get_uchar
+ (of-object "GValue")
+ (c-name "g_value_get_uchar")
+ (return-type "guchar")
+)
+
+(define-method set_boolean
+ (of-object "GValue")
+ (c-name "g_value_set_boolean")
+ (return-type "none")
+ (parameters
+ '("gboolean" "v_boolean")
+ )
+)
+
+(define-method get_boolean
+ (of-object "GValue")
+ (c-name "g_value_get_boolean")
+ (return-type "gboolean")
+)
+
+(define-method set_int
+ (of-object "GValue")
+ (c-name "g_value_set_int")
+ (return-type "none")
+ (parameters
+ '("gint" "v_int")
+ )
+)
+
+(define-method get_int
+ (of-object "GValue")
+ (c-name "g_value_get_int")
+ (return-type "gint")
+)
+
+(define-method set_uint
+ (of-object "GValue")
+ (c-name "g_value_set_uint")
+ (return-type "none")
+ (parameters
+ '("guint" "v_uint")
+ )
+)
+
+(define-method get_uint
+ (of-object "GValue")
+ (c-name "g_value_get_uint")
+ (return-type "guint")
+)
+
+(define-method set_long
+ (of-object "GValue")
+ (c-name "g_value_set_long")
+ (return-type "none")
+ (parameters
+ '("glong" "v_long")
+ )
+)
+
+(define-method get_long
+ (of-object "GValue")
+ (c-name "g_value_get_long")
+ (return-type "glong")
+)
+
+(define-method set_ulong
+ (of-object "GValue")
+ (c-name "g_value_set_ulong")
+ (return-type "none")
+ (parameters
+ '("gulong" "v_ulong")
+ )
+)
+
+(define-method get_ulong
+ (of-object "GValue")
+ (c-name "g_value_get_ulong")
+ (return-type "gulong")
+)
+
+(define-method set_int64
+ (of-object "GValue")
+ (c-name "g_value_set_int64")
+ (return-type "none")
+ (parameters
+ '("gint64" "v_int64")
+ )
+)
+
+(define-method get_int64
+ (of-object "GValue")
+ (c-name "g_value_get_int64")
+ (return-type "gint64")
+)
+
+(define-method set_uint64
+ (of-object "GValue")
+ (c-name "g_value_set_uint64")
+ (return-type "none")
+ (parameters
+ '("guint64" "v_uint64")
+ )
+)
+
+(define-method get_uint64
+ (of-object "GValue")
+ (c-name "g_value_get_uint64")
+ (return-type "guint64")
+)
+
+(define-method set_float
+ (of-object "GValue")
+ (c-name "g_value_set_float")
+ (return-type "none")
+ (parameters
+ '("gfloat" "v_float")
+ )
+)
+
+(define-method get_float
+ (of-object "GValue")
+ (c-name "g_value_get_float")
+ (return-type "gfloat")
+)
+
+(define-method set_double
+ (of-object "GValue")
+ (c-name "g_value_set_double")
+ (return-type "none")
+ (parameters
+ '("gdouble" "v_double")
+ )
+)
+
+(define-method get_double
+ (of-object "GValue")
+ (c-name "g_value_get_double")
+ (return-type "gdouble")
+)
+
+(define-method set_string
+ (of-object "GValue")
+ (c-name "g_value_set_string")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "v_string")
+ )
+)
+
+(define-method set_static_string
+ (of-object "GValue")
+ (c-name "g_value_set_static_string")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "v_string")
+ )
+)
+
+(define-method get_string
+ (of-object "GValue")
+ (c-name "g_value_get_string")
+ (return-type "const-gchar*")
+)
+
+(define-method dup_string
+ (of-object "GValue")
+ (c-name "g_value_dup_string")
+ (return-type "gchar*")
+)
+
+(define-method set_pointer
+ (of-object "GValue")
+ (c-name "g_value_set_pointer")
+ (return-type "none")
+ (parameters
+ '("gpointer" "v_pointer")
+ )
+)
+
+(define-method get_pointer
+ (of-object "GValue")
+ (c-name "g_value_get_pointer")
+ (return-type "gpointer")
+)
+
+(define-function g_gtype_get_type
+ (c-name "g_gtype_get_type")
+ (return-type "GType")
+)
+
+(define-method set_gtype
+ (of-object "GValue")
+ (c-name "g_value_set_gtype")
+ (return-type "none")
+ (parameters
+ '("GType" "v_gtype")
+ )
+)
+
+(define-method get_gtype
+ (of-object "GValue")
+ (c-name "g_value_get_gtype")
+ (return-type "GType")
+)
+
+(define-method set_variant
+ (of-object "GValue")
+ (c-name "g_value_set_variant")
+ (return-type "none")
+ (parameters
+ '("GVariant*" "variant")
+ )
+)
+
+(define-method get_variant
+ (of-object "GValue")
+ (c-name "g_value_get_variant")
+ (return-type "GVariant*")
+)
+
+(define-method dup_variant
+ (of-object "GValue")
+ (c-name "g_value_dup_variant")
+ (return-type "GVariant*")
+)
+
+(define-function g_pointer_type_register_static
+ (c-name "g_pointer_type_register_static")
+ (return-type "GType")
+ (parameters
+ '("const-gchar*" "name")
+ )
+)
+
+(define-function g_strdup_value_contents
+ (c-name "g_strdup_value_contents")
+ (return-type "gchar*")
+ (parameters
+ '("const-GValue*" "value")
+ )
+)
+
+(define-method take_string
+ (of-object "GValue")
+ (c-name "g_value_take_string")
+ (return-type "none")
+ (parameters
+ '("gchar*" "v_string")
+ )
+)
+
+(define-method set_string_take_ownership
+ (of-object "GValue")
+ (c-name "g_value_set_string_take_ownership")
+ (return-type "none")
+ (parameters
+ '("gchar*" "v_string")
+ )
+)
+
+
;; From galloca.h
@@ -2276,7 +5462,7 @@
)
)
-(define-method
+(define-method
(of-object "GIConv")
(c-name "g_iconv")
(return-type "gsize")
@@ -9877,7 +13063,7 @@
'("int" "line")
'("const-char*" "func")
'("const-char*" "expr")
- '("GError*" "error")
+ '("const-GError*" "error")
'("GQuark" "error_domain")
'("int" "error_code")
)
@@ -9951,7 +13137,7 @@
(c-name "guint64")
(return-type "GLIB_VAR")
(parameters
- '("*" "g_thread_gettime")
+ '("something" "g_thread_gettime")
)
)
@@ -11134,6 +14320,24 @@
(return-type "const-gchar*")
)
+(define-function g_get_system_data_dirs
+ (c-name "g_get_system_data_dirs")
+ (return-type "const-gchar**")
+)
+
+(define-function g_win32_get_system_data_dirs_for_module
+ (c-name "g_win32_get_system_data_dirs_for_module")
+ (return-type "const-gchar**")
+ (parameters
+ '("somefunc" "address_of_function")
+ )
+)
+
+(define-function g_get_language_names
+ (c-name "g_get_language_names")
+ (return-type "const-gchar**")
+)
+
(define-function g_get_user_special_dir
(c-name "g_get_user_special_dir")
(return-type "const-gchar*")
@@ -11901,6 +15105,16 @@
(varargs #t)
)
+(define-method add_parsed
+ (of-object "GVariantBuilder")
+ (c-name "g_variant_builder_add_parsed")
+ (return-type "none")
+ (parameters
+ '("const-gchar*" "format")
+ )
+ (varargs #t)
+)
+
(define-function g_variant_new
(c-name "g_variant_new")
(is-constructor-of "GVariant")
@@ -12257,3 +15471,69 @@
)
+
+;; From glib.h
+
+
+
+;; From glib-object.h
+
+
+
+;; From gmodule.h
+
+(define-function g_module_supported
+ (c-name "g_module_supported")
+ (return-type "gboolean")
+)
+
+(define-function g_module_open
+ (c-name "g_module_open")
+ (return-type "GModule*")
+ (parameters
+ '("const-gchar*" "file_name")
+ '("GModuleFlags" "flags")
+ )
+)
+
+(define-method close
+ (of-object "GModule")
+ (c-name "g_module_close")
+ (return-type "gboolean")
+)
+
+(define-method make_resident
+ (of-object "GModule")
+ (c-name "g_module_make_resident")
+ (return-type "none")
+)
+
+(define-function g_module_error
+ (c-name "g_module_error")
+ (return-type "const-gchar*")
+)
+
+(define-method symbol
+ (of-object "GModule")
+ (c-name "g_module_symbol")
+ (return-type "gboolean")
+ (parameters
+ '("const-gchar*" "symbol_name")
+ '("gpointer*" "symbol")
+ )
+)
+
+(define-method name
+ (of-object "GModule")
+ (c-name "g_module_name")
+ (return-type "const-gchar*")
+)
+
+(define-function g_module_build_path
+ (c-name "g_module_build_path")
+ (return-type "gchar*")
+ (parameters
+ '("const-gchar*" "directory")
+ '("const-gchar*" "module_name")
+ )
+)
diff --git a/tools/m4/convert_gio.m4 b/tools/m4/convert_gio.m4
index 78542ac..4a6263c 100644
--- a/tools/m4/convert_gio.m4
+++ b/tools/m4/convert_gio.m4
@@ -128,6 +128,7 @@ _CONVERSION(`const Glib::RefPtr<OutputStream>&',`GOutputStream*',__CONVERT_CONST
#Settings
_CONVERSION(`GSettings*',`Glib::RefPtr<Settings>',`Glib::wrap($3)')
_CONVERSION(`const Glib::StringArrayHandle&',`const gchar*-const*',`($3).data()')
+_CONVERSION(`const Glib::RefPtr<SettingsBackend>&',`GSettingsBackend*',__CONVERT_REFPTR_TO_P)
#Socket
_CONVERSION(`const Glib::RefPtr<Socket>&',`GSocket*',__CONVERT_CONST_REFPTR_TO_P)
@@ -158,4 +159,3 @@ _CONVERSION(`const Glib::RefPtr<Volume>&',`GVolume*',__CONVERT_CONST_REFPTR_TO_P
#Vfs
_CONVERSION(`GVfs*', `Glib::RefPtr<Vfs>', `Glib::wrap($3)')
-
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
