Add python binding. Fixes bug #457660 (Michael Sheldon).

2007-08-19 Xavier Claessens  <xclaesse@gmail.com>

	* python/pyempathy/pyempathy.defs:
	* python/pyempathy/pyempathymodule.c:
	* python/pyempathy/Makefile.am:
	* python/pyempathy/pyempathy.override:
	* python/pyempathygtk/pyempathygtk.override:
	* python/pyempathygtk/pyempathygtk.defs:
	* python/pyempathygtk/Makefile.am:
	* python/pyempathygtk/pyempathygtkmodule.c:
	* python/Makefile.am:
	* libempathy/empathy-time.h:
	* configure.ac:
	* Makefile.am: Add python binding. Fixes bug #457660 (Michael Sheldon).


svn path=/trunk/; revision=264

13 files changed, 3864 insertions, 1 deletions

diff --git a/ChangeLog b/ChangeLog
index 1694b906..9f2c7e0a 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,20 @@
 2007-08-19 Xavier Claessens  <xclaesse@gmail.com>
 
+	* python/pyempathy/pyempathy.defs:
+	* python/pyempathy/pyempathymodule.c:
+	* python/pyempathy/Makefile.am:
+	* python/pyempathy/pyempathy.override:
+	* python/pyempathygtk/pyempathygtk.override:
+	* python/pyempathygtk/pyempathygtk.defs:
+	* python/pyempathygtk/Makefile.am:
+	* python/pyempathygtk/pyempathygtkmodule.c:
+	* python/Makefile.am:
+	* libempathy/empathy-time.h:
+	* configure.ac:
+	* Makefile.am: Add python binding. Fixes bug #457660 (Michael Sheldon).
+
+2007-08-19 Xavier Claessens  <xclaesse@gmail.com>
+
 	* libempathy-gtk/empathy-main-window.glade: Edit menu should be second
 	from the left. Fixes bug #467827 (Cosimo Cecchi).
 
diff --git a/Makefile.am b/Makefile.am
index 9e4c06f3..9c336a52 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,5 +1,9 @@
 SUBDIRS = po data libempathy libempathy-gtk src doc
 
+if HAVE_PYTHON
+SUBDIRS += python
+endif
+
 DISTCHECK_CONFIGURE_FLAGS =	\
 	--disable-scrollkeeper  \
 	--enable-gtk-doc
diff --git a/configure.ac b/configure.ac
index 74ea426c..f582d2bd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -145,7 +145,46 @@ if test "x$enable_aspell" = "xyes" -a "x$have_aspell" != "xyes"; then
    AC_MSG_ERROR([Couldn't find aspell.])
 fi
 
+
+dnl -----------------------------------------------------------
+dnl Python Bindings
 dnl -----------------------------------------------------------
+AC_ARG_ENABLE(python,
+              AS_HELP_STRING([--enable-python=@<:@no/yes/auto@:>@],
+                             [build python bindings to libempathy and libempathy-gtk]), ,
+                             enable_python=auto)
+
+PKG_CHECK_MODULES(PYTHON_BINDING,
+[
+   pygtk-2.0,
+   glib-2.0 >= $GLIB_REQUIRED
+   gobject-2.0
+   gconf-2.0 >= $GCONF_REQUIRED
+   libxml-2.0
+   gnome-vfs-2.0
+   libtelepathy >= $TELEPATHY_REQUIRED
+   libmissioncontrol >= $MISSION_CONTROL_REQUIRED
+   gtk+-2.0 >= $GTK_REQUIRED
+   libglade-2.0 >= $LIBGLADE_REQUIRED
+   libgnomeui-2.0
+], have_python="yes", have_python="no")
+
+if test "x$have_python" = "xno"; then
+	if test "x$enable_python" = "xyes"; then
+		AC_MSG_ERROR([Could not find python dependencies])
+	fi
+	enable_python="no (missing dependencies)"
+else
+	if test "x$enable_python" != "xno"; then
+		enable_python="yes"
+	else
+		enable_python="no (disabled)"
+	fi
+fi
+AM_CONDITIONAL(HAVE_PYTHON, test x$enable_python = xyes)
+
+dnl -----------------------------------------------------------
+
 AC_OUTPUT([
   Makefile
   data/Makefile
@@ -164,5 +203,7 @@ AC_OUTPUT([
   doc/Makefile
   doc/libempathy/Makefile
   doc/libempathy-gtk/Makefile
+  python/Makefile
+  python/pyempathy/Makefile
+  python/pyempathygtk/Makefile
 ])
-
diff --git a/libempathy/empathy-time.h b/libempathy/empathy-time.h
index 0989391c..debf784c 100644
--- a/libempathy/empathy-time.h
+++ b/libempathy/empathy-time.h
@@ -21,7 +21,9 @@
 #ifndef __EMPATHY_TIME_H__
 #define __EMPATHY_TIME_H__
 
+#ifndef __USE_XOPEN
 #define __USE_XOPEN
+#endif
 #include <time.h>
 
 #include <glib.h>
diff --git a/python/Makefile.am b/python/Makefile.am
new file mode 100644
index 00000000..5050f1b8
--- /dev/null
+++ b/python/Makefile.am
@@ -0,0 +1,2 @@
+SUBDIRS = pyempathy pyempathygtk
+
diff --git a/python/pyempathy/Makefile.am b/python/pyempathy/Makefile.am
new file mode 100644
index 00000000..3c0bdbf2
--- /dev/null
+++ b/python/pyempathy/Makefile.am
@@ -0,0 +1,38 @@
+PYDEFS=`pkg-config --variable=defsdir pygtk-2.0`
+
+AM_CPPFLAGS =                                           \
+	-I.                                             \
+	-I$(top_srcdir)/libempathy			\
+	-I$(top_srcdir)                                 \
+	-DDATADIR=\""$(datadir)"\"              	\
+	$(PYTHON_BINDING_CFLAGS)			\
+	`python-config --cflags`			\
+	$(WARN_CFLAGS)
+
+BUILT_SOURCES = 					\
+	pyempathy.c					
+
+pyempathydir = $(prefix)/lib/`pyversions -d`/site-packages
+pyempathy_LTLIBRARIES = empathy.la
+
+empathy_la_SOURCES =					\
+	pyempathymodule.c				\
+	pyempathy.c
+
+empathy_la_LIBADD =					\
+	$(PYTHON_BINDING_LIBS)				\
+	$(top_builddir)/libempathy/libempathy.la
+
+empathy_la_LDFLAGS =					\
+	`python-config --libs`				\
+	-module -avoid-version
+
+pyempathy.c: pyempathy.override pyempathy.defs
+	pygtk-codegen-2.0 --prefix empathy 		\
+		--register $(PYDEFS)/gdk-types.defs 	\
+		--register $(PYDEFS)/gtk-types.defs 	\
+		--override pyempathy.override 		\
+		pyempathy.defs > $@ 
+
+CLEANFILES = $(BUILT_SOURCES)
+
diff --git a/python/pyempathy/pyempathy.defs b/python/pyempathy/pyempathy.defs
new file mode 100644
index 00000000..eea0b76d
--- /dev/null
+++ b/python/pyempathy/pyempathy.defs
@@ -0,0 +1,1816 @@
+;; -*- scheme -*-
+; interfaces
+
+(define-interface ContactList
+  (in-module "Empathy")
+  (c-name "EmpathyContactList")
+  (gtype-id "EMPATHY_TYPE_CONTACT_LIST")
+)
+
+; object definitions ...
+(define-object Chandler
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyChandler")
+  (gtype-id "EMPATHY_TYPE_CHANDLER")
+)
+
+(define-object Chatroom
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyChatroom")
+  (gtype-id "EMPATHY_TYPE_CHATROOM")
+)
+
+(define-object ChatroomManager
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyChatroomManager")
+  (gtype-id "EMPATHY_TYPE_CHATROOM_MANAGER")
+)
+
+(define-object Conf
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyConf")
+  (gtype-id "EMPATHY_TYPE_CONF")
+)
+
+(define-object Contact
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyContact")
+  (gtype-id "EMPATHY_TYPE_CONTACT")
+)
+
+(define-object ContactManager
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyContactManager")
+  (gtype-id "EMPATHY_TYPE_CONTACT_MANAGER")
+  (implements "EmpathyContactList")
+)
+
+(define-object Filter
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyFilter")
+  (gtype-id "EMPATHY_TYPE_FILTER")
+)
+
+(define-object Idle
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyIdle")
+  (gtype-id "EMPATHY_TYPE_IDLE")
+)
+
+(define-object LogManager
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyLogManager")
+  (gtype-id "EMPATHY_TYPE_LOG_MANAGER")
+)
+
+(define-object Message
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyMessage")
+  (gtype-id "EMPATHY_TYPE_MESSAGE")
+)
+
+(define-object Presence
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyPresence")
+  (gtype-id "EMPATHY_TYPE_PRESENCE")
+)
+
+(define-object TpChat
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyTpChat")
+  (gtype-id "EMPATHY_TYPE_TP_CHAT")
+)
+
+(define-object TpChatroom
+  (in-module "Empathy")
+  (parent "EmpathyTpChat")
+  (c-name "EmpathyTpChatroom")
+  (gtype-id "EMPATHY_TYPE_TP_CHATROOM")
+  (implements "EmpathyContactList")
+)
+
+(define-object TpContactList
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyTpContactList")
+  (gtype-id "EMPATHY_TYPE_TP_CONTACT_LIST")
+  (implements "EmpathyContactList")
+)
+
+(define-object TpGroup
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyTpGroup")
+  (gtype-id "EMPATHY_TYPE_TP_GROUP")
+)
+
+;; Enumerations and flags ...
+
+(define-flags Subscription
+  (in-module "Empathy")
+  (c-name "EmpathySubscription")
+  (gtype-id "EMPATHY_TYPE_SUBSCRIPTION")
+  (values
+    '("none" "EMPATHY_SUBSCRIPTION_NONE")
+    '("to" "EMPATHY_SUBSCRIPTION_TO")
+    '("from" "EMPATHY_SUBSCRIPTION_FROM")
+    '("both" "EMPATHY_SUBSCRIPTION_BOTH")
+  )
+)
+
+(define-enum MessageType
+  (in-module "Empathy")
+  (c-name "EmpathyMessageType")
+  (gtype-id "EMPATHY_TYPE_MESSAGE_TYPE")
+  (values
+    '("normal" "EMPATHY_MESSAGE_TYPE_NORMAL")
+    '("action" "EMPATHY_MESSAGE_TYPE_ACTION")
+    '("notice" "EMPATHY_MESSAGE_TYPE_NOTICE")
+    '("auto-reply" "EMPATHY_MESSAGE_TYPE_AUTO_REPLY")
+    '("last" "EMPATHY_MESSAGE_TYPE_LAST")
+  )
+)
+
+(define-enum RegExType
+  (in-module "Empathy")
+  (c-name "EmpathyRegExType")
+  (gtype-id "EMPATHY_TYPE_REG_EX_TYPE")
+  (values
+    '("as-is" "EMPATHY_REGEX_AS_IS")
+    '("browser" "EMPATHY_REGEX_BROWSER")
+    '("email" "EMPATHY_REGEX_EMAIL")
+    '("other" "EMPATHY_REGEX_OTHER")
+    '("all" "EMPATHY_REGEX_ALL")
+  )
+)
+
+
+;; From empathy-avatar.h
+
+(define-function empathy_avatar_get_gtype
+  (c-name "empathy_avatar_get_gtype")
+  (return-type "GType")
+)
+
+(define-function empathy_avatar_new
+  (c-name "empathy_avatar_new")
+  (is-constructor-of "EmpathyAvatar")
+  (return-type "EmpathyAvatar*")
+  (parameters
+    '("guchar*" "avatar")
+    '("gsize" "len")
+    '("gchar*" "format")
+  )
+)
+
+(define-method ref
+  (of-object "EmpathyAvatar")
+  (c-name "empathy_avatar_ref")
+  (return-type "EmpathyAvatar*")
+)
+
+(define-method unref
+  (of-object "EmpathyAvatar")
+  (c-name "empathy_avatar_unref")
+  (return-type "none")
+)
+
+
+
+;; From empathy-chandler-glue.h
+
+(define-function dbus_glib_marshal_empathy_chandler_BOOLEAN__STRING_BOXED_STRING_BOXED_UINT_UINT_POINTER
+  (c-name "dbus_glib_marshal_empathy_chandler_BOOLEAN__STRING_BOXED_STRING_BOXED_UINT_UINT_POINTER")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+
+
+;; From empathy-chandler.h
+
+(define-function empathy_chandler_get_type
+  (c-name "empathy_chandler_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_chandler_new
+  (c-name "empathy_chandler_new")
+  (is-constructor-of "EmpathyChandler")
+  (return-type "EmpathyChandler*")
+  (parameters
+    '("const-gchar*" "bus_name")
+    '("const-gchar*" "object_path")
+  )
+)
+
+
+
+;; From empathy-chatroom-manager.h
+
+(define-function empathy_chatroom_manager_get_type
+  (c-name "empathy_chatroom_manager_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_chatroom_manager_new
+  (c-name "empathy_chatroom_manager_new")
+  (is-constructor-of "EmpathyChatroomManager")
+  (return-type "EmpathyChatroomManager*")
+)
+
+(define-method add
+  (of-object "EmpathyChatroomManager")
+  (c-name "empathy_chatroom_manager_add")
+  (return-type "gboolean")
+  (parameters
+    '("EmpathyChatroom*" "chatroom")
+  )
+)
+
+(define-method remove
+  (of-object "EmpathyChatroomManager")
+  (c-name "empathy_chatroom_manager_remove")
+  (return-type "none")
+  (parameters
+    '("EmpathyChatroom*" "chatroom")
+  )
+)
+
+(define-method find
+  (of-object "EmpathyChatroomManager")
+  (c-name "empathy_chatroom_manager_find")
+  (return-type "EmpathyChatroom*")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "room")
+  )
+)
+
+(define-method get_chatrooms
+  (of-object "EmpathyChatroomManager")
+  (c-name "empathy_chatroom_manager_get_chatrooms")
+  (return-type "GList*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-method get_count
+  (of-object "EmpathyChatroomManager")
+  (c-name "empathy_chatroom_manager_get_count")
+  (return-type "guint")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-method store
+  (of-object "EmpathyChatroomManager")
+  (c-name "empathy_chatroom_manager_store")
+  (return-type "none")
+)
+
+
+
+;; From empathy-chatroom.h
+
+(define-function empathy_chatroom_get_type
+  (c-name "empathy_chatroom_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_chatroom_new
+  (c-name "empathy_chatroom_new")
+  (is-constructor-of "EmpathyChatroom")
+  (return-type "EmpathyChatroom*")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "room")
+  )
+)
+
+(define-function empathy_chatroom_new_full
+  (c-name "empathy_chatroom_new_full")
+  (return-type "EmpathyChatroom*")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "room")
+    '("const-gchar*" "name")
+    '("gboolean" "auto_connect")
+  )
+)
+
+(define-method get_account
+  (of-object "EmpathyChatroom")
+  (c-name "empathy_chatroom_get_account")
+  (return-type "McAccount*")
+)
+
+(define-method set_account
+  (of-object "EmpathyChatroom")
+  (c-name "empathy_chatroom_set_account")
+  (return-type "none")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-method get_room
+  (of-object "EmpathyChatroom")
+  (c-name "empathy_chatroom_get_room")
+  (return-type "const-gchar*")
+)
+
+(define-method set_room
+  (of-object "EmpathyChatroom")
+  (c-name "empathy_chatroom_set_room")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "room")
+  )
+)
+
+(define-method get_name
+  (of-object "EmpathyChatroom")
+  (c-name "empathy_chatroom_get_name")
+  (return-type "const-gchar*")
+)
+
+(define-method set_name
+  (of-object "EmpathyChatroom")
+  (c-name "empathy_chatroom_set_name")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method get_auto_connect
+  (of-object "EmpathyChatroom")
+  (c-name "empathy_chatroom_get_auto_connect")
+  (return-type "gboolean")
+)
+
+(define-method set_auto_connect
+  (of-object "EmpathyChatroom")
+  (c-name "empathy_chatroom_set_auto_connect")
+  (return-type "none")
+  (parameters
+    '("gboolean" "auto_connect")
+  )
+)
+
+(define-function empathy_chatroom_equal
+  (c-name "empathy_chatroom_equal")
+  (return-type "gboolean")
+  (parameters
+    '("gconstpointer" "v1")
+    '("gconstpointer" "v2")
+  )
+)
+
+
+
+;; From empathy-conf.h
+
+(define-function empathy_conf_get_type
+  (c-name "empathy_conf_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_conf_get
+  (c-name "empathy_conf_get")
+  (return-type "EmpathyConf*")
+)
+
+(define-function empathy_conf_shutdown
+  (c-name "empathy_conf_shutdown")
+  (return-type "none")
+)
+
+(define-method notify_add
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_notify_add")
+  (return-type "guint")
+  (parameters
+    '("const-gchar*" "key")
+    '("EmpathyConfNotifyFunc" "func")
+    '("gpointer" "data")
+  )
+)
+
+(define-method notify_remove
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_notify_remove")
+  (return-type "gboolean")
+  (parameters
+    '("guint" "id")
+  )
+)
+
+(define-method set_int
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_set_int")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+    '("gint" "value")
+  )
+)
+
+(define-method get_int
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_get_int")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+    '("gint*" "value")
+  )
+)
+
+(define-method set_bool
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_set_bool")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+    '("gboolean" "value")
+  )
+)
+
+(define-method get_bool
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_get_bool")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+    '("gboolean*" "value")
+  )
+)
+
+(define-method set_string
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_set_string")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+    '("const-gchar*" "value")
+  )
+)
+
+(define-method get_string
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_get_string")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+    '("gchar**" "value")
+  )
+)
+
+(define-method set_string_list
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_set_string_list")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+    '("GSList*" "value")
+  )
+)
+
+(define-method get_string_list
+  (of-object "EmpathyConf")
+  (c-name "empathy_conf_get_string_list")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+    '("GSList**" "value")
+  )
+)
+
+
+
+;; From empathy-contact-list.h
+
+(define-function contact_list_get_type
+  (c-name "empathy_contact_list_get_type")
+  (return-type "GType")
+)
+
+(define-method list_info_new
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_list_info_new")
+  (return-type "EmpathyContactListInfo*")
+  (parameters
+    '("const-gchar*" "message")
+  )
+)
+
+(define-method free
+  (of-object "EmpathyContactListInfo")
+  (c-name "empathy_contact_list_info_free")
+  (return-type "none")
+)
+
+(define-method setup
+  (of-object "EmpathyContactList")
+  (c-name "empathy_contact_list_setup")
+  (return-type "none")
+)
+
+(define-method find
+  (of-object "EmpathyContactList")
+  (c-name "empathy_contact_list_find")
+  (return-type "EmpathyContact*")
+  (parameters
+    '("const-gchar*" "id")
+  )
+)
+
+(define-method add
+  (of-object "EmpathyContactList")
+  (c-name "empathy_contact_list_add")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+    '("const-gchar*" "message")
+  )
+)
+
+(define-method remove
+  (of-object "EmpathyContactList")
+  (c-name "empathy_contact_list_remove")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+    '("const-gchar*" "message")
+  )
+)
+
+(define-method get_members
+  (of-object "EmpathyContactList")
+  (c-name "empathy_contact_list_get_members")
+  (return-type "GList*")
+)
+
+(define-method get_local_pending
+  (of-object "EmpathyContactList")
+  (c-name "empathy_contact_list_get_local_pending")
+  (return-type "GList*")
+)
+
+(define-method process_pending
+  (of-object "EmpathyContactList")
+  (c-name "empathy_contact_list_process_pending")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+    '("gboolean" "accept")
+  )
+)
+
+(define-virtual setup
+  (of-object "EmpathyContactList")
+  (return-type "none")
+)
+
+(define-virtual find
+  (of-object "EmpathyContactList")
+  (return-type "EmpathyContact*")
+  (parameters
+    '("const-gchar*" "id")
+  )
+)
+
+(define-virtual add
+  (of-object "EmpathyContactList")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+    '("const-gchar*" "message")
+  )
+)
+
+(define-virtual remove
+  (of-object "EmpathyContactList")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+    '("const-gchar*" "message")
+  )
+)
+
+(define-virtual get_members
+  (of-object "EmpathyContactList")
+  (return-type "GList*")
+)
+
+(define-virtual get_local_pending
+  (of-object "EmpathyContactList")
+  (return-type "GList*")
+)
+
+(define-virtual process_pending
+  (of-object "EmpathyContactList")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+    '("gboolean" "accept")
+  )
+)
+
+;; From empathy-contact-manager.h
+
+(define-function empathy_contact_manager_get_type
+  (c-name "empathy_contact_manager_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_contact_manager_new
+  (c-name "empathy_contact_manager_new")
+  (is-constructor-of "EmpathyContactManager")
+  (return-type "EmpathyContactManager*")
+)
+
+(define-method get_list
+  (of-object "EmpathyContactManager")
+  (c-name "empathy_contact_manager_get_list")
+  (return-type "EmpathyTpContactList*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-method get_user
+  (of-object "EmpathyContactManager")
+  (c-name "empathy_contact_manager_get_user")
+  (return-type "EmpathyContact*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-method create
+  (of-object "EmpathyContactManager")
+  (c-name "empathy_contact_manager_create")
+  (return-type "EmpathyContact*")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "id")
+  )
+)
+
+(define-method rename_group
+  (of-object "EmpathyContactManager")
+  (c-name "empathy_contact_manager_rename_group")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "old_group")
+    '("const-gchar*" "new_group")
+  )
+)
+
+(define-method get_groups
+  (of-object "EmpathyContactManager")
+  (c-name "empathy_contact_manager_get_groups")
+  (return-type "GList*")
+)
+
+
+
+;; From empathy-contact.h
+
+(define-function empathy_contact_get_gtype
+  (c-name "empathy_contact_get_gtype")
+  (return-type "GType")
+)
+
+(define-function empathy_contact_new
+  (c-name "empathy_contact_new")
+  (is-constructor-of "EmpathyContact")
+  (return-type "EmpathyContact*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-function empathy_contact_new_full
+  (c-name "empathy_contact_new_full")
+  (return-type "EmpathyContact*")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "id")
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method get_id
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_get_id")
+  (return-type "const-gchar*")
+)
+
+(define-method get_name
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_get_name")
+  (return-type "const-gchar*")
+)
+
+(define-method get_avatar
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_get_avatar")
+  (return-type "EmpathyAvatar*")
+)
+
+(define-method get_account
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_get_account")
+  (return-type "McAccount*")
+)
+
+(define-method get_presence
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_get_presence")
+  (return-type "EmpathyPresence*")
+)
+
+(define-method get_groups
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_get_groups")
+  (return-type "GList*")
+)
+
+(define-method get_subscription
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_get_subscription")
+  (return-type "EmpathySubscription")
+)
+
+(define-method get_handle
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_get_handle")
+  (return-type "guint")
+)
+
+(define-method is_user
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_is_user")
+  (return-type "gboolean")
+)
+
+(define-method set_id
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_set_id")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "id")
+  )
+)
+
+(define-method set_name
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_set_name")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+  )
+)
+
+(define-method set_avatar
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_set_avatar")
+  (return-type "none")
+  (parameters
+    '("EmpathyAvatar*" "avatar")
+  )
+)
+
+(define-method set_account
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_set_account")
+  (return-type "none")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-method set_presence
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_set_presence")
+  (return-type "none")
+  (parameters
+    '("EmpathyPresence*" "presence")
+  )
+)
+
+(define-method set_groups
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_set_groups")
+  (return-type "none")
+  (parameters
+    '("GList*" "categories")
+  )
+)
+
+(define-method set_subscription
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_set_subscription")
+  (return-type "none")
+  (parameters
+    '("EmpathySubscription" "subscription")
+  )
+)
+
+(define-method set_handle
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_set_handle")
+  (return-type "none")
+  (parameters
+    '("guint" "handle")
+  )
+)
+
+(define-method set_is_user
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_set_is_user")
+  (return-type "none")
+  (parameters
+    '("gboolean" "is_user")
+  )
+)
+
+(define-method add_group
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_add_group")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "group")
+  )
+)
+
+(define-method remove_group
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_remove_group")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "group")
+  )
+)
+
+(define-method is_online
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_is_online")
+  (return-type "gboolean")
+)
+
+(define-method is_in_group
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_is_in_group")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "group")
+  )
+)
+
+(define-method get_status
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_get_status")
+  (return-type "const-gchar*")
+)
+
+(define-function empathy_contact_equal
+  (c-name "empathy_contact_equal")
+  (return-type "gboolean")
+  (parameters
+    '("gconstpointer" "v1")
+    '("gconstpointer" "v2")
+  )
+)
+
+(define-function empathy_contact_hash
+  (c-name "empathy_contact_hash")
+  (return-type "guint")
+  (parameters
+    '("gconstpointer" "key")
+  )
+)
+
+
+
+;; From empathy-debug.h
+
+(define-function empathy_debug_impl
+  (c-name "empathy_debug_impl")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "domain")
+    '("const-gchar*" "msg")
+  )
+  (varargs #t)
+)
+
+
+
+;; From empathy-filter-glue.h
+
+(define-function dbus_glib_marshal_empathy_filter_BOOLEAN__STRING_BOXED_STRING_BOXED_UINT_UINT_UINT_POINTER
+  (c-name "dbus_glib_marshal_empathy_filter_BOOLEAN__STRING_BOXED_STRING_BOXED_UINT_UINT_UINT_POINTER")
+  (return-type "none")
+  (parameters
+    '("GClosure*" "closure")
+    '("GValue*" "return_value")
+    '("guint" "n_param_values")
+    '("const-GValue*" "param_values")
+    '("gpointer" "invocation_hint")
+    '("gpointer" "marshal_data")
+  )
+)
+
+
+
+;; From empathy-filter.h
+
+(define-function empathy_filter_get_type
+  (c-name "empathy_filter_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_filter_new
+  (c-name "empathy_filter_new")
+  (is-constructor-of "EmpathyFilter")
+  (return-type "EmpathyFilter*")
+  (parameters
+    '("const-gchar*" "bus_name")
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "channel_type")
+    '("guint" "priority")
+    '("guint" "flags")
+  )
+)
+
+(define-method process
+  (of-object "EmpathyFilter")
+  (c-name "empathy_filter_process")
+  (return-type "none")
+  (parameters
+    '("TpChan*" "tp_chan")
+    '("gboolean" "process")
+  )
+)
+
+
+
+;; From empathy-idle.h
+
+(define-function empathy_idle_get_type
+  (c-name "empathy_idle_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_idle_new
+  (c-name "empathy_idle_new")
+  (is-constructor-of "EmpathyIdle")
+  (return-type "EmpathyIdle*")
+)
+
+(define-method get_state
+  (of-object "EmpathyIdle")
+  (c-name "empathy_idle_get_state")
+  (return-type "McPresence")
+)
+
+(define-method set_state
+  (of-object "EmpathyIdle")
+  (c-name "empathy_idle_set_state")
+  (return-type "none")
+  (parameters
+    '("McPresence" "state")
+  )
+)
+
+(define-method get_status
+  (of-object "EmpathyIdle")
+  (c-name "empathy_idle_get_status")
+  (return-type "const-gchar*")
+)
+
+(define-method set_status
+  (of-object "EmpathyIdle")
+  (c-name "empathy_idle_set_status")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "status")
+  )
+)
+
+(define-method get_flash_state
+  (of-object "EmpathyIdle")
+  (c-name "empathy_idle_get_flash_state")
+  (return-type "McPresence")
+)
+
+(define-method set_flash_state
+  (of-object "EmpathyIdle")
+  (c-name "empathy_idle_set_flash_state")
+  (return-type "none")
+  (parameters
+    '("McPresence" "state")
+  )
+)
+
+(define-method set_presence
+  (of-object "EmpathyIdle")
+  (c-name "empathy_idle_set_presence")
+  (return-type "none")
+  (parameters
+    '("McPresence" "state")
+    '("const-gchar*" "status")
+  )
+)
+
+
+
+;; From empathy-log-manager.h
+
+(define-function empathy_log_manager_get_type
+  (c-name "empathy_log_manager_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_log_manager_new
+  (c-name "empathy_log_manager_new")
+  (is-constructor-of "EmpathyLogManager")
+  (return-type "EmpathyLogManager*")
+)
+
+(define-method add_message
+  (of-object "EmpathyLogManager")
+  (c-name "empathy_log_manager_add_message")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "chat_id")
+    '("gboolean" "chatroom")
+    '("EmpathyMessage*" "message")
+  )
+)
+
+(define-method exists
+  (of-object "EmpathyLogManager")
+  (c-name "empathy_log_manager_exists")
+  (return-type "gboolean")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "chat_id")
+    '("gboolean" "chatroom")
+  )
+)
+
+(define-method get_dates
+  (of-object "EmpathyLogManager")
+  (c-name "empathy_log_manager_get_dates")
+  (return-type "GList*")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "chat_id")
+    '("gboolean" "chatroom")
+  )
+)
+
+(define-method get_messages_for_date
+  (of-object "EmpathyLogManager")
+  (c-name "empathy_log_manager_get_messages_for_date")
+  (return-type "GList*")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "chat_id")
+    '("gboolean" "chatroom")
+    '("const-gchar*" "date")
+  )
+)
+
+(define-method get_last_messages
+  (of-object "EmpathyLogManager")
+  (c-name "empathy_log_manager_get_last_messages")
+  (return-type "GList*")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "chat_id")
+    '("gboolean" "chatroom")
+  )
+)
+
+(define-method get_chats
+  (of-object "EmpathyLogManager")
+  (c-name "empathy_log_manager_get_chats")
+  (return-type "GList*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-method search_new
+  (of-object "EmpathyLogManager")
+  (c-name "empathy_log_manager_search_new")
+  (return-type "GList*")
+  (parameters
+    '("const-gchar*" "text")
+  )
+)
+
+(define-function empathy_log_manager_search_free
+  (c-name "empathy_log_manager_search_free")
+  (return-type "none")
+  (parameters
+    '("GList*" "hits")
+  )
+)
+
+(define-function empathy_log_manager_get_date_readable
+  (c-name "empathy_log_manager_get_date_readable")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "date")
+  )
+)
+
+
+
+;; From empathy-marshal.h
+
+
+
+;; From empathy-message.h
+
+(define-function empathy_message_get_gtype
+  (c-name "empathy_message_get_gtype")
+  (return-type "GType")
+)
+
+(define-function empathy_message_new
+  (c-name "empathy_message_new")
+  (is-constructor-of "EmpathyMessage")
+  (return-type "EmpathyMessage*")
+  (parameters
+    '("const-gchar*" "body")
+  )
+)
+
+(define-method get_type
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_get_type")
+  (return-type "EmpathyMessageType")
+)
+
+(define-method set_type
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_set_type")
+  (return-type "none")
+  (parameters
+    '("EmpathyMessageType" "type")
+  )
+)
+
+(define-method get_sender
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_get_sender")
+  (return-type "EmpathyContact*")
+)
+
+(define-method set_sender
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_set_sender")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+  )
+)
+
+(define-method get_receiver
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_get_receiver")
+  (return-type "EmpathyContact*")
+)
+
+(define-method set_receiver
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_set_receiver")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+  )
+)
+
+(define-method get_body
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_get_body")
+  (return-type "const-gchar*")
+)
+
+(define-method set_body
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_set_body")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "body")
+  )
+)
+
+(define-method get_timestamp
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_get_timestamp")
+  (return-type "EmpathyTime")
+)
+
+(define-method set_timestamp
+  (of-object "EmpathyMessage")
+  (c-name "empathy_message_set_timestamp")
+  (return-type "none")
+  (parameters
+    '("EmpathyTime" "timestamp")
+  )
+)
+
+
+
+;; From empathy-presence.h
+
+(define-function empathy_presence_get_type
+  (c-name "empathy_presence_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_presence_new
+  (c-name "empathy_presence_new")
+  (is-constructor-of "EmpathyPresence")
+  (return-type "EmpathyPresence*")
+)
+
+(define-function empathy_presence_new_full
+  (c-name "empathy_presence_new_full")
+  (return-type "EmpathyPresence*")
+  (parameters
+    '("McPresence" "state")
+    '("const-gchar*" "status")
+  )
+)
+
+(define-method get_state
+  (of-object "EmpathyPresence")
+  (c-name "empathy_presence_get_state")
+  (return-type "McPresence")
+)
+
+(define-method get_status
+  (of-object "EmpathyPresence")
+  (c-name "empathy_presence_get_status")
+  (return-type "const-gchar*")
+)
+
+(define-method set_state
+  (of-object "EmpathyPresence")
+  (c-name "empathy_presence_set_state")
+  (return-type "none")
+  (parameters
+    '("McPresence" "state")
+  )
+)
+
+(define-method set_status
+  (of-object "EmpathyPresence")
+  (c-name "empathy_presence_set_status")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "status")
+  )
+)
+
+(define-function empathy_presence_sort_func
+  (c-name "empathy_presence_sort_func")
+  (return-type "gint")
+  (parameters
+    '("gconstpointer" "a")
+    '("gconstpointer" "b")
+  )
+)
+
+(define-function empathy_presence_state_get_default_status
+  (c-name "empathy_presence_state_get_default_status")
+  (return-type "const-gchar*")
+  (parameters
+    '("McPresence" "state")
+  )
+)
+
+(define-function empathy_presence_state_to_str
+  (c-name "empathy_presence_state_to_str")
+  (return-type "const-gchar*")
+  (parameters
+    '("McPresence" "state")
+  )
+)
+
+(define-function empathy_presence_state_from_str
+  (c-name "empathy_presence_state_from_str")
+  (return-type "McPresence")
+  (parameters
+    '("const-gchar*" "str")
+  )
+)
+
+
+
+;; From empathy-time.h
+
+(define-function empathy_time_get_current
+  (c-name "empathy_time_get_current")
+  (return-type "EmpathyTime")
+)
+
+(define-function empathy_time_get_local_time
+  (c-name "empathy_time_get_local_time")
+  (return-type "time_t")
+  (parameters
+    '("struct-tm*" "tm")
+  )
+)
+
+(define-function empathy_time_parse
+  (c-name "empathy_time_parse")
+  (return-type "EmpathyTime")
+  (parameters
+    '("const-gchar*" "str")
+  )
+)
+
+(define-function empathy_time_parse_format
+  (c-name "empathy_time_parse_format")
+  (return-type "EmpathyTime")
+  (parameters
+    '("const-gchar*" "str")
+    '("const-gchar*" "format")
+  )
+)
+
+(define-method to_string_utc
+  (of-object "EmpathyTime")
+  (c-name "empathy_time_to_string_utc")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "format")
+  )
+)
+
+(define-method to_string_local
+  (of-object "EmpathyTime")
+  (c-name "empathy_time_to_string_local")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "format")
+  )
+)
+
+
+
+;; From empathy-tp-chat.h
+
+(define-function empathy_tp_chat_get_type
+  (c-name "empathy_tp_chat_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_tp_chat_new
+  (c-name "empathy_tp_chat_new")
+  (is-constructor-of "EmpathyTpChat")
+  (return-type "EmpathyTpChat*")
+  (parameters
+    '("McAccount*" "account")
+    '("TpChan*" "tp_chan")
+  )
+)
+
+(define-function empathy_tp_chat_new_with_contact
+  (c-name "empathy_tp_chat_new_with_contact")
+  (return-type "EmpathyTpChat*")
+  (parameters
+    '("EmpathyContact*" "contact")
+  )
+)
+
+(define-method get_acknowledge
+  (of-object "EmpathyTpChat")
+  (c-name "empathy_tp_chat_get_acknowledge")
+  (return-type "gboolean")
+)
+
+(define-method set_acknowledge
+  (of-object "EmpathyTpChat")
+  (c-name "empathy_tp_chat_set_acknowledge")
+  (return-type "none")
+  (parameters
+    '("gboolean" "acknowledge")
+  )
+)
+
+(define-method get_channel
+  (of-object "EmpathyTpChat")
+  (c-name "empathy_tp_chat_get_channel")
+  (return-type "TpChan*")
+)
+
+(define-method get_pendings
+  (of-object "EmpathyTpChat")
+  (c-name "empathy_tp_chat_get_pendings")
+  (return-type "GList*")
+)
+
+(define-method send
+  (of-object "EmpathyTpChat")
+  (c-name "empathy_tp_chat_send")
+  (return-type "none")
+  (parameters
+    '("EmpathyMessage*" "message")
+  )
+)
+
+(define-method set_state
+  (of-object "EmpathyTpChat")
+  (c-name "empathy_tp_chat_set_state")
+  (return-type "none")
+  (parameters
+    '("TelepathyChannelChatState" "state")
+  )
+)
+
+(define-method get_id
+  (of-object "EmpathyTpChat")
+  (c-name "empathy_tp_chat_get_id")
+  (return-type "const-gchar*")
+)
+
+
+
+;; From empathy-tp-chatroom.h
+
+(define-function empathy_tp_chatroom_get_type
+  (c-name "empathy_tp_chatroom_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_tp_chatroom_new
+  (c-name "empathy_tp_chatroom_new")
+  (is-constructor-of "EmpathyTpChatroom")
+  (return-type "EmpathyTpChatroom*")
+  (parameters
+    '("McAccount*" "account")
+    '("TpChan*" "tp_chan")
+  )
+)
+
+(define-method get_invitation
+  (of-object "EmpathyTpChatroom")
+  (c-name "empathy_tp_chatroom_get_invitation")
+  (return-type "gboolean")
+  (parameters
+    '("EmpathyContact**" "contact")
+    '("const-gchar**" "message")
+  )
+)
+
+(define-method accept_invitation
+  (of-object "EmpathyTpChatroom")
+  (c-name "empathy_tp_chatroom_accept_invitation")
+  (return-type "none")
+)
+
+(define-method set_topic
+  (of-object "EmpathyTpChatroom")
+  (c-name "empathy_tp_chatroom_set_topic")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "topic")
+  )
+)
+
+
+
+;; From empathy-tp-contact-list.h
+
+(define-function empathy_tp_contact_list_get_type
+  (c-name "empathy_tp_contact_list_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_tp_contact_list_new
+  (c-name "empathy_tp_contact_list_new")
+  (is-constructor-of "EmpathyTpContactList")
+  (return-type "EmpathyTpContactList*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-method get_account
+  (of-object "EmpathyTpContactList")
+  (c-name "empathy_tp_contact_list_get_account")
+  (return-type "McAccount*")
+)
+
+(define-method get_user
+  (of-object "EmpathyTpContactList")
+  (c-name "empathy_tp_contact_list_get_user")
+  (return-type "EmpathyContact*")
+)
+
+(define-method get_from_id
+  (of-object "EmpathyTpContactList")
+  (c-name "empathy_tp_contact_list_get_from_id")
+  (return-type "EmpathyContact*")
+  (parameters
+    '("const-gchar*" "id")
+  )
+)
+
+(define-method get_from_handle
+  (of-object "EmpathyTpContactList")
+  (c-name "empathy_tp_contact_list_get_from_handle")
+  (return-type "EmpathyContact*")
+  (parameters
+    '("guint" "handle")
+  )
+)
+
+(define-method get_from_handles
+  (of-object "EmpathyTpContactList")
+  (c-name "empathy_tp_contact_list_get_from_handles")
+  (return-type "GList*")
+  (parameters
+    '("GArray*" "handles")
+  )
+)
+
+(define-method rename_group
+  (of-object "EmpathyTpContactList")
+  (c-name "empathy_tp_contact_list_rename_group")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "old_group")
+    '("const-gchar*" "new_group")
+  )
+)
+
+(define-method get_groups
+  (of-object "EmpathyTpContactList")
+  (c-name "empathy_tp_contact_list_get_groups")
+  (return-type "GList*")
+)
+
+
+
+;; From empathy-tp-group.h
+
+(define-function empathy_tp_group_get_type
+  (c-name "empathy_tp_group_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_tp_group_new
+  (c-name "empathy_tp_group_new")
+  (is-constructor-of "EmpathyTpGroup")
+  (return-type "EmpathyTpGroup*")
+  (parameters
+    '("TpChan*" "tp_chan")
+    '("TpConn*" "tp_conn")
+  )
+)
+
+(define-method add_members
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_add_members")
+  (return-type "none")
+  (parameters
+    '("GArray*" "handles")
+    '("const-gchar*" "message")
+  )
+)
+
+(define-method add_member
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_add_member")
+  (return-type "none")
+  (parameters
+    '("guint" "handle")
+    '("const-gchar*" "message")
+  )
+)
+
+(define-method remove_members
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_remove_members")
+  (return-type "none")
+  (parameters
+    '("GArray*" "handle")
+    '("const-gchar*" "message")
+  )
+)
+
+(define-method remove_member
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_remove_member")
+  (return-type "none")
+  (parameters
+    '("guint" "handle")
+    '("const-gchar*" "message")
+  )
+)
+
+(define-method get_members
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_get_members")
+  (return-type "GArray*")
+)
+
+(define-method get_all_members
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_get_all_members")
+  (return-type "none")
+  (parameters
+    '("GArray**" "members")
+    '("GArray**" "local_pending")
+    '("GArray**" "remote_pending")
+  )
+)
+
+(define-method get_local_pending_members_with_info
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_get_local_pending_members_with_info")
+  (return-type "GList*")
+)
+
+(define-function empathy_tp_group_info_list_free
+  (c-name "empathy_tp_group_info_list_free")
+  (return-type "none")
+  (parameters
+    '("GList*" "infos")
+  )
+)
+
+(define-method get_name
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_get_name")
+  (return-type "const-gchar*")
+)
+
+(define-method get_self_handle
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_get_self_handle")
+  (return-type "guint")
+)
+
+(define-method get_object_path
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_get_object_path")
+  (return-type "const-gchar*")
+)
+
+(define-method is_member
+  (of-object "EmpathyTpGroup")
+  (c-name "empathy_tp_group_is_member")
+  (return-type "gboolean")
+  (parameters
+    '("guint" "handle")
+  )
+)
+
+
+
+;; From empathy-utils.h
+
+(define-function empathy_substring
+  (c-name "empathy_substring")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "str")
+    '("gint" "start")
+    '("gint" "end")
+  )
+)
+
+(define-function empathy_regex_match
+  (c-name "empathy_regex_match")
+  (return-type "gint")
+  (parameters
+    '("EmpathyRegExType" "type")
+    '("const-gchar*" "msg")
+    '("GArray*" "start")
+    '("GArray*" "end")
+  )
+)
+
+(define-function empathy_strcasecmp
+  (c-name "empathy_strcasecmp")
+  (return-type "gint")
+  (parameters
+    '("const-gchar*" "s1")
+    '("const-gchar*" "s2")
+  )
+)
+
+(define-function empathy_strncasecmp
+  (c-name "empathy_strncasecmp")
+  (return-type "gint")
+  (parameters
+    '("const-gchar*" "s1")
+    '("const-gchar*" "s2")
+    '("gsize" "n")
+  )
+)
+
+(define-function empathy_xml_validate
+  (c-name "empathy_xml_validate")
+  (return-type "gboolean")
+  (parameters
+    '("xmlDoc*" "doc")
+    '("const-gchar*" "dtd_filename")
+  )
+)
+
+(define-function empathy_xml_node_get_child
+  (c-name "empathy_xml_node_get_child")
+  (return-type "xmlNodePtr")
+  (parameters
+    '("xmlNodePtr" "node")
+    '("const-gchar*" "child_name")
+  )
+)
+
+(define-function empathy_xml_node_get_child_content
+  (c-name "empathy_xml_node_get_child_content")
+  (return-type "xmlChar*")
+  (parameters
+    '("xmlNodePtr" "node")
+    '("const-gchar*" "child_name")
+  )
+)
+
+(define-function empathy_xml_node_find_child_prop_value
+  (c-name "empathy_xml_node_find_child_prop_value")
+  (return-type "xmlNodePtr")
+  (parameters
+    '("xmlNodePtr" "node")
+    '("const-gchar*" "prop_name")
+    '("const-gchar*" "prop_value")
+  )
+)
+
+(define-function empathy_account_hash
+  (c-name "empathy_account_hash")
+  (return-type "guint")
+  (parameters
+    '("gconstpointer" "key")
+  )
+)
+
+(define-function empathy_account_equal
+  (c-name "empathy_account_equal")
+  (return-type "gboolean")
+  (parameters
+    '("gconstpointer" "a")
+    '("gconstpointer" "b")
+  )
+)
+
+(define-function empathy_mission_control_new
+  (c-name "empathy_mission_control_new")
+  (is-constructor-of "EmpathyMissionControl")
+  (return-type "MissionControl*")
+)
+
+(define-function empathy_get_channel_id
+  (c-name "empathy_get_channel_id")
+  (return-type "gchar*")
+  (parameters
+    '("McAccount*" "account")
+    '("TpChan*" "tp_chan")
+  )
+)
+
diff --git a/python/pyempathy/pyempathy.override b/python/pyempathy/pyempathy.override
new file mode 100644
index 00000000..82433927
--- /dev/null
+++ b/python/pyempathy/pyempathy.override
@@ -0,0 +1,84 @@
+%%
+headers
+#include <Python.h>
+#include <pygobject.h>
+#include "empathy-avatar.h"
+#include "empathy-chandler.h"
+#include "empathy-chatroom-manager.h"
+#include "empathy-chatroom.h"
+#include "empathy-conf.h"
+#include "empathy-contact-list.h"
+#include "empathy-contact-manager.h"
+#include "empathy-contact.h"
+#include "empathy-debug.h"
+#include "empathy-filter.h"
+#include "empathy-idle.h"
+#include "empathy-log-manager.h"
+#include "empathy-marshal.h"
+#include "empathy-message.h"
+#include "empathy-presence.h"
+#include "empathy-time.h"
+#include "empathy-tp-chat.h"
+#include "empathy-tp-chatroom.h"
+#include "empathy-tp-contact-list.h"
+#include "empathy-tp-group.h"
+#include "empathy-utils.h"
+
+
+/* FIXME */
+#define MC_TYPE_PRESENCE 1
+#define EMPATHY_TYPE_SUBSCRIPTION 2
+#define EMPATHY_TYPE_MESSAGE_TYPE 3
+#define EMPATHY_TYPE_REG_EX_TYPE 4
+
+
+void empathy_add_constants(PyObject *module, const gchar *strip_prefix);
+void empathy_register_classes(PyObject *d);
+
+%%
+modulename empathy
+%%
+ignore-glob
+	*_get_type
+%%
+import gobject.GObject as PyGObject_Type
+%%
+override empathy_contact_list_get_members kwargs
+static PyObject *
+_wrap_empathy_contact_list_get_members(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+
+	PyObject *py_contacts = PyList_New(0);
+	GList *l, *contacts;
+
+	contacts = empathy_contact_list_get_members(EMPATHY_CONTACT_LIST(self->obj));
+
+	for (l = contacts; l; l = l->next) {
+		EmpathyContact *contact;
+		contact = l->data;
+		PyList_Append(py_contacts, pygobject_new((GObject *) contact));
+	}
+
+	return py_contacts;
+
+}
+%%
+override empathy_contact_get_groups kwargs
+static PyObject *
+_wrap_empathy_contact_get_groups(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+
+	GList *groups = empathy_contact_get_groups(EMPATHY_CONTACT(self->obj));
+	PyObject *py_groups = PyList_New(0);
+	GList *l;
+
+	for(l = groups; l; l = l->next) {
+		const gchar *group;
+		group = l->data;
+		PyList_Append(py_groups, PyString_FromString(group));
+	}
+
+	return py_groups;
+
+}
+%%
diff --git a/python/pyempathy/pyempathymodule.c b/python/pyempathy/pyempathymodule.c
new file mode 100644
index 00000000..11803136
--- /dev/null
+++ b/python/pyempathy/pyempathymodule.c
@@ -0,0 +1,24 @@
+#include <pygobject.h>
+
+void empathy_register_classes (PyObject *d); 
+DL_EXPORT(void) initempathy(void);
+extern PyMethodDef empathy_functions[];
+
+DL_EXPORT(void)
+initempathy(void)
+{
+	PyObject *m, *d;
+
+	init_pygobject ();
+	
+	m = Py_InitModule ("empathy", empathy_functions);
+	d = PyModule_GetDict (m);
+	
+	empathy_register_classes (d);
+	
+	if (PyErr_Occurred ()) {
+		PyErr_Print();
+		Py_FatalError ("can't initialise module empathy");
+	}
+}
+
diff --git a/python/pyempathygtk/Makefile.am b/python/pyempathygtk/Makefile.am
new file mode 100644
index 00000000..fa8f9f9d
--- /dev/null
+++ b/python/pyempathygtk/Makefile.am
@@ -0,0 +1,39 @@
+PYDEFS=`pkg-config --variable=defsdir pygtk-2.0`
+
+AM_CPPFLAGS =                                           \
+	-I.                                             \
+	-I$(top_srcdir)/libempathy-gtk			\
+	-I$(top_srcdir)                                 \
+	-DDATADIR=\""$(datadir)"\"              	\
+	$(PYTHON_BINDING_CFLAGS)			\
+	`python-config --cflags`			
+
+BUILT_SOURCES = 					\
+	pyempathygtk.c					
+
+pyempathygtkdir = $(prefix)/lib/`pyversions -d`/site-packages
+pyempathygtk_LTLIBRARIES = empathygtk.la
+
+empathygtk_la_SOURCES =					\
+	pyempathygtkmodule.c				\
+	pyempathygtk.c
+
+empathygtk_la_LIBADD =					\
+	$(PYTHON_BINDING_LIBS)				\
+	$(top_builddir)/libempathy/libempathy.la	\
+	$(top_builddir)/libempathy-gtk/libempathy-gtk.la
+
+empathygtk_la_LDFLAGS =					\
+	`python-config --libs`				\
+	-module -avoid-version
+
+pyempathygtk.c: pyempathygtk.override pyempathygtk.defs
+	pygtk-codegen-2.0 --prefix empathy 				\
+		--register $(PYDEFS)/gdk-types.defs 			\
+		--register $(PYDEFS)/gtk-types.defs 			\
+		--register ../pyempathy/pyempathy.defs			\
+		--override pyempathygtk.override 			\
+		pyempathygtk.defs > $@ 
+
+CLEANFILES = $(BUILT_SOURCES)
+
diff --git a/python/pyempathygtk/pyempathygtk.defs b/python/pyempathygtk/pyempathygtk.defs
new file mode 100644
index 00000000..c41ea45c
--- /dev/null
+++ b/python/pyempathygtk/pyempathygtk.defs
@@ -0,0 +1,1698 @@
+;; -*- scheme -*-
+; object definitions ...
+(define-object AccountChooser
+  (in-module "Empathy")
+  (parent "GtkComboBox")
+  (c-name "EmpathyAccountChooser")
+  (gtype-id "EMPATHY_TYPE_ACCOUNT_CHOOSER")
+)
+
+(define-object CellRendererExpander
+  (in-module "Empathy")
+  (parent "GtkCellRenderer")
+  (c-name "EmpathyCellRendererExpander")
+  (gtype-id "EMPATHY_TYPE_CELL_RENDERER_EXPANDER")
+)
+
+(define-object CellRendererText
+  (in-module "Empathy")
+  (parent "GtkCellRendererText")
+  (c-name "EmpathyCellRendererText")
+  (gtype-id "EMPATHY_TYPE_CELL_RENDERER_TEXT")
+)
+
+(define-object Chat
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyChat")
+  (gtype-id "EMPATHY_TYPE_CHAT")
+)
+
+(define-object ChatView
+  (in-module "Empathy")
+  (parent "GtkTextView")
+  (c-name "EmpathyChatView")
+  (gtype-id "EMPATHY_TYPE_CHAT_VIEW")
+)
+
+(define-object ChatWindow
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyChatWindow")
+  (gtype-id "EMPATHY_TYPE_CHAT_WINDOW")
+)
+
+(define-object ContactListStore
+  (in-module "Empathy")
+  (parent "GtkTreeStore")
+  (c-name "EmpathyContactListStore")
+  (gtype-id "EMPATHY_TYPE_CONTACT_LIST_STORE")
+)
+
+(define-object ContactListView
+  (in-module "Empathy")
+  (parent "GtkTreeView")
+  (c-name "EmpathyContactListView")
+  (gtype-id "EMPATHY_TYPE_CONTACT_LIST_VIEW")
+)
+
+(define-object GroupChat
+  (in-module "Empathy")
+  (parent "EmpathyChat")
+  (c-name "EmpathyGroupChat")
+  (gtype-id "EMPATHY_TYPE_GROUP_CHAT")
+)
+
+(define-object PresenceChooser
+  (in-module "Empathy")
+  (parent "GtkToggleButton")
+  (c-name "EmpathyPresenceChooser")
+  (gtype-id "EMPATHY_TYPE_PRESENCE_CHOOSER")
+)
+
+(define-object PrivateChat
+  (in-module "Empathy")
+  (parent "EmpathyChat")
+  (c-name "EmpathyPrivateChat")
+  (gtype-id "EMPATHY_TYPE_PRIVATE_CHAT")
+)
+
+(define-object StatusIcon
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyStatusIcon")
+  (gtype-id "EMPATHY_TYPE_STATUS_ICON")
+)
+
+(define-object ThemeManager
+  (in-module "Empathy")
+  (parent "GObject")
+  (c-name "EmpathyThemeManager")
+  (gtype-id "EMPATHY_TYPE_THEME_MANAGER")
+)
+
+(define-object Spinner
+  (in-module "Ephy")
+  (parent "GtkWidget")
+  (c-name "EphySpinner")
+  (gtype-id "EPHY_TYPE_SPINNER")
+)
+
+;; Enumerations and flags ...
+
+(define-enum Smiley
+  (in-module "Empathy")
+  (c-name "EmpathySmiley")
+  (gtype-id "EMPATHY_TYPE_SMILEY")
+  (values
+    '("normal" "EMPATHY_SMILEY_NORMAL")
+    '("wink" "EMPATHY_SMILEY_WINK")
+    '("bigeye" "EMPATHY_SMILEY_BIGEYE")
+    '("nose" "EMPATHY_SMILEY_NOSE")
+    '("cry" "EMPATHY_SMILEY_CRY")
+    '("sad" "EMPATHY_SMILEY_SAD")
+    '("sceptical" "EMPATHY_SMILEY_SCEPTICAL")
+    '("bigsmile" "EMPATHY_SMILEY_BIGSMILE")
+    '("indifferent" "EMPATHY_SMILEY_INDIFFERENT")
+    '("tounge" "EMPATHY_SMILEY_TOUNGE")
+    '("shocked" "EMPATHY_SMILEY_SHOCKED")
+    '("cool" "EMPATHY_SMILEY_COOL")
+    '("sorry" "EMPATHY_SMILEY_SORRY")
+    '("kiss" "EMPATHY_SMILEY_KISS")
+    '("shutup" "EMPATHY_SMILEY_SHUTUP")
+    '("yawn" "EMPATHY_SMILEY_YAWN")
+    '("confused" "EMPATHY_SMILEY_CONFUSED")
+    '("angel" "EMPATHY_SMILEY_ANGEL")
+    '("oooh" "EMPATHY_SMILEY_OOOH")
+    '("lookaway" "EMPATHY_SMILEY_LOOKAWAY")
+    '("blush" "EMPATHY_SMILEY_BLUSH")
+    '("coolbigsmile" "EMPATHY_SMILEY_COOLBIGSMILE")
+    '("angry" "EMPATHY_SMILEY_ANGRY")
+    '("boss" "EMPATHY_SMILEY_BOSS")
+    '("monkey" "EMPATHY_SMILEY_MONKEY")
+    '("silly" "EMPATHY_SMILEY_SILLY")
+    '("sick" "EMPATHY_SMILEY_SICK")
+    '("count" "EMPATHY_SMILEY_COUNT")
+  )
+)
+
+(define-enum ContactListStoreSort
+  (in-module "Empathy")
+  (c-name "EmpathyContactListStoreSort")
+  (gtype-id "EMPATHY_TYPE_CONTACT_LIST_STORE_SORT")
+  (values
+    '("state" "EMPATHY_CONTACT_LIST_STORE_SORT_STATE")
+    '("name" "EMPATHY_CONTACT_LIST_STORE_SORT_NAME")
+  )
+)
+
+(define-enum ContactListStoreCol
+  (in-module "Empathy")
+  (c-name "EmpathyContactListStoreCol")
+  (gtype-id "EMPATHY_TYPE_CONTACT_LIST_STORE_COL")
+  (values
+    '("icon-status" "COL_ICON_STATUS")
+    '("pixbuf-avatar" "COL_PIXBUF_AVATAR")
+    '("pixbuf-avatar-visible" "COL_PIXBUF_AVATAR_VISIBLE")
+    '("name" "COL_NAME")
+    '("status" "COL_STATUS")
+    '("status-visible" "COL_STATUS_VISIBLE")
+    '("contact" "COL_CONTACT")
+    '("is-group" "COL_IS_GROUP")
+    '("is-active" "COL_IS_ACTIVE")
+    '("is-online" "COL_IS_ONLINE")
+    '("is-separator" "COL_IS_SEPARATOR")
+    '("count" "COL_COUNT")
+  )
+)
+
+(define-enum ContactWidgetType
+  (in-module "Empathy")
+  (c-name "EmpathyContactWidgetType")
+  (gtype-id "EMPATHY_TYPE_CONTACT_WIDGET_TYPE")
+  (values
+    '("show" "CONTACT_WIDGET_TYPE_SHOW")
+    '("edit" "CONTACT_WIDGET_TYPE_EDIT")
+    '("add" "CONTACT_WIDGET_TYPE_ADD")
+    '("subscription" "CONTACT_WIDGET_TYPE_SUBSCRIPTION")
+  )
+)
+
+
+;; From empathy-about-dialog.h
+
+(define-function empathy_about_dialog_new
+  (c-name "empathy_about_dialog_new")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "parent")
+  )
+)
+
+
+
+;; From empathy-account-chooser.h
+
+(define-function empathy_account_chooser_get_type
+  (c-name "empathy_account_chooser_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_account_chooser_new
+  (c-name "empathy_account_chooser_new")
+  (is-constructor-of "EmpathyAccountChooser")
+  (return-type "GtkWidget*")
+)
+
+(define-method get_account
+  (of-object "EmpathyAccountChooser")
+  (c-name "empathy_account_chooser_get_account")
+  (return-type "McAccount*")
+)
+
+(define-method set_account
+  (of-object "EmpathyAccountChooser")
+  (c-name "empathy_account_chooser_set_account")
+  (return-type "gboolean")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-method get_has_all_option
+  (of-object "EmpathyAccountChooser")
+  (c-name "empathy_account_chooser_get_has_all_option")
+  (return-type "gboolean")
+)
+
+(define-method set_has_all_option
+  (of-object "EmpathyAccountChooser")
+  (c-name "empathy_account_chooser_set_has_all_option")
+  (return-type "none")
+  (parameters
+    '("gboolean" "has_all_option")
+  )
+)
+
+(define-method set_filter
+  (of-object "EmpathyAccountChooser")
+  (c-name "empathy_account_chooser_set_filter")
+  (return-type "none")
+  (parameters
+    '("EmpathyAccountChooserFilterFunc" "filter")
+    '("gpointer" "user_data")
+  )
+)
+
+(define-function empathy_account_chooser_filter_is_connected
+  (c-name "empathy_account_chooser_filter_is_connected")
+  (return-type "gboolean")
+  (parameters
+    '("McAccount*" "account")
+    '("gpointer" "user_data")
+  )
+)
+
+
+
+;; From empathy-accounts-dialog.h
+
+(define-function empathy_accounts_dialog_show
+  (c-name "empathy_accounts_dialog_show")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GtkWindow*" "parent")
+  )
+)
+
+
+
+;; From empathy-account-widget-generic.h
+
+(define-function empathy_account_widget_generic_new
+  (c-name "empathy_account_widget_generic_new")
+  (is-constructor-of "EmpathyAccountWidgetGeneric")
+  (return-type "GtkWidget*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+
+
+;; From empathy-account-widget-jabber.h
+
+(define-function empathy_account_widget_jabber_new
+  (c-name "empathy_account_widget_jabber_new")
+  (is-constructor-of "EmpathyAccountWidgetJabber")
+  (return-type "GtkWidget*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+
+
+;; From empathy-account-widget-msn.h
+
+(define-function empathy_account_widget_msn_new
+  (c-name "empathy_account_widget_msn_new")
+  (is-constructor-of "EmpathyAccountWidgetMsn")
+  (return-type "GtkWidget*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+
+
+;; From empathy-cell-renderer-expander.h
+
+(define-function empathy_cell_renderer_expander_get_type
+  (c-name "empathy_cell_renderer_expander_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_cell_renderer_expander_new
+  (c-name "empathy_cell_renderer_expander_new")
+  (is-constructor-of "EmpathyCellRendererExpander")
+  (return-type "GtkCellRenderer*")
+)
+
+
+
+;; From empathy-cell-renderer-text.h
+
+(define-function empathy_cell_renderer_text_get_type
+  (c-name "empathy_cell_renderer_text_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_cell_renderer_text_new
+  (c-name "empathy_cell_renderer_text_new")
+  (is-constructor-of "EmpathyCellRendererText")
+  (return-type "GtkCellRenderer*")
+)
+
+
+
+;; From empathy-chat.h
+
+(define-function empathy_chat_get_type
+  (c-name "empathy_chat_get_type")
+  (return-type "GType")
+)
+
+(define-method get_view
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_get_view")
+  (return-type "EmpathyChatView*")
+)
+
+(define-method get_window
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_get_window")
+  (return-type "EmpathyChatWindow*")
+)
+
+(define-method set_window
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_set_window")
+  (return-type "none")
+  (parameters
+    '("EmpathyChatWindow*" "window")
+  )
+)
+
+(define-method present
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_present")
+  (return-type "none")
+)
+
+(define-method clear
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_clear")
+  (return-type "none")
+)
+
+(define-method scroll_down
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_scroll_down")
+  (return-type "none")
+)
+
+(define-method cut
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_cut")
+  (return-type "none")
+)
+
+(define-method copy
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_copy")
+  (return-type "none")
+)
+
+(define-method paste
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_paste")
+  (return-type "none")
+)
+
+(define-method get_name
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_get_name")
+  (return-type "const-gchar*")
+)
+
+(define-method get_tooltip
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_get_tooltip")
+  (return-type "gchar*")
+)
+
+(define-method get_status_icon_name
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_get_status_icon_name")
+  (return-type "const-gchar*")
+)
+
+(define-method get_widget
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_get_widget")
+  (return-type "GtkWidget*")
+)
+
+(define-method is_group_chat
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_is_group_chat")
+  (return-type "gboolean")
+)
+
+(define-method is_connected
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_is_connected")
+  (return-type "gboolean")
+)
+
+(define-method save_geometry
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_save_geometry")
+  (return-type "none")
+  (parameters
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "w")
+    '("gint" "h")
+  )
+)
+
+(define-method load_geometry
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_load_geometry")
+  (return-type "none")
+  (parameters
+    '("gint*" "x")
+    '("gint*" "y")
+    '("gint*" "w")
+    '("gint*" "h")
+  )
+)
+
+(define-method set_tp_chat
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_set_tp_chat")
+  (return-type "none")
+  (parameters
+    '("EmpathyTpChat*" "tp_chat")
+  )
+)
+
+(define-method get_id
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_get_id")
+  (return-type "const-gchar*")
+)
+
+(define-function empathy_chat_get_is_command
+  (c-name "empathy_chat_get_is_command")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "str")
+  )
+)
+
+(define-method correct_word
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_correct_word")
+  (return-type "none")
+  (parameters
+    '("GtkTextIter" "start")
+    '("GtkTextIter" "end")
+    '("const-gchar*" "new_word")
+  )
+)
+
+(define-method should_play_sound
+  (of-object "EmpathyChat")
+  (c-name "empathy_chat_should_play_sound")
+  (return-type "gboolean")
+)
+
+(define-function empathy_chat_should_highlight_nick
+  (c-name "empathy_chat_should_highlight_nick")
+  (return-type "gboolean")
+  (parameters
+    '("EmpathyMessage*" "message")
+  )
+)
+
+
+
+;; From empathy-chatrooms-window.h
+
+(define-function empathy_chatrooms_window_show
+  (c-name "empathy_chatrooms_window_show")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "parent")
+  )
+)
+
+
+
+;; From empathy-chat-view.h
+
+(define-function empathy_chat_view_get_type
+  (c-name "empathy_chat_view_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_chat_view_new
+  (c-name "empathy_chat_view_new")
+  (is-constructor-of "EmpathyChatView")
+  (return-type "EmpathyChatView*")
+)
+
+(define-method append_message
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_append_message")
+  (return-type "none")
+  (parameters
+    '("EmpathyMessage*" "msg")
+  )
+)
+
+(define-method append_event
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_append_event")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "str")
+  )
+)
+
+(define-method append_button
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_append_button")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "message")
+    '("GtkWidget*" "button1")
+    '("GtkWidget*" "button2")
+  )
+)
+
+(define-method set_margin
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_set_margin")
+  (return-type "none")
+  (parameters
+    '("gint" "margin")
+  )
+)
+
+(define-method scroll
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_scroll")
+  (return-type "none")
+  (parameters
+    '("gboolean" "allow_scrolling")
+  )
+)
+
+(define-method scroll_down
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_scroll_down")
+  (return-type "none")
+)
+
+(define-method get_selection_bounds
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_get_selection_bounds")
+  (return-type "gboolean")
+  (parameters
+    '("GtkTextIter*" "start")
+    '("GtkTextIter*" "end")
+  )
+)
+
+(define-method clear
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_clear")
+  (return-type "none")
+)
+
+(define-method find_previous
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_find_previous")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "search_criteria")
+    '("gboolean" "new_search")
+  )
+)
+
+(define-method find_next
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_find_next")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "search_criteria")
+    '("gboolean" "new_search")
+  )
+)
+
+(define-method find_abilities
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_find_abilities")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "search_criteria")
+    '("gboolean*" "can_do_previous")
+    '("gboolean*" "can_do_next")
+  )
+)
+
+(define-method highlight
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_highlight")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "text")
+  )
+)
+
+(define-method copy_clipboard
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_copy_clipboard")
+  (return-type "none")
+)
+
+(define-method get_irc_style
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_get_irc_style")
+  (return-type "gboolean")
+)
+
+(define-method set_irc_style
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_set_irc_style")
+  (return-type "none")
+  (parameters
+    '("gboolean" "irc_style")
+  )
+)
+
+(define-method set_margin
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_set_margin")
+  (return-type "none")
+  (parameters
+    '("gint" "margin")
+  )
+)
+
+(define-function empathy_chat_view_get_smiley_image
+  (c-name "empathy_chat_view_get_smiley_image")
+  (return-type "GdkPixbuf*")
+  (parameters
+    '("EmpathySmiley" "smiley")
+  )
+)
+
+(define-function empathy_chat_view_get_smiley_text
+  (c-name "empathy_chat_view_get_smiley_text")
+  (return-type "const-gchar*")
+  (parameters
+    '("EmpathySmiley" "smiley")
+  )
+)
+
+(define-function empathy_chat_view_get_smiley_menu
+  (c-name "empathy_chat_view_get_smiley_menu")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GCallback" "callback")
+    '("gpointer" "user_data")
+    '("GtkTooltips*" "tooltips")
+  )
+)
+
+(define-method set_is_group_chat
+  (of-object "EmpathyChatView")
+  (c-name "empathy_chat_view_set_is_group_chat")
+  (return-type "none")
+  (parameters
+    '("gboolean" "is_group_chat")
+  )
+)
+
+
+
+;; From empathy-chat-window.h
+
+(define-function empathy_chat_window_get_type
+  (c-name "empathy_chat_window_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_chat_window_get_default
+  (c-name "empathy_chat_window_get_default")
+  (return-type "EmpathyChatWindow*")
+)
+
+(define-function empathy_chat_window_new
+  (c-name "empathy_chat_window_new")
+  (is-constructor-of "EmpathyChatWindow")
+  (return-type "EmpathyChatWindow*")
+)
+
+(define-method get_dialog
+  (of-object "EmpathyChatWindow")
+  (c-name "empathy_chat_window_get_dialog")
+  (return-type "GtkWidget*")
+)
+
+(define-method add_chat
+  (of-object "EmpathyChatWindow")
+  (c-name "empathy_chat_window_add_chat")
+  (return-type "none")
+  (parameters
+    '("EmpathyChat*" "chat")
+  )
+)
+
+(define-method remove_chat
+  (of-object "EmpathyChatWindow")
+  (c-name "empathy_chat_window_remove_chat")
+  (return-type "none")
+  (parameters
+    '("EmpathyChat*" "chat")
+  )
+)
+
+(define-method move_chat
+  (of-object "EmpathyChatWindow")
+  (c-name "empathy_chat_window_move_chat")
+  (return-type "none")
+  (parameters
+    '("EmpathyChatWindow*" "new_window")
+    '("EmpathyChat*" "chat")
+  )
+)
+
+(define-method switch_to_chat
+  (of-object "EmpathyChatWindow")
+  (c-name "empathy_chat_window_switch_to_chat")
+  (return-type "none")
+  (parameters
+    '("EmpathyChat*" "chat")
+  )
+)
+
+(define-method has_focus
+  (of-object "EmpathyChatWindow")
+  (c-name "empathy_chat_window_has_focus")
+  (return-type "gboolean")
+)
+
+(define-function empathy_chat_window_find_chat
+  (c-name "empathy_chat_window_find_chat")
+  (return-type "EmpathyChat*")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "id")
+  )
+)
+
+
+
+;; From empathy-contact-dialogs.h
+
+(define-function empathy_subscription_dialog_show
+  (c-name "empathy_subscription_dialog_show")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+    '("GtkWindow*" "parent")
+  )
+)
+
+(define-method information_dialog_show
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_information_dialog_show")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "parent")
+    '("gboolean" "edit")
+  )
+)
+
+(define-function empathy_new_contact_dialog_show
+  (c-name "empathy_new_contact_dialog_show")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "parent")
+  )
+)
+
+
+
+;; From empathy-contact-groups.h
+
+(define-function empathy_contact_groups_get_all
+  (c-name "empathy_contact_groups_get_all")
+  (return-type "none")
+)
+
+(define-function empathy_contact_group_get_expanded
+  (c-name "empathy_contact_group_get_expanded")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "group")
+  )
+)
+
+(define-function empathy_contact_group_set_expanded
+  (c-name "empathy_contact_group_set_expanded")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "group")
+    '("gboolean" "expanded")
+  )
+)
+
+
+
+;; From empathy-contact-list-store.h
+
+(define-function empathy_contact_list_store_get_type
+  (c-name "empathy_contact_list_store_get_type")
+  (return-type "GType")
+)
+
+(define-method store_new
+  (of-object "EmpathyContactList")
+  (c-name "empathy_contact_list_store_new")
+  (return-type "EmpathyContactListStore*")
+)
+
+(define-method get_list_iface
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_get_list_iface")
+  (return-type "EmpathyContactList*")
+)
+
+(define-method get_show_offline
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_get_show_offline")
+  (return-type "gboolean")
+)
+
+(define-method set_show_offline
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_set_show_offline")
+  (return-type "none")
+  (parameters
+    '("gboolean" "show_offline")
+  )
+)
+
+(define-method get_show_avatars
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_get_show_avatars")
+  (return-type "gboolean")
+)
+
+(define-method set_show_avatars
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_set_show_avatars")
+  (return-type "none")
+  (parameters
+    '("gboolean" "show_avatars")
+  )
+)
+
+(define-method get_is_compact
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_get_is_compact")
+  (return-type "gboolean")
+)
+
+(define-method set_is_compact
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_set_is_compact")
+  (return-type "none")
+  (parameters
+    '("gboolean" "is_compact")
+  )
+)
+
+(define-method get_sort_criterium
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_get_sort_criterium")
+  (return-type "EmpathyContactListStoreSort")
+)
+
+(define-method set_sort_criterium
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_set_sort_criterium")
+  (return-type "none")
+  (parameters
+    '("EmpathyContactListStoreSort" "sort_criterium")
+  )
+)
+
+(define-function empathy_contact_list_store_row_separator_func
+  (c-name "empathy_contact_list_store_row_separator_func")
+  (return-type "gboolean")
+  (parameters
+    '("GtkTreeModel*" "model")
+    '("GtkTreeIter*" "iter")
+    '("gpointer" "data")
+  )
+)
+
+(define-function empathy_contact_list_store_get_parent_group
+  (c-name "empathy_contact_list_store_get_parent_group")
+  (return-type "gchar*")
+  (parameters
+    '("GtkTreeModel*" "model")
+    '("GtkTreePath*" "path")
+    '("gboolean*" "path_is_group")
+  )
+)
+
+(define-function empathy_contact_list_store_search_equal_func
+  (c-name "empathy_contact_list_store_search_equal_func")
+  (return-type "gboolean")
+  (parameters
+    '("GtkTreeModel*" "model")
+    '("gint" "column")
+    '("const-gchar*" "key")
+    '("GtkTreeIter*" "iter")
+    '("gpointer" "search_data")
+  )
+)
+
+(define-method set_contact_groups_func
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_set_contact_groups_func")
+  (return-type "none")
+  (parameters
+    '("EmpathyContactGroupsFunc" "func")
+    '("gpointer" "user_data")
+  )
+)
+
+(define-method update_contact_groups
+  (of-object "EmpathyContactListStore")
+  (c-name "empathy_contact_list_store_update_contact_groups")
+  (return-type "none")
+  (parameters
+    '("EmpathyContact*" "contact")
+  )
+)
+
+
+
+;; From empathy-contact-list-view.h
+
+(define-function empathy_contact_list_view_get_type
+  (c-name "empathy_contact_list_view_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_contact_list_view_new
+  (c-name "empathy_contact_list_view_new")
+  (is-constructor-of "EmpathyContactListView")
+  (return-type "EmpathyContactListView*")
+  (parameters
+    '("EmpathyContactListStore*" "store")
+  )
+)
+
+(define-method get_selected
+  (of-object "EmpathyContactListView")
+  (c-name "empathy_contact_list_view_get_selected")
+  (return-type "EmpathyContact*")
+)
+
+(define-method get_selected_group
+  (of-object "EmpathyContactListView")
+  (c-name "empathy_contact_list_view_get_selected_group")
+  (return-type "gchar*")
+)
+
+(define-method get_contact_menu
+  (of-object "EmpathyContactListView")
+  (c-name "empathy_contact_list_view_get_contact_menu")
+  (return-type "GtkWidget*")
+  (parameters
+    '("EmpathyContact*" "contact")
+  )
+)
+
+(define-method get_group_menu
+  (of-object "EmpathyContactListView")
+  (c-name "empathy_contact_list_view_get_group_menu")
+  (return-type "GtkWidget*")
+)
+
+(define-method set_filter
+  (of-object "EmpathyContactListView")
+  (c-name "empathy_contact_list_view_set_filter")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "filter")
+  )
+)
+
+(define-method set_drag_received_func
+  (of-object "EmpathyContactListView")
+  (c-name "empathy_contact_list_view_set_drag_received_func")
+  (return-type "none")
+  (parameters
+    '("EmpathyContactListViewDragReceivedFunc" "func")
+    '("gpointer" "user_data")
+  )
+)
+
+
+
+;; From empathy-contact-widget.h
+
+(define-method widget_new
+  (of-object "EmpathyContact")
+  (c-name "empathy_contact_widget_new")
+  (return-type "GtkWidget*")
+  (parameters
+    '("EmpathyContactWidgetType" "type")
+  )
+)
+
+(define-function empathy_contact_widget_get_contact
+  (c-name "empathy_contact_widget_get_contact")
+  (return-type "EmpathyContact*")
+  (parameters
+    '("GtkWidget*" "widget")
+  )
+)
+
+
+
+;; From empathy-geometry.h
+
+(define-function empathy_geometry_save
+  (c-name "empathy_geometry_save")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+    '("gint" "x")
+    '("gint" "y")
+    '("gint" "w")
+    '("gint" "h")
+  )
+)
+
+(define-function empathy_geometry_load
+  (c-name "empathy_geometry_load")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "name")
+    '("gint*" "x")
+    '("gint*" "y")
+    '("gint*" "w")
+    '("gint*" "h")
+  )
+)
+
+
+
+;; From empathy-group-chat.h
+
+(define-function empathy_group_chat_get_type
+  (c-name "empathy_group_chat_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_group_chat_new
+  (c-name "empathy_group_chat_new")
+  (is-constructor-of "EmpathyGroupChat")
+  (return-type "EmpathyGroupChat*")
+  (parameters
+    '("McAccount*" "account")
+    '("TpChan*" "tp_chan")
+  )
+)
+
+(define-method get_show_contacts
+  (of-object "EmpathyGroupChat")
+  (c-name "empathy_group_chat_get_show_contacts")
+  (return-type "gboolean")
+)
+
+(define-method set_show_contacts
+  (of-object "EmpathyGroupChat")
+  (c-name "empathy_group_chat_set_show_contacts")
+  (return-type "none")
+  (parameters
+    '("gboolean" "show")
+  )
+)
+
+(define-method set_topic
+  (of-object "EmpathyGroupChat")
+  (c-name "empathy_group_chat_set_topic")
+  (return-type "none")
+)
+
+
+
+;; From empathy-images.h
+
+
+
+;; From empathy-log-window.h
+
+(define-function empathy_log_window_show
+  (c-name "empathy_log_window_show")
+  (return-type "none")
+  (parameters
+    '("McAccount*" "account")
+    '("const-gchar*" "chat_id")
+    '("gboolean" "chatroom")
+    '("GtkWindow*" "parent")
+  )
+)
+
+
+
+;; From empathy-main-window.h
+
+(define-function empathy_main_window_show
+  (c-name "empathy_main_window_show")
+  (return-type "GtkWidget*")
+)
+
+
+
+;; From empathy-new-chatroom-dialog.h
+
+(define-function empathy_new_chatroom_dialog_show
+  (c-name "empathy_new_chatroom_dialog_show")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "parent")
+  )
+)
+
+
+
+;; From empathy-preferences.h
+
+(define-function empathy_preferences_show
+  (c-name "empathy_preferences_show")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GtkWindow*" "parent")
+  )
+)
+
+
+
+;; From empathy-presence-chooser.h
+
+(define-function empathy_presence_chooser_get_type
+  (c-name "empathy_presence_chooser_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_presence_chooser_new
+  (c-name "empathy_presence_chooser_new")
+  (is-constructor-of "EmpathyPresenceChooser")
+  (return-type "GtkWidget*")
+)
+
+(define-function empathy_presence_chooser_create_menu
+  (c-name "empathy_presence_chooser_create_menu")
+  (return-type "GtkWidget*")
+)
+
+
+
+;; From empathy-private-chat.h
+
+(define-function empathy_private_chat_get_type
+  (c-name "empathy_private_chat_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_private_chat_new
+  (c-name "empathy_private_chat_new")
+  (is-constructor-of "EmpathyPrivateChat")
+  (return-type "EmpathyPrivateChat*")
+  (parameters
+    '("McAccount*" "account")
+    '("TpChan*" "tp_chan")
+  )
+)
+
+(define-function empathy_private_chat_new_with_contact
+  (c-name "empathy_private_chat_new_with_contact")
+  (return-type "EmpathyPrivateChat*")
+  (parameters
+    '("EmpathyContact*" "contact")
+  )
+)
+
+(define-method get_contact
+  (of-object "EmpathyPrivateChat")
+  (c-name "empathy_private_chat_get_contact")
+  (return-type "EmpathyContact*")
+)
+
+
+
+;; From empathy-profile-chooser.h
+
+(define-function empathy_profile_chooser_new
+  (c-name "empathy_profile_chooser_new")
+  (is-constructor-of "EmpathyProfileChooser")
+  (return-type "GtkWidget*")
+)
+
+(define-function empathy_profile_chooser_get_selected
+  (c-name "empathy_profile_chooser_get_selected")
+  (return-type "McProfile*")
+  (parameters
+    '("GtkWidget*" "widget")
+  )
+)
+
+
+
+;; From empathy-spell-dialog.h
+
+(define-function empathy_spell_dialog_show
+  (c-name "empathy_spell_dialog_show")
+  (return-type "none")
+  (parameters
+    '("EmpathyChat*" "chat")
+    '("GtkTextIter" "start")
+    '("GtkTextIter" "end")
+    '("const-gchar*" "word")
+  )
+)
+
+
+
+;; From empathy-spell.h
+
+(define-function empathy_spell_supported
+  (c-name "empathy_spell_supported")
+  (return-type "gboolean")
+)
+
+(define-function empathy_spell_get_language_name
+  (c-name "empathy_spell_get_language_name")
+  (return-type "const-gchar*")
+  (parameters
+    '("const-gchar*" "code")
+  )
+)
+
+(define-function empathy_spell_get_language_codes
+  (c-name "empathy_spell_get_language_codes")
+  (return-type "GList*")
+)
+
+(define-function empathy_spell_free_language_codes
+  (c-name "empathy_spell_free_language_codes")
+  (return-type "none")
+  (parameters
+    '("GList*" "codes")
+  )
+)
+
+(define-function empathy_spell_check
+  (c-name "empathy_spell_check")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "word")
+  )
+)
+
+(define-function empathy_spell_get_suggestions
+  (c-name "empathy_spell_get_suggestions")
+  (return-type "GList*")
+  (parameters
+    '("const-gchar*" "word")
+  )
+)
+
+(define-function empathy_spell_free_suggestions
+  (c-name "empathy_spell_free_suggestions")
+  (return-type "none")
+  (parameters
+    '("GList*" "suggestions")
+  )
+)
+
+
+
+;; From empathy-status-icon.h
+
+(define-function empathy_status_icon_get_type
+  (c-name "empathy_status_icon_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_status_icon_new
+  (c-name "empathy_status_icon_new")
+  (is-constructor-of "EmpathyStatusIcon")
+  (return-type "EmpathyStatusIcon*")
+  (parameters
+    '("GtkWindow*" "window")
+  )
+)
+
+
+
+;; From empathy-status-presets.h
+
+(define-function empathy_status_presets_get_all
+  (c-name "empathy_status_presets_get_all")
+  (return-type "none")
+)
+
+(define-function empathy_status_presets_get
+  (c-name "empathy_status_presets_get")
+  (return-type "GList*")
+  (parameters
+    '("McPresence" "state")
+    '("gint" "max_number")
+  )
+)
+
+(define-function empathy_status_presets_set_last
+  (c-name "empathy_status_presets_set_last")
+  (return-type "none")
+  (parameters
+    '("McPresence" "state")
+    '("const-gchar*" "status")
+  )
+)
+
+(define-function empathy_status_presets_remove
+  (c-name "empathy_status_presets_remove")
+  (return-type "none")
+  (parameters
+    '("McPresence" "state")
+    '("const-gchar*" "status")
+  )
+)
+
+(define-function empathy_status_presets_reset
+  (c-name "empathy_status_presets_reset")
+  (return-type "none")
+)
+
+(define-function empathy_status_presets_get_default_state
+  (c-name "empathy_status_presets_get_default_state")
+  (return-type "McPresence")
+)
+
+(define-function empathy_status_presets_get_default_status
+  (c-name "empathy_status_presets_get_default_status")
+  (return-type "const-gchar*")
+)
+
+(define-function empathy_status_presets_set_default
+  (c-name "empathy_status_presets_set_default")
+  (return-type "none")
+  (parameters
+    '("McPresence" "state")
+    '("const-gchar*" "status")
+  )
+)
+
+(define-function empathy_status_presets_clear_default
+  (c-name "empathy_status_presets_clear_default")
+  (return-type "none")
+)
+
+
+
+;; From empathy-theme-manager.h
+
+(define-function empathy_theme_manager_get_type
+  (c-name "empathy_theme_manager_get_type")
+  (return-type "GType")
+)
+
+(define-function empathy_theme_manager_get
+  (c-name "empathy_theme_manager_get")
+  (return-type "EmpathyThemeManager*")
+)
+
+(define-function empathy_theme_manager_get_themes
+  (c-name "empathy_theme_manager_get_themes")
+  (return-type "const-gchar**")
+)
+
+(define-method apply
+  (of-object "EmpathyThemeManager")
+  (c-name "empathy_theme_manager_apply")
+  (return-type "none")
+  (parameters
+    '("EmpathyChatView*" "view")
+    '("const-gchar*" "theme")
+  )
+)
+
+(define-method apply_saved
+  (of-object "EmpathyThemeManager")
+  (c-name "empathy_theme_manager_apply_saved")
+  (return-type "none")
+  (parameters
+    '("EmpathyChatView*" "view")
+  )
+)
+
+(define-method update_show_avatars
+  (of-object "EmpathyThemeManager")
+  (c-name "empathy_theme_manager_update_show_avatars")
+  (return-type "none")
+  (parameters
+    '("EmpathyChatView*" "view")
+    '("gboolean" "show")
+  )
+)
+
+
+
+;; From empathy-ui-utils.h
+
+(define-function empathy_glade_get_file_simple
+  (c-name "empathy_glade_get_file_simple")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "filename")
+    '("const-gchar*" "root")
+    '("const-gchar*" "domain")
+    '("const-gchar*" "first_required_widget")
+  )
+  (varargs #t)
+)
+
+(define-function empathy_glade_get_file
+  (c-name "empathy_glade_get_file")
+  (return-type "GladeXML*")
+  (parameters
+    '("const-gchar*" "filename")
+    '("const-gchar*" "root")
+    '("const-gchar*" "domain")
+    '("const-gchar*" "first_required_widget")
+  )
+  (varargs #t)
+)
+
+(define-function empathy_glade_connect
+  (c-name "empathy_glade_connect")
+  (return-type "none")
+  (parameters
+    '("GladeXML*" "gui")
+    '("gpointer" "user_data")
+    '("gchar*" "first_widget")
+  )
+  (varargs #t)
+)
+
+(define-function empathy_glade_setup_size_group
+  (c-name "empathy_glade_setup_size_group")
+  (return-type "none")
+  (parameters
+    '("GladeXML*" "gui")
+    '("GtkSizeGroupMode" "mode")
+    '("gchar*" "first_widget")
+  )
+  (varargs #t)
+)
+
+(define-function empathy_pixbuf_from_icon_name
+  (c-name "empathy_pixbuf_from_icon_name")
+  (return-type "GdkPixbuf*")
+  (parameters
+    '("const-gchar*" "icon_name")
+    '("GtkIconSize" "icon_size")
+  )
+)
+
+(define-function empathy_pixbuf_from_smiley
+  (c-name "empathy_pixbuf_from_smiley")
+  (return-type "GdkPixbuf*")
+  (parameters
+    '("EmpathySmiley" "type")
+    '("GtkIconSize" "icon_size")
+  )
+)
+
+(define-function empathy_icon_name_from_account
+  (c-name "empathy_icon_name_from_account")
+  (return-type "const-gchar*")
+  (parameters
+    '("McAccount*" "account")
+  )
+)
+
+(define-function empathy_icon_name_for_presence_state
+  (c-name "empathy_icon_name_for_presence_state")
+  (return-type "const-gchar*")
+  (parameters
+    '("McPresence" "state")
+  )
+)
+
+(define-function empathy_icon_name_for_presence
+  (c-name "empathy_icon_name_for_presence")
+  (return-type "const-gchar*")
+  (parameters
+    '("EmpathyPresence*" "presence")
+  )
+)
+
+(define-function empathy_icon_name_for_contact
+  (c-name "empathy_icon_name_for_contact")
+  (return-type "const-gchar*")
+  (parameters
+    '("EmpathyContact*" "contact")
+  )
+)
+
+(define-function empathy_pixbuf_from_avatar_scaled
+  (c-name "empathy_pixbuf_from_avatar_scaled")
+  (return-type "GdkPixbuf*")
+  (parameters
+    '("EmpathyAvatar*" "avatar")
+    '("gint" "width")
+    '("gint" "height")
+  )
+)
+
+(define-function empathy_pixbuf_avatar_from_contact_scaled
+  (c-name "empathy_pixbuf_avatar_from_contact_scaled")
+  (return-type "GdkPixbuf*")
+  (parameters
+    '("EmpathyContact*" "contact")
+    '("gint" "width")
+    '("gint" "height")
+  )
+)
+
+(define-function empathy_text_iter_forward_search
+  (c-name "empathy_text_iter_forward_search")
+  (return-type "gboolean")
+  (parameters
+    '("const-GtkTextIter*" "iter")
+    '("const-gchar*" "str")
+    '("GtkTextIter*" "match_start")
+    '("GtkTextIter*" "match_end")
+    '("const-GtkTextIter*" "limit")
+  )
+)
+
+(define-function empathy_text_iter_backward_search
+  (c-name "empathy_text_iter_backward_search")
+  (return-type "gboolean")
+  (parameters
+    '("const-GtkTextIter*" "iter")
+    '("const-gchar*" "str")
+    '("GtkTextIter*" "match_start")
+    '("GtkTextIter*" "match_end")
+    '("const-GtkTextIter*" "limit")
+  )
+)
+
+(define-function empathy_window_get_is_visible
+  (c-name "empathy_window_get_is_visible")
+  (return-type "gboolean")
+  (parameters
+    '("GtkWindow*" "window")
+  )
+)
+
+(define-function empathy_window_present
+  (c-name "empathy_window_present")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "window")
+    '("gboolean" "steal_focus")
+  )
+)
+
+(define-function empathy_window_iconify
+  (c-name "empathy_window_iconify")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "window")
+    '("GtkStatusIcon*" "status_icon")
+  )
+)
+
+(define-function empathy_get_toplevel_window
+  (c-name "empathy_get_toplevel_window")
+  (return-type "GtkWindow*")
+  (parameters
+    '("GtkWidget*" "widget")
+  )
+)
+
+(define-function empathy_url_show
+  (c-name "empathy_url_show")
+  (return-type "none")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-function empathy_toggle_button_set_state_quietly
+  (c-name "empathy_toggle_button_set_state_quietly")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "widget")
+    '("GCallback" "callback")
+    '("gpointer" "user_data")
+    '("gboolean" "active")
+  )
+)
+
+(define-function empathy_link_button_new
+  (c-name "empathy_link_button_new")
+  (is-constructor-of "EmpathyLinkButton")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-gchar*" "url")
+    '("const-gchar*" "title")
+  )
+)
+
+
+
+;; From ephy-spinner.h
+
+(define-function ephy_spinner_get_type
+  (c-name "ephy_spinner_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_spinner_new
+  (c-name "ephy_spinner_new")
+  (is-constructor-of "EphySpinner")
+  (return-type "GtkWidget*")
+)
+
+(define-method start
+  (of-object "EphySpinner")
+  (c-name "ephy_spinner_start")
+  (return-type "none")
+)
+
+(define-method stop
+  (of-object "EphySpinner")
+  (c-name "ephy_spinner_stop")
+  (return-type "none")
+)
+
+(define-method set_size
+  (of-object "EphySpinner")
+  (c-name "ephy_spinner_set_size")
+  (return-type "none")
+  (parameters
+    '("GtkIconSize" "size")
+  )
+)
+
+
diff --git a/python/pyempathygtk/pyempathygtk.override b/python/pyempathygtk/pyempathygtk.override
new file mode 100644
index 00000000..8b3f22d5
--- /dev/null
+++ b/python/pyempathygtk/pyempathygtk.override
@@ -0,0 +1,77 @@
+%%
+headers
+#include <Python.h>
+#include <pygobject.h>
+#include "empathy-about-dialog.h"
+#include "empathy-account-chooser.h"
+#include "empathy-accounts-dialog.h"
+#include "empathy-account-widget-generic.h"
+#include "empathy-account-widget-jabber.h"
+#include "empathy-account-widget-msn.h"
+#include "empathy-cell-renderer-expander.h"
+#include "empathy-cell-renderer-text.h"
+#include "empathy-chat.h"
+#include "empathy-chatrooms-window.h"
+#include "empathy-chat-view.h"
+#include "empathy-chat-window.h"
+#include "empathy-contact-dialogs.h"
+#include "empathy-contact-groups.h"
+#include "empathy-contact-list-store.h"
+#include "empathy-contact-list-view.h"
+#include "empathy-contact-widget.h"
+#include "empathy-geometry.h"
+#include "empathy-group-chat.h"
+#include "empathy-images.h"
+#include "empathy-log-window.h"
+#include "empathy-main-window.h"
+#include "empathy-new-chatroom-dialog.h"
+#include "empathy-preferences.h"
+#include "empathy-presence-chooser.h"
+#include "empathy-private-chat.h"
+#include "empathy-profile-chooser.h"
+#include "empathy-spell-dialog.h"
+#include "empathy-spell.h"
+#include "empathy-status-icon.h"
+#include "empathy-status-presets.h"
+#include "empathy-theme-manager.h"
+#include "empathy-ui-utils.h"
+#include "ephy-spinner.h"
+
+/* FIXME */
+#define EMPATHY_TYPE_SMILEY 1
+#define EMPATHY_TYPE_CONTACT_LIST_STORE_COL 2
+#define EMPATHY_TYPE_CONTACT_LIST_STORE_SORT 3
+#define EMPATHY_TYPE_CONTACT_WIDGET_TYPE 4
+
+void empathy_add_constants(PyObject *module, const gchar *strip_prefix);
+void empathy_register_classes(PyObject *d);
+%%
+modulename empathygtk
+%%
+import gobject.GObject as PyGObject_Type
+import gtk.Widget as PyGtkWidget_Type
+import gtk.Window as PyGtkWindow_Type
+import gtk.CellRenderer as PyGtkCellRenderer_Type
+import gtk.CellRendererText as PyGtkCellRendererText_Type
+import gtk.TextView as PyGtkTextView_Type
+import gtk.TreeView as PyGtkTreeView_Type
+import gtk.TreeStore as PyGtkTreeStore_Type
+import gtk.ToggleButton as PyGtkToggleButton_Type
+import gtk.ComboBox as PyGtkComboBox_Type
+import gtk.StatusIcon as PyGtkStatusIcon_Type
+import empathy.Contact as PyEmpathyContact_Type
+import empathy.ContactList as PyEmpathyContactList_Type
+import empathy.TpChat as PyEmpathyTpChat_Type
+import empathy.Presence as PyEmpathyPresence_Type
+import empathy.Message as PyEmpathyMessage_Type
+%%
+ignore-glob
+	*_get_type
+%%
+ignore
+	empathy_chat_correct_word
+	empathy_chat_view_set_margin
+	empathy_chat_get_view
+	empathy_spell_dialog_show
+	empathy_window_iconify
+%%
diff --git a/python/pyempathygtk/pyempathygtkmodule.c b/python/pyempathygtk/pyempathygtkmodule.c
new file mode 100644
index 00000000..4f751f08
--- /dev/null
+++ b/python/pyempathygtk/pyempathygtkmodule.c
@@ -0,0 +1,23 @@
+#include <pygobject.h>
+
+void empathy_register_classes (PyObject *d);
+DL_EXPORT(void) initempathygtk(void);
+extern PyMethodDef empathy_functions[];
+
+DL_EXPORT(void) initempathygtk(void)
+{
+	PyObject *m, *d;
+
+	init_pygobject ();
+	
+	m = Py_InitModule ("empathygtk", empathy_functions);
+	d = PyModule_GetDict (m);
+	
+	empathy_register_classes (d);
+	
+	if (PyErr_Occurred ()) {
+		PyErr_Print();
+		Py_FatalError ("can't initialise module empathygtk");
+	}
+}
+