A README.Python A m4/.cvsignore: A m4/python.m4:

2005-05-21  Christian Persch  <chpe@cvs.gnome.org>

	* Makefile.am:
	* configure.ac:
	A README.Python
	A m4/.cvsignore:
	A m4/python.m4:
	* src/Makefile.am:
	* src/ephy-extensions-manager.c: (get_loader_for_type):
	A src/ephy-python-extension.c:
 	A src/ephy-python-extension.h:
	A src/ephy-python-loader.c:
	A src/ephy-python-loader.h:
	A src/ephy-python.c:
	A src/ephy-python.h:
	A src/epiphany.defs:
	A src/epiphany.override:

	Merge Pyphany.

10 files changed, 4263 insertions, 2 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index a2e21dad5..71f511843 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -2,6 +2,10 @@ SUBDIRS = bookmarks
 
 noinst_LTLIBRARIES = libephymain.la
 
+if ENABLE_PYTHON
+noinst_LTLIBRARIES += libpyphany.la
+endif
+
 bin_PROGRAMS = epiphany
 
 CXXLD = $(CXX)
@@ -61,7 +65,8 @@ INST_H_FILES = \
 	ephy-window.h
 
 libephymain_la_SOURCES = \
-	$(BUILT_SOURCES)		\
+	$(CORBA_SOURCE)			\
+	$(TYPES_SOURCE)			\
 	ephy-action-helper.c		\
 	ephy-automation.c		\
 	ephy-completion-model.c		\
@@ -120,6 +125,61 @@ if ENABLE_DBUS
 libephymain_la_CFLAGS += $(DBUS_CFLAGS)
 endif
 
+if ENABLE_PYTHON
+NOINST_H_FILES += \
+	ephy-python.h		\
+	ephy-python-extension.h	\
+	ephy-python-loader.h
+
+PYPHANY_SOURCE = epiphany.c
+
+libpyphany_la_SOURCES = \
+	ephy-python.c		\
+	ephy-python.h		\
+	ephy-python-extension.c	\
+	ephy-python-extension.h	\
+	ephy-python-loader.c	\
+	ephy-python-loader.h	\
+	$(PYPHANY_SOURCE)	\
+	$(TYPES_SOURCE)
+
+libpyphany_la_CPPFLAGS = \
+	-I$(top_srcdir)/lib		\
+	-I$(top_srcdir)/lib/widgets	\
+	-I$(top_srcdir)/lib/egg		\
+	-I$(top_srcdir)/embed		\
+	-I$(top_srcdir)/embed/mozilla	\
+	-I$(top_srcdir)/src		\
+	-I$(top_srcdir)/src/bookmarks	\
+	-I$(top_builddir)/lib		\
+	-I$(top_builddir)/lib/widgets	\
+	-I$(top_builddir)/lib/egg	\
+	-I$(top_builddir)/embed		\
+	-I$(top_builddir)/embed/mozilla	\
+	-I$(top_builddir)/src		\
+	-I$(top_builddir)/src/bookmarks	\
+	$(PYTHON_INCLUDES)		\
+	-DEXTENSIONS_DIR=\""$(libdir)/epiphany/$(EPIPHANY_MAJOR)/extensions"\" 	\
+	-DLOADER_DIR=\""$(libdir)/epiphany/$(EPIPHANY_MAJOR)/loaders"\"		\
+	-DDATADIR=\""$(datadir)"\" 	\
+	$(AM_CPPFLAGS)
+
+libpyphany_la_CFLAGS = \
+	$(EPIPHANY_DEPENDENCY_CFLAGS)	\
+	$(NO_STRICT_ALIASING_CFLAGS)	\
+	$(PYGTK_CFLAGS)			\
+	$(AM_CFLAGS)
+
+libpyphany_la_LDFLAGS = \
+	-export-symbols-regex ephy_python_init
+
+libpyphany_la_LIBADD = \
+	$(EPIPHANY_DEPENDENCY_LIBS)		\
+	$(PYTHON_LIB_LOC) $(PYTHON_LIBS)	\
+	$(PYTHON_EXTRA_LIBS)			\
+	$(PYGTK_LIBS)
+endif
+
 epiphany_SOURCES = ephy-main.c
 
 epiphany_CPPFLAGS = \
@@ -153,9 +213,26 @@ if ENABLE_DBUS
 epiphany_LDADD += $(DBUS_LIBS)
 endif
 
+if ENABLE_PYTHON
+epiphany_LDADD += \
+	libpyphany.la				\
+	$(PYTHON_LIB_LOC) $(PYTHON_LIBS)	\
+	$(PYTHON_EXTRA_LIBS)			\
+	$(PYGTK_LIBS)
+endif
+
+if ENABLE_PYTHON
+pydefsdir = $(datadir)/pygtk/2.0/defs
+pydefs_DATA = epiphany.defs
+
+EXTRA_DIST = \
+	$(pydefs_DATA)
+endif
+
 BUILT_SOURCES =	\
 	$(CORBA_SOURCE)	\
-	$(TYPES_SOURCE)
+	$(TYPES_SOURCE)	\
+	$(PYPHANY_SOURCE)
 
 TYPES_SOURCE = \
 	ephy-type-builtins.c	\
@@ -203,6 +280,16 @@ stamp-ephy-type-builtins.h: $(INST_H_FILES) $(NOINST_H_FILES)
 	&& rm -f xgen-$(@F) \
 	&& echo timestamp > $(@F)
 
+epiphany.c: epiphany.defs epiphany.override
+	( cd $(srcdir) && $(PYGTK_CODEGEN) \
+		--register $(PYGTK_DEFSDIR)/pango-types.defs \
+		--register $(PYGTK_DEFSDIR)/gdk-types.defs \
+		--register $(PYGTK_DEFSDIR)/gtk-types.defs \
+		--override $*.override \
+		--prefix py$* $(<F) ) > gen-$@ \
+	&& ( cmp -s gen-$@ $@ || cp gen-$@ $@ ) \
+	&& rm -f gen-$@
+
 CLEANFILES = $(stamp_files) $(BUILT_SOURCES)
 DISTCLEANFILES = $(stamp_files) $(BUILT_SOURCES)
 MAINTAINERCLEANFILES = $(stamp_files) $(BUILT_SOURCES)
diff --git a/src/ephy-extensions-manager.c b/src/ephy-extensions-manager.c
index 927d72fd8..f38a6ad43 100644
--- a/src/ephy-extensions-manager.c
+++ b/src/ephy-extensions-manager.c
@@ -52,6 +52,11 @@
 #include <libxml/xmlschemas.h>
 #endif
 
+#ifdef ENABLE_PYTHON
+#include "ephy-python-extension.h"
+#include "ephy-python-loader.h"
+#endif
+
 #define CONF_LOADED_EXTENSIONS	"/apps/epiphany/general/active_extensions"
 #define SCHEMA_FILE		"/epiphany-extension.xsd"
 
@@ -753,6 +758,19 @@ get_loader_for_type (EphyExtensionsManager *manager,
 
 		return g_object_ref (info->loader);
 	}
+#ifdef ENABLE_PYTHON
+	if (strcmp (type, "python") == 0)
+	{
+		info = g_new (LoaderInfo, 1);
+		info->type = g_strdup (type);
+		info->loader = g_object_new (EPHY_TYPE_PYTHON_LOADER, NULL);
+
+		manager->priv->factories =
+				g_list_append (manager->priv->factories, info);
+
+		return g_object_ref (info->loader);
+	}
+#endif
 
 	stype = sanitise_type (type);
 	name = g_strconcat ("lib", stype, "loader.", G_MODULE_SUFFIX, NULL);
diff --git a/src/ephy-python-extension.c b/src/ephy-python-extension.c
new file mode 100644
index 000000000..190327f73
--- /dev/null
+++ b/src/ephy-python-extension.c
@@ -0,0 +1,370 @@
+/*
+ *  Copyright (C) 2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
+ *  Copyright (C) 2004, 2005 Adam Hooper
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#include "Python.h"
+
+#include "config.h"
+
+#include "ephy-python-extension.h"
+
+#include <pygobject.h>
+
+#include "ephy-extension.h"
+#include "ephy-window.h"
+#include "ephy-tab.h"
+#include "ephy-file-helpers.h"
+#include "ephy-debug.h"
+
+#define EPHY_PYTHON_EXTENSION_GET_PRIVATE(object) (G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_PYTHON_EXTENSION, EphyPythonExtensionPrivate))
+
+struct _EphyPythonExtensionPrivate
+{
+	char *filename;
+	PyObject *module;
+};
+
+enum
+{
+	PROP_0,
+	PROP_FILENAME
+};
+
+static GObjectClass *parent_class = NULL;
+
+static int
+set_python_search_path (const char *filename)
+{
+	char *dirname;
+	char *dot_dir;
+	int ret = 2;
+	PyObject *sys_path;
+	PyObject *pValue;
+
+	sys_path = PySys_GetObject ("path");
+
+	/* Systems extensions dir */
+	pValue = PyString_FromString (EXTENSIONS_DIR);
+	PyList_Insert (sys_path, 0, pValue);
+	Py_DECREF (pValue);
+
+	/* Home dir */
+	dot_dir = g_strconcat (ephy_dot_dir (), "/extensions", NULL);
+	pValue = PyString_FromString (dot_dir);
+	PyList_Insert (sys_path, 0, pValue);
+	Py_DECREF (pValue);
+	g_free (dot_dir);
+
+	/* Absolute path specified in .xml file */
+	dirname = g_path_get_dirname (filename);
+	if (g_path_is_absolute (dirname))
+	{
+		pValue = PyString_FromString (dirname);
+		PyList_Insert (sys_path, 0, pValue);
+		Py_DECREF (pValue);
+		ret++;
+	}
+	g_free (dirname);
+
+	return ret;
+}
+
+static void
+unset_python_search_path (int num_dirs)
+{
+	PyObject *sys_path = PySys_GetObject ("path");
+
+	PySequence_DelSlice (sys_path, 0, num_dirs);
+}
+
+static void
+ephy_python_extension_init (EphyPythonExtension *extension)
+{
+	LOG ("EphyPythonExtension initialising");
+
+	extension->priv = EPHY_PYTHON_EXTENSION_GET_PRIVATE (extension);
+}
+
+static GObject *
+ephy_python_extension_constructor (GType type,
+				   guint n_construct_properties,
+				   GObjectConstructParam *construct_params)
+{
+	GObject *object;
+	EphyPythonExtension *ext;
+	char *module_name;	/* filename minus optional ".py" */
+				/* Note: could equally be a directory */
+	PyObject *pModules, *pModule, *pReload;
+			  
+	int num_temp_paths;
+
+	object = parent_class->constructor (type, n_construct_properties,
+					    construct_params);
+
+	ext = EPHY_PYTHON_EXTENSION (object);
+
+	module_name = g_path_get_basename (ext->priv->filename);
+
+	num_temp_paths = set_python_search_path (ext->priv->filename);
+
+	pModules = PySys_GetObject ("modules");
+	g_assert (pModules != NULL);
+
+	pModule = PyDict_GetItemString (pModules, module_name);
+
+	if (pModule == NULL)
+	{
+		pModule = PyImport_ImportModule (module_name);
+
+		if (pModule == NULL)
+		{
+			PyErr_Print ();
+			PyErr_Clear ();
+			g_warning ("Could not initialize Python module '%s'",
+				   module_name);
+		}
+	}
+	else
+	{
+		pReload = PyImport_ReloadModule (pModule);
+
+		if (pReload == NULL)
+		{
+			PyErr_Print ();
+			PyErr_Clear ();
+			g_warning ("Could not reload Python module '%s'\n"
+				   "Falling back to previous version",
+				   module_name);
+		}
+		else
+		{
+			Py_DECREF (pReload);
+		}
+	}
+
+	unset_python_search_path (num_temp_paths);
+
+	ext->priv->module = pModule;
+
+	g_free (module_name);
+
+	return object;
+}
+
+static void
+ephy_python_extension_finalize (GObject *object)
+{
+	EphyPythonExtension *extension =
+			EPHY_PYTHON_EXTENSION (object);
+
+	LOG ("EphyPythonExtension finalizing");
+
+	g_free (extension->priv->filename);
+	Py_XDECREF (extension->priv->module);
+
+	G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+call_python_func (EphyExtension *extension,
+		  const char *func_name,
+		  EphyWindow *window,
+		  EphyTab *tab) /* HACK: tab may be NULL */
+{
+	PyObject *pDict, *pFunc;
+	PyObject *pArgs, *pValue, *pTab = NULL, *pWindow;
+	EphyPythonExtension *py_ext;
+	
+	py_ext = EPHY_PYTHON_EXTENSION (extension);
+
+        /* Happens if the module load fails, e.g. python couldn't
+         * parse it, so be quiet about it, we will have already warned */
+        if (py_ext->priv->module == NULL)
+	{
+		return;
+	}
+
+	pDict = PyModule_GetDict (py_ext->priv->module);
+	pFunc = PyDict_GetItemString (pDict, func_name);
+
+	if (pFunc && PyCallable_Check (pFunc))
+	{
+		pArgs = PyTuple_New (tab == NULL ? 1 : 2);
+
+		pWindow = pygobject_new (G_OBJECT (window));
+		PyTuple_SetItem (pArgs, 0, pWindow);
+
+		if (tab != NULL)
+		{
+			pTab = pygobject_new (G_OBJECT (tab));
+			PyTuple_SetItem (pArgs, 1, pTab);
+		}
+
+		pValue = PyObject_CallObject (pFunc, pArgs);
+		if (pValue == NULL)
+		{
+			PyErr_Print ();
+			PyErr_Clear ();
+			g_warning ("Python code for '%s' failed to execute",
+				   func_name);
+		}
+		Py_XDECREF (pValue);
+		Py_DECREF (pArgs);
+	}
+	else
+	{
+		if (PyErr_Occurred ())
+		{
+			PyErr_Print ();
+			PyErr_Clear ();
+		}
+	}
+}
+
+static void
+impl_attach_tab (EphyExtension *extension,
+		 EphyWindow *window,
+		 EphyTab *tab)
+{
+	call_python_func (extension, "attach_tab", window, tab);
+}
+
+static void
+impl_detach_tab (EphyExtension *extension,
+		 EphyWindow *window,
+		 EphyTab *tab)
+{
+	call_python_func (extension, "detach_tab", window, tab);
+
+	g_idle_add ((GSourceFunc) PyGC_Collect, NULL);
+}
+
+static void
+impl_attach_window (EphyExtension *extension,
+		    EphyWindow *window)
+{
+	call_python_func (extension, "attach_window", window, NULL);
+}
+
+static void
+impl_detach_window (EphyExtension *extension,
+		    EphyWindow *window)
+{
+	call_python_func (extension, "detach_window", window, NULL);
+
+	g_idle_add ((GSourceFunc) PyGC_Collect, NULL);
+}
+
+static void
+ephy_python_extension_iface_init (EphyExtensionIface *iface)
+{
+	iface->attach_tab = impl_attach_tab;
+	iface->detach_tab = impl_detach_tab;
+	iface->attach_window = impl_attach_window;
+	iface->detach_window = impl_detach_window;
+}
+
+static void
+ephy_python_extension_get_property (GObject *object,
+				    guint prop_id,
+				    GValue *value,
+				    GParamSpec *pspec)
+{
+	/* no readable properties */
+	g_return_if_reached ();
+}
+
+static void
+ephy_python_extension_set_property (GObject *object,
+				    guint prop_id,
+				    const GValue *value,
+				    GParamSpec *pspec)
+{
+	EphyPythonExtension *ext = EPHY_PYTHON_EXTENSION (object);
+
+	switch (prop_id)
+	{
+		case PROP_FILENAME:
+			ext->priv->filename = g_value_dup_string (value);
+			break;
+		default:
+			g_return_if_reached ();
+	}
+}
+
+static void
+ephy_python_extension_class_init (EphyPythonExtensionClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	object_class->finalize = ephy_python_extension_finalize;
+	object_class->constructor = ephy_python_extension_constructor;
+	object_class->get_property = ephy_python_extension_get_property;
+	object_class->set_property = ephy_python_extension_set_property;
+
+	g_object_class_install_property
+			(object_class,
+			 PROP_FILENAME,
+			 g_param_spec_string ("filename",
+					      "Filename",
+					      "Filename",
+					      NULL,
+					      G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
+
+	g_type_class_add_private (object_class, sizeof (EphyPythonExtensionPrivate));
+}
+
+GType
+ephy_python_extension_get_type (void)
+{
+	static GType type = 0;
+
+	if (G_UNLIKELY (type == 0))
+	{
+		static const GTypeInfo our_info =
+		{
+			sizeof (EphyPythonExtensionClass),
+			NULL, /* base_init */
+			NULL, /* base_finalize */
+			(GClassInitFunc) ephy_python_extension_class_init,
+			NULL,
+			NULL, /* class_data */
+			sizeof (EphyPythonExtension),
+			0, /* n_preallocs */
+			(GInstanceInitFunc) ephy_python_extension_init
+		};
+		static const GInterfaceInfo extension_info =
+		{
+			(GInterfaceInitFunc) ephy_python_extension_iface_init,
+			NULL,
+			NULL
+		};
+
+		type = g_type_register_static (G_TYPE_OBJECT, "EphyPythonExtension",
+					       &our_info, 0);
+
+		g_type_add_interface_static (type, EPHY_TYPE_EXTENSION, &extension_info);
+	}
+
+	return type;
+}
diff --git a/src/ephy-python-extension.h b/src/ephy-python-extension.h
new file mode 100644
index 000000000..76cdc30a0
--- /dev/null
+++ b/src/ephy-python-extension.h
@@ -0,0 +1,59 @@
+/*
+ *  Copyright (C) 2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
+ *  Copyright (C) 2004, 2005 Adam Hooper
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#ifndef EPHY_PYTHON_EXTENSION_H
+#define EPHY_PYTHON_EXTENSION_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define EPHY_TYPE_PYTHON_EXTENSION		(ephy_python_extension_get_type ())
+#define EPHY_PYTHON_EXTENSION(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_PYTHON_EXTENSION, EphyPythonExtension))
+#define EPHY_PYTHON_EXTENSION_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_PYTHON_EXTENSION, EphyPythonExtensionClass))
+#define EPHY_IS_PYTHON_EXTENSION(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_PYTHON_EXTENSION))
+#define EPHY_IS_PYTHON_EXTENSION_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_PYTHON_EXTENSION))
+#define EPHY_PYTHON_EXTENSION_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), EPHY_TYPE_PYTHON_EXTENSION, EphyPythonExtensionClass))
+
+typedef struct _EphyPythonExtension		EphyPythonExtension;
+typedef struct _EphyPythonExtensionClass	EphyPythonExtensionClass;
+typedef struct _EphyPythonExtensionPrivate	EphyPythonExtensionPrivate;
+
+struct _EphyPythonExtensionClass
+{
+	GObjectClass parent_class;
+};
+
+struct _EphyPythonExtension
+{
+	GObject parent_instance;
+
+	/*< private >*/
+	EphyPythonExtensionPrivate *priv;
+};
+
+GType	ephy_python_extension_get_type		(void);
+
+G_END_DECLS
+
+#endif
diff --git a/src/ephy-python-loader.c b/src/ephy-python-loader.c
new file mode 100644
index 000000000..d376c39c5
--- /dev/null
+++ b/src/ephy-python-loader.c
@@ -0,0 +1,143 @@
+/*
+ *  Copyright (C) 2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003, 2004, 2005 Christian Persch
+ *  Copyright (C) 2004, 2005 Jean-François Rameau
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#include "config.h"
+
+#include "ephy-python-loader.h"
+#include "ephy-loader.h"
+#include "ephy-python.h"
+#include "ephy-python-extension.h"
+#include "ephy-debug.h"
+
+#define EPHY_PYTHON_LOADER_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_PYTHON_LOADER, EphyPythonLoaderPrivate))
+
+struct _EphyPythonLoaderPrivate
+{
+	gpointer dummy;
+};
+
+static GObjectClass *parent_class = NULL;
+
+static GObject *
+impl_get_object (EphyLoader *eloader,
+		 GData **attributes)
+{
+	char *filename;
+	GObject *object;
+
+	filename = g_datalist_get_data (attributes, "module");
+	if (filename == NULL)
+	{
+		g_warning ("NULL module name!\n");
+		return NULL;
+	}
+
+	object = g_object_new (EPHY_TYPE_PYTHON_EXTENSION,
+			       "filename", filename,
+			       NULL);
+
+	/* we own one ref */
+	return g_object_ref (object);
+}
+
+static void
+impl_release_object (EphyLoader *eloader,
+		     GObject *object)
+{
+	g_return_if_fail (object != NULL);
+
+	g_object_unref (object);
+}
+
+static void
+ephy_python_loader_iface_init (EphyLoaderIface *iface)
+{
+	iface->type = "python";
+	iface->get_object = impl_get_object;
+	iface->release_object = impl_release_object;
+}
+
+static void
+ephy_python_loader_init (EphyPythonLoader *loader)
+{
+	loader->priv = EPHY_PYTHON_LOADER_GET_PRIVATE (loader);
+
+	LOG ("EphyPythonLoader initialising");
+
+	/* Initialize Python engine */
+	ephy_python_init ();
+}
+
+static void
+ephy_python_loader_finalize (GObject *object)
+{
+	LOG ("EphyPythonLoader finalising");
+
+	parent_class->finalize (object);
+}
+
+static void
+ephy_python_loader_class_init (EphyPythonLoaderClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	object_class->finalize = ephy_python_loader_finalize;
+
+	g_type_class_add_private (object_class, sizeof (EphyPythonLoaderPrivate));
+}
+
+GType
+ephy_python_loader_get_type (void)
+{
+	static GType type = 0;
+
+	if (G_UNLIKELY (type == 0))
+	{
+		static const GTypeInfo our_info =
+		{
+			sizeof (EphyPythonLoaderClass),
+			NULL, /* base_init */
+			NULL, /* base_finalize */
+			(GClassInitFunc) ephy_python_loader_class_init,
+			NULL,
+			NULL, /* class_data */
+			sizeof (EphyPythonLoader),
+			0, /* n_preallocs */
+			(GInstanceInitFunc) ephy_python_loader_init
+		};
+		static const GInterfaceInfo loader_info =
+		{
+			(GInterfaceInitFunc) ephy_python_loader_iface_init,
+			NULL,
+			NULL
+		};
+
+		type = g_type_register_static (G_TYPE_OBJECT, "EphyPythonLoader",
+					       &our_info, 0);
+
+		g_type_add_interface_static (type, EPHY_TYPE_LOADER, &loader_info);
+	}
+
+	return type;
+}
diff --git a/src/ephy-python-loader.h b/src/ephy-python-loader.h
new file mode 100644
index 000000000..48e288f47
--- /dev/null
+++ b/src/ephy-python-loader.h
@@ -0,0 +1,59 @@
+/*
+ *  Copyright (C) 2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003, 2004, 2005 Christian Persch
+ *  Copyright (C) 2004, 2005 Jean-François Rameau
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#ifndef EPHY_PYTHON_LOADER_H
+#define EPHY_PYTHON_LOADER_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define EPHY_TYPE_PYTHON_LOADER		(ephy_python_loader_get_type ())
+#define EPHY_PYTHON_LOADER(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_PYTHON_LOADER, EphyPythonLoader))
+#define EPHY_PYTHON_LOADER_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_PYTHON_LOADER, EphyPythonLoaderClass))
+#define EPHY_IS_PYTHON_LOADER(o)	(G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_PYTHON_LOADER))
+#define EPHY_IS_PYTHON_LOADER_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_PYTHON_LOADER))
+#define EPHY_PYTHON_LOADER_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), EPHY_TYPE_PYTHON_LOADER, EphyPythonLoaderClass))
+
+typedef struct _EphyPythonLoader	EphyPythonLoader;
+typedef struct _EphyPythonLoaderClass	EphyPythonLoaderClass;
+typedef struct _EphyPythonLoaderPrivate	EphyPythonLoaderPrivate;
+
+struct _EphyPythonLoaderClass
+{
+	GObjectClass parent_class;
+};
+
+struct _EphyPythonLoader
+{
+	GObject parent_instance;
+
+	/*< private >*/
+	EphyPythonLoaderPrivate *priv;
+};
+
+GType	ephy_python_loader_get_type		(void);
+
+G_END_DECLS
+
+#endif /* !EPHY_PYTHON_LOADER_H */
diff --git a/src/ephy-python.c b/src/ephy-python.c
new file mode 100644
index 000000000..242d19330
--- /dev/null
+++ b/src/ephy-python.c
@@ -0,0 +1,57 @@
+/*
+ *  Copyright (C) 2004, 2005 Jean-François Rameau
+ *  Copyright (C) 2004, 2005 Adam Hooper
+ *  Copyright (C) 2004, 2005 Crispin Flowerday
+ *  Copyright (C) 2004, 2005 Christian Persch
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#include <Python.h>
+
+#include "config.h"
+
+#include "ephy-python.h"
+
+#include <pygobject.h>
+#include <pygtk/pygtk.h>
+
+void pyepiphany_register_classes (PyObject *d); 
+void pyepiphany_add_constants (PyObject *module, const gchar *strip_prefix);
+
+extern PyMethodDef pyepiphany_functions[];
+
+void
+ephy_python_init (void)
+{
+	char *argv[1];
+	PyObject *m, *d;
+	
+	Py_Initialize();
+
+	argv[0] = g_get_prgname ();
+	PySys_SetArgv (1, argv);
+
+	init_pygobject ();
+	init_pygtk ();
+
+	m = Py_InitModule ("epiphany", pyepiphany_functions);
+	d = PyModule_GetDict (m);
+
+	pyepiphany_register_classes (d);
+	pyepiphany_add_constants (m, "EPHY_");
+}
diff --git a/src/ephy-python.h b/src/ephy-python.h
new file mode 100644
index 000000000..48b6e3285
--- /dev/null
+++ b/src/ephy-python.h
@@ -0,0 +1,32 @@
+/*
+ *  Copyright (C) 2005 Christian Persch
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#ifndef EPHY_PYTHON_H
+#define EPHY_PYTHON_H
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+void ephy_python_init (void);
+
+G_END_DECLS
+
+#endif
diff --git a/src/epiphany.defs b/src/epiphany.defs
new file mode 100644
index 000000000..ea85c97c3
--- /dev/null
+++ b/src/epiphany.defs
@@ -0,0 +1,3044 @@
+;; -*- scheme -*-
+; object definitions ...
+(define-object Bookmarks
+  (in-module "Ephy")
+  (parent "GObject")
+  (c-name "EphyBookmarks")
+  (gtype-id "EPHY_TYPE_BOOKMARKS")
+)
+
+(define-interface CommandManager
+  (in-module "Ephy")
+  (c-name "EphyCommandManager")
+  (gtype-id "EPHY_TYPE_COMMAND_MANAGER")
+)
+
+(define-interface CookieManager
+  (in-module "Ephy")
+  (c-name "EphyCookieManager")
+  (gtype-id "EPHY_TYPE_COOKIE_MANAGER")
+)
+
+(define-object Dialog
+  (in-module "Ephy")
+  (parent "GObject")
+  (c-name "EphyDialog")
+  (gtype-id "EPHY_TYPE_DIALOG")
+)
+
+(define-interface Embed
+  (in-module "Ephy")
+  (c-name "EphyEmbed")
+  (gtype-id "EPHY_TYPE_EMBED")
+)
+
+(define-interface EmbedEvent
+  (in-module "Ephy")
+  (c-name "EphyEmbedEvent")
+  (gtype-id "EPHY_TYPE_EMBED_EVENT")
+)
+
+(define-object EmbedPersist
+  (in-module "Ephy")
+  (parent "GObject")
+  (c-name "EphyEmbedPersist")
+  (gtype-id "EPHY_TYPE_EMBED_PERSIST")
+)
+
+(define-object EmbedShell
+  (in-module "Ephy")
+  (parent "GObject")
+  (c-name "EphyEmbedShell")
+  (gtype-id "EPHY_TYPE_EMBED_SHELL")
+)
+
+(define-interface EmbedSingle
+  (in-module "Ephy")
+  (c-name "EphyEmbedSingle")
+  (gtype-id "EPHY_TYPE_EMBED_SINGLE")
+)
+
+(define-interface Extension
+  (in-module "Ephy")
+  (c-name "EphyExtension")
+  (gtype-id "EPHY_TYPE_EXTENSION")
+)
+
+(define-object ExtensionsManager
+  (in-module "Ephy")
+  (parent "GObject")
+  (c-name "EphyExtensionsManager")
+  (gtype-id "EPHY_TYPE_EXTENSIONS_MANAGER")
+)
+
+(define-object History
+  (in-module "Ephy")
+  (parent "GObject")
+  (c-name "EphyHistory")
+  (gtype-id "EPHY_TYPE_HISTORY")
+)
+
+(define-object Link
+  (in-module "Ephy")
+  (c-name "EphyLink")
+  (gtype-id "EPHY_TYPE_LINK")
+)
+
+(define-interface Loader
+  (in-module "Ephy")
+  (c-name "EphyLoader")
+  (gtype-id "EPHY_TYPE_LOADER")
+)
+
+(define-object NodeDb
+  (in-module "Ephy")
+  (parent "GObject")
+  (c-name "EphyNodeDb")
+  (gtype-id "EPHY_TYPE_NODE_DB")
+)
+
+(define-object Notebook
+  (in-module "Ephy")
+  (parent "GtkNotebook")
+  (c-name "EphyNotebook")
+  (gtype-id "EPHY_TYPE_NOTEBOOK")
+)
+
+(define-interface PasswordManager
+  (in-module "Ephy")
+  (c-name "EphyPasswordManager")
+  (gtype-id "EPHY_TYPE_PASSWORD_MANAGER")
+)
+
+(define-interface PermissionManager
+  (in-module "Ephy")
+  (c-name "EphyPermissionManager")
+  (gtype-id "EPHY_TYPE_PERMISSION_MANAGER")
+)
+
+(define-object Session
+  (in-module "Ephy")
+  (parent "GObject")
+  (c-name "EphySession")
+  (gtype-id "EPHY_TYPE_SESSION")
+)
+
+(define-object Shell
+  (in-module "Ephy")
+  (parent "EphyEmbedShell")
+  (c-name "EphyShell")
+  (gtype-id "EPHY_TYPE_SHELL")
+)
+
+(define-object Statusbar
+  (in-module "Ephy")
+  (parent "GtkStatusbar")
+  (c-name "EphyStatusbar")
+  (gtype-id "EPHY_TYPE_STATUSBAR")
+  (fields
+    '("GtkTooltips*" "tooltips")
+  )
+)
+
+(define-object Tab
+  (in-module "Ephy")
+  (parent "GtkBin")
+  (c-name "EphyTab")
+  (gtype-id "EPHY_TYPE_TAB")
+)
+
+(define-object Window
+  (in-module "Ephy")
+  (parent "GtkWindow")
+  (c-name "EphyWindow")
+  (gtype-id "EPHY_TYPE_WINDOW")
+)
+
+;; Boxed types ...
+
+(define-boxed Cookie
+  (in-module "Ephy")
+  (c-name "EphyCookie")
+  (gtype-id "EPHY_TYPE_COOKIE")
+  (fields
+    '("char*" "name")
+    '("char*" "value")
+    '("char*" "domain")
+    '("char*" "path")
+    '("gulong" "expires")
+    '("glong" "real_expires")
+    '("guint" "is_secure")
+    '("guint" "is_session")
+  )
+)
+
+(define-boxed PasswordInfo
+  (in-module "Ephy")
+  (c-name "EphyPasswordInfo")
+  (gtype-id  "EPHY_TYPE_PASSWORD_INFO")
+  (copy_func "ephy_password_info_copy")
+  (release-func "ephy_password_info_free")
+  (fields
+    '("char*" "host")
+    '("char*" "username")
+    '("char*" "password")
+  )
+)
+
+(define-boxed Node
+  (in-module "Ephy")
+  (c-name "EphyNode")
+  (gtype-id "EPHY_TYPE_NODE")
+)
+
+;; Enumerations and flags ...
+
+(define-enum BookmarkProperty
+  (in-module "Ephy")
+  (c-name "EphyBookmarkProperty")
+  (gtype-id "EPHY_TYPE_BOOKMARK_PROPERTY")
+  (values
+    '("bmk-prop-title" "EPHY_NODE_BMK_PROP_TITLE")
+    '("bmk-prop-location" "EPHY_NODE_BMK_PROP_LOCATION")
+    '("bmk-prop-keywords" "EPHY_NODE_BMK_PROP_KEYWORDS")
+    '("keyword-prop-name" "EPHY_NODE_KEYWORD_PROP_NAME")
+    '("bmk-prop-icon" "EPHY_NODE_BMK_PROP_ICON")
+    '("keyword-prop-priority" "EPHY_NODE_KEYWORD_PROP_PRIORITY")
+  )
+)
+
+;;(define-enum DialogApplyType
+;;  (in-module "Ephy")
+;;  (c-name "EphyDialogApplyType")
+;;  (gtype-id "EPHY_TYPE_DIALOG_APPLY_TYPE")
+;;  (values
+;;    '("normal" "PT_NORMAL")
+;;    '("autoapply" "PT_AUTOAPPLY")
+;;  )
+;;)
+
+(define-flags EmbedEventContext
+  (in-module "Ephy")
+  (c-name "EphyEmbedEventContext")
+  (gtype-id "EPHY_TYPE_EMBED_EVENT_CONTEXT")
+  (values
+    '("none" "EPHY_EMBED_CONTEXT_NONE")
+    '("default" "EPHY_EMBED_CONTEXT_DEFAULT")
+    '("link" "EPHY_EMBED_CONTEXT_LINK")
+    '("image" "EPHY_EMBED_CONTEXT_IMAGE")
+    '("document" "EPHY_EMBED_CONTEXT_DOCUMENT")
+    '("input" "EPHY_EMBED_CONTEXT_INPUT")
+    '("input-password" "EPHY_EMBED_CONTEXT_INPUT_PASSWORD")
+    '("xul" "EPHY_EMBED_CONTEXT_XUL")
+    '("email-link" "EPHY_EMBED_CONTEXT_EMAIL_LINK")
+  )
+)
+
+(define-flags EmbedNetState
+  (in-module "Ephy")
+  (c-name "EphyEmbedNetState")
+  (gtype-id "EPHY_TYPE_EMBED_NET_STATE")
+  (values
+    '("unknown" "EPHY_EMBED_STATE_UNKNOWN")
+    '("start" "EPHY_EMBED_STATE_START")
+    '("redirecting" "EPHY_EMBED_STATE_REDIRECTING")
+    '("transferring" "EPHY_EMBED_STATE_TRANSFERRING")
+    '("negotiating" "EPHY_EMBED_STATE_NEGOTIATING")
+    '("stop" "EPHY_EMBED_STATE_STOP")
+    '("is-request" "EPHY_EMBED_STATE_IS_REQUEST")
+    '("is-document" "EPHY_EMBED_STATE_IS_DOCUMENT")
+    '("is-network" "EPHY_EMBED_STATE_IS_NETWORK")
+    '("is-window" "EPHY_EMBED_STATE_IS_WINDOW")
+  )
+)
+
+(define-flags EmbedChrome
+  (in-module "Ephy")
+  (c-name "EphyEmbedChrome")
+  (gtype-id "EPHY_TYPE_EMBED_CHROME")
+  (values
+    '("menubar" "EPHY_EMBED_CHROME_MENUBAR")
+    '("toolbar" "EPHY_EMBED_CHROME_TOOLBAR")
+    '("statusbar" "EPHY_EMBED_CHROME_STATUSBAR")
+    '("bookmarksbar" "EPHY_EMBED_CHROME_BOOKMARKSBAR")
+  )
+)
+
+(define-enum EmbedPrintPreviewNavType
+  (in-module "Ephy")
+  (c-name "EphyEmbedPrintPreviewNavType")
+  (gtype-id "EPHY_TYPE_EMBED_PRINT_PREVIEW_NAV_TYPE")
+  (values
+    '("goto-pagenum" "EPHY_EMBED_PRINTPREVIEW_GOTO_PAGENUM")
+    '("prev-page" "EPHY_EMBED_PRINTPREVIEW_PREV_PAGE")
+    '("next-page" "EPHY_EMBED_PRINTPREVIEW_NEXT_PAGE")
+    '("home" "EPHY_EMBED_PRINTPREVIEW_HOME")
+    '("end" "EPHY_EMBED_PRINTPREVIEW_END")
+  )
+)
+
+(define-enum EmbedSecurityLevel
+  (in-module "Ephy")
+  (c-name "EphyEmbedSecurityLevel")
+  (gtype-id "EPHY_TYPE_EMBED_SECURITY_LEVEL")
+  (values
+    '("unknown" "EPHY_EMBED_STATE_IS_UNKNOWN")
+    '("insecure" "EPHY_EMBED_STATE_IS_INSECURE")
+    '("broken" "EPHY_EMBED_STATE_IS_BROKEN")
+    '("secure-low" "EPHY_EMBED_STATE_IS_SECURE_LOW")
+    '("secure-med" "EPHY_EMBED_STATE_IS_SECURE_MED")
+    '("secure-high" "EPHY_EMBED_STATE_IS_SECURE_HIGH")
+  )
+)
+
+(define-enum EmbedDocumentType
+  (in-module "Ephy")
+  (c-name "EphyEmbedDocumentType")
+  (gtype-id "EPHY_TYPE_EMBED_DOCUMENT_TYPE")
+  (values
+    '("html" "EPHY_EMBED_DOCUMENT_HTML")
+    '("xml" "EPHY_EMBED_DOCUMENT_XML")
+    '("image" "EPHY_EMBED_DOCUMENT_IMAGE")
+    '("other" "EPHY_EMBED_DOCUMENT_OTHER")
+  )
+)
+
+(define-flags EmbedPersistFlags
+  (in-module "Ephy")
+  (c-name "EphyEmbedPersistFlags")
+  (gtype-id "EPHY_TYPE_EMBED_PERSIST_FLAGS")
+  (values
+    '("copy-page" "EPHY_EMBED_PERSIST_COPY_PAGE")
+    '("maindoc" "EPHY_EMBED_PERSIST_MAINDOC")
+    '("no-view" "EPHY_EMBED_PERSIST_NO_VIEW")
+    '("ask-destination" "EPHY_EMBED_PERSIST_ASK_DESTINATION")
+    '("do-conversion" "EPHY_EMBED_PERSIST_DO_CONVERSION")
+  )
+)
+
+(define-enum ContentCheckType
+  (in-module "Ephy")
+  (c-name "EphyContentCheckType")
+  (gtype-id "EPHY_TYPE_CONTENT_CHECK_TYPE")
+  (values
+    '("other" "EPHY_CONTENT_CHECK_TYPE_OTHER")
+    '("script" "EPHY_CONTENT_CHECK_TYPE_SCRIPT")
+    '("image" "EPHY_CONTENT_CHECK_TYPE_IMAGE")
+    '("stylesheet" "EPHY_CONTENT_CHECK_TYPE_STYLESHEET")
+    '("object" "EPHY_CONTENT_CHECK_TYPE_OBJECT")
+    '("document" "EPHY_CONTENT_CHECK_TYPE_DOCUMENT")
+    '("subdocument" "EPHY_CONTENT_CHECK_TYPE_SUBDOCUMENT")
+    '("refresh" "EPHY_CONTENT_CHECK_TYPE_REFRESH")
+  )
+)
+
+(define-flags LinkFlags
+  (in-module "Ephy")
+  (c-name "EphyLinkFlags")
+  (gtype-id "EPHY_TYPE_LINK_FLAGS")
+  (values
+    '("new-window" "EPHY_LINK_NEW_WINDOW")
+    '("new-tab" "EPHY_LINK_NEW_TAB")
+    '("jump-to" "EPHY_LINK_JUMP_TO")
+  )
+)
+
+(define-enum NodeSignalType
+  (in-module "Ephy")
+  (c-name "EphyNodeSignalType")
+  (gtype-id "EPHY_TYPE_NODE_SIGNAL_TYPE")
+  (values
+    '("destroy" "EPHY_NODE_DESTROY")
+    '("restored" "EPHY_NODE_RESTORED")
+    '("changed" "EPHY_NODE_CHANGED")
+    '("child-added" "EPHY_NODE_CHILD_ADDED")
+    '("child-changed" "EPHY_NODE_CHILD_CHANGED")
+    '("child-removed" "EPHY_NODE_CHILD_REMOVED")
+    '("children-reordered" "EPHY_NODE_CHILDREN_REORDERED")
+  )
+)
+
+(define-enum Permission
+  (in-module "Ephy")
+  (c-name "EphyPermission")
+  (gtype-id "EPHY_TYPE_PERMISSION")
+  (values
+    '("allowed" "EPHY_PERMISSION_ALLOWED")
+    '("denied" "EPHY_PERMISSION_DENIED")
+    '("default" "EPHY_PERMISSION_DEFAULT")
+  )
+)
+
+(define-enum ShellError
+  (in-module "Ephy")
+  (c-name "EphyShellError")
+  (gtype-id "EPHY_TYPE_SHELL_ERROR")
+  (values
+    '("missing-server" "EPHY_SHELL_ERROR_MISSING_SERVER")
+    '("object-reg-failed" "EPHY_SHELL_ERROR_OBJECT_REG_FAILED")
+    '("factory-reg-failed" "EPHY_SHELL_ERROR_FACTORY_REG_FAILED")
+  )
+)
+
+(define-flags ShellStartupFlags
+  (in-module "Ephy")
+  (c-name "EphyShellStartupFlags")
+  (gtype-id "EPHY_TYPE_SHELL_STARTUP_FLAGS")
+  (values
+    '("tabs" "EPHY_SHELL_STARTUP_TABS")
+    '("existing-window" "EPHY_SHELL_STARTUP_EXISTING_WINDOW")
+    '("fullscreen" "EPHY_SHELL_STARTUP_FULLSCREEN")
+    '("bookmarks-editor" "EPHY_SHELL_STARTUP_BOOKMARKS_EDITOR")
+    '("session" "EPHY_SHELL_STARTUP_SESSION")
+    '("import-bookmarks" "EPHY_SHELL_STARTUP_IMPORT_BOOKMARKS")
+    '("add-bookmark" "EPHY_SHELL_STARTUP_ADD_BOOKMARK")
+  )
+)
+
+(define-flags NewTabFlags
+  (in-module "Ephy")
+  (c-name "EphyNewTabFlags")
+  (gtype-id "EPHY_TYPE_NEW_TAB_FLAGS")
+  (values
+    '("home-page" "EPHY_NEW_TAB_HOME_PAGE")
+    '("new-page" "EPHY_NEW_TAB_NEW_PAGE")
+    '("open-page" "EPHY_NEW_TAB_OPEN_PAGE")
+    '("fullscreen-mode" "EPHY_NEW_TAB_FULLSCREEN_MODE")
+    '("dont-show-window" "EPHY_NEW_TAB_DONT_SHOW_WINDOW")
+    '("append-last" "EPHY_NEW_TAB_APPEND_LAST")
+    '("append-after" "EPHY_NEW_TAB_APPEND_AFTER")
+    '("jump" "EPHY_NEW_TAB_JUMP")
+    '("in-new-window" "EPHY_NEW_TAB_IN_NEW_WINDOW")
+    '("in-existing-window" "EPHY_NEW_TAB_IN_EXISTING_WINDOW")
+  )
+)
+
+(define-flags StateWindowFlags
+  (in-module "Ephy")
+  (c-name "EphyStateWindowFlags")
+  (gtype-id "EPHY_TYPE_STATE_WINDOW_FLAGS")
+  (values
+    '("none" "EPHY_STATE_WINDOW_SAVE_NONE")
+    '("size" "EPHY_STATE_WINDOW_SAVE_SIZE")
+    '("position" "EPHY_STATE_WINDOW_SAVE_POSITION")
+  )
+)
+
+(define-flags TabNavigationFlags
+  (in-module "Ephy")
+  (c-name "EphyTabNavigationFlags")
+  (gtype-id "EPHY_TYPE_TAB_NAVIGATION_FLAGS")
+  (values
+    '("up" "EPHY_TAB_NAV_UP")
+    '("back" "EPHY_TAB_NAV_BACK")
+    '("forward" "EPHY_TAB_NAV_FORWARD")
+  )
+)
+
+(define-enum TabAddressExpire
+  (in-module "Ephy")
+  (c-name "EphyTabAddressExpire")
+  (gtype-id "EPHY_TYPE_TAB_ADDRESS_EXPIRE")
+  (values
+    '("now" "EPHY_TAB_ADDRESS_EXPIRE_NOW")
+    '("next" "EPHY_TAB_ADDRESS_EXPIRE_NEXT")
+    '("current" "EPHY_TAB_ADDRESS_EXPIRE_CURRENT")
+  )
+)
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-bookmarks.h
+
+(define-function ephy_bookmarks_get_type
+  (c-name "ephy_bookmarks_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_bookmarks_new
+  (c-name "ephy_bookmarks_new")
+  (is-constructor-of "EphyBookmarks")
+  (return-type "EphyBookmarks*")
+)
+
+(define-method get_from_id
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_get_from_id")
+  (return-type "EphyNode*")
+  (parameters
+    '("long" "id")
+  )
+)
+
+(define-method get_toolbars_model
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_get_toolbars_model")
+  (return-type "GObject*")
+)
+
+(define-method add
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_add")
+  (return-type "EphyNode*")
+  (parameters
+    '("const-char*" "title")
+    '("const-char*" "url")
+  )
+)
+
+(define-method find_bookmark
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_find_bookmark")
+  (return-type "EphyNode*")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-method set_icon
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_set_icon")
+  (return-type "none")
+  (parameters
+    '("const-char*" "url")
+    '("const-char*" "icon")
+  )
+)
+
+(define-method set_address
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_set_address")
+  (return-type "none")
+  (parameters
+    '("EphyNode*" "bookmark")
+    '("const-char*" "address")
+  )
+)
+
+(define-method solve_smart_url
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_solve_smart_url")
+  (return-type "char*")
+  (parameters
+    '("const-char*" "smart_url")
+    '("const-char*" "content")
+  )
+)
+
+(define-method show_bookmark_properties
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_show_bookmark_properties")
+  (return-type "GtkWidget*")
+  (parameters
+    '("EphyNode*" "bookmark")
+    '("GtkWidget*" "parent_window")
+  )
+)
+
+(define-method add_keyword
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_add_keyword")
+  (return-type "EphyNode*")
+  (parameters
+    '("const-char*" "name")
+  )
+)
+
+(define-method find_keyword
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_find_keyword")
+  (return-type "EphyNode*")
+  (parameters
+    '("const-char*" "name")
+    '("gboolean" "partial_match")
+  )
+)
+
+(define-method remove_keyword
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_remove_keyword")
+  (return-type "none")
+  (parameters
+    '("EphyNode*" "keyword")
+  )
+)
+
+(define-method has_keyword
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_has_keyword")
+  (return-type "gboolean")
+  (parameters
+    '("EphyNode*" "keyword")
+    '("EphyNode*" "bookmark")
+  )
+)
+
+(define-method set_keyword
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_set_keyword")
+  (return-type "none")
+  (parameters
+    '("EphyNode*" "keyword")
+    '("EphyNode*" "bookmark")
+  )
+)
+
+(define-method unset_keyword
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_unset_keyword")
+  (return-type "none")
+  (parameters
+    '("EphyNode*" "keyword")
+    '("EphyNode*" "bookmark")
+  )
+)
+
+(define-method get_topic_uri
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_get_topic_uri")
+  (return-type "char*")
+  (parameters
+    '("EphyNode*" "node")
+  )
+)
+
+(define-method get_favorites
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_get_favorites")
+  (return-type "EphyNode*")
+)
+
+(define-method get_keywords
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_get_keywords")
+  (return-type "EphyNode*")
+)
+
+(define-method get_bookmarks
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_get_bookmarks")
+  (return-type "EphyNode*")
+)
+
+(define-method get_not_categorized
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_get_not_categorized")
+  (return-type "EphyNode*")
+)
+
+(define-method get_smart_bookmarks
+  (of-object "EphyBookmarks")
+  (c-name "ephy_bookmarks_get_smart_bookmarks")
+  (return-type "EphyNode*")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-bookmarks-type-builtins.h
+
+(define-function ephy_bookmark_property_get_type
+  (c-name "ephy_bookmark_property_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-command-manager.h
+
+(define-function ephy_command_manager_get_type
+  (c-name "ephy_command_manager_get_type")
+  (return-type "GType")
+)
+
+(define-method do_command
+  (of-object "EphyCommandManager")
+  (c-name "ephy_command_manager_do_command")
+  (return-type "none")
+  (parameters
+    '("const-char*" "command")
+  )
+)
+
+(define-method can_do_command
+  (of-object "EphyCommandManager")
+  (c-name "ephy_command_manager_can_do_command")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "command")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-cookie-manager.h
+
+(define-function ephy_cookie_get_type
+  (c-name "ephy_cookie_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_cookie_new
+  (c-name "ephy_cookie_new")
+  (is-constructor-of "EphyCookie")
+  (return-type "EphyCookie*")
+)
+
+(define-method copy
+  (of-object "EphyCookie")
+  (c-name "ephy_cookie_copy")
+  (return-type "EphyCookie*")
+)
+
+(define-method free
+  (of-object "EphyCookie")
+  (c-name "ephy_cookie_free")
+  (return-type "none")
+)
+
+(define-function ephy_cookie_manager_get_type
+  (c-name "ephy_cookie_manager_get_type")
+  (return-type "GType")
+)
+
+(define-method list_cookies
+  (of-object "EphyCookieManager")
+  (c-name "ephy_cookie_manager_list_cookies")
+  (return-type "GList*")
+)
+
+(define-method remove_cookie
+  (of-object "EphyCookieManager")
+  (c-name "ephy_cookie_manager_remove_cookie")
+  (return-type "none")
+  (parameters
+    '("const-EphyCookie*" "cookie")
+  )
+)
+
+(define-method clear
+  (of-object "EphyCookieManager")
+  (c-name "ephy_cookie_manager_clear")
+  (return-type "none")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-dialog.h
+
+(define-function ephy_dialog_get_type
+  (c-name "ephy_dialog_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_dialog_new
+  (c-name "ephy_dialog_new")
+  (is-constructor-of "EphyDialog")
+  (return-type "EphyDialog*")
+)
+
+(define-function ephy_dialog_new_with_parent
+  (c-name "ephy_dialog_new_with_parent")
+  (is-constructor-of "EphyDialog")
+  (return-type "EphyDialog*")
+  (parameters
+    '("GtkWidget*" "parent_window")
+  )
+)
+
+(define-method construct
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_construct")
+  (return-type "none")
+  (parameters
+    '("const-EphyDialogProperty*" "properties")
+    '("const-char*" "file")
+    '("const-char*" "name")
+    '("const-char*" "domain")
+  )
+)
+
+(define-method add_enum
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_add_enum")
+  (return-type "none")
+  (parameters
+    '("const-char*" "id")
+    '("guint" "n_items")
+    '("const-char**" "items")
+  )
+)
+
+(define-method set_data_column
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_set_data_column")
+  (return-type "none")
+  (parameters
+    '("const-char*" "id")
+    '("int" "col")
+  )
+)
+
+(define-method set_size_group
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_set_size_group")
+  (return-type "none")
+  (parameters
+    '("const-char*" "first_id")
+  )
+  (varargs #t)
+)
+
+(define-method run
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_run")
+  (return-type "int")
+)
+
+(define-method show
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_show")
+  (return-type "none")
+)
+
+(define-method hide
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_hide")
+  (return-type "none")
+)
+
+(define-method set_parent
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_set_parent")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "parent")
+  )
+)
+
+(define-method get_parent
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_get_parent")
+  (return-type "GtkWidget*")
+)
+
+(define-method set_modal
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_set_modal")
+  (return-type "none")
+  (parameters
+    '("gboolean" "is_modal")
+  )
+)
+
+(define-method get_control
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_get_control")
+  (return-type "GtkWidget*")
+  (parameters
+    '("const-char*" "property_id")
+  )
+)
+
+(define-method get_controls
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_get_controls")
+  (return-type "none")
+  (parameters
+    '("const-char*" "first_property_id")
+  )
+  (varargs #t)
+)
+
+(define-method get_value
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_get_value")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "property_id")
+    '("GValue*" "value")
+  )
+)
+
+(define-method set_value
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_set_value")
+  (return-type "none")
+  (parameters
+    '("const-char*" "property_id")
+    '("const-GValue*" "value")
+  )
+)
+
+(define-method set_pref
+  (of-object "EphyDialog")
+  (c-name "ephy_dialog_set_pref")
+  (return-type "none")
+  (parameters
+    '("const-char*" "property_id")
+    '("const-char*" "pref")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-embed-event.h
+
+(define-function ephy_embed_event_get_type
+  (c-name "ephy_embed_event_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_event_context_get_type
+  (c-name "ephy_embed_event_context_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_event_type_get_type
+  (c-name "ephy_embed_event_type_get_type")
+  (return-type "GType")
+)
+
+(define-method get_context
+  (of-object "EphyEmbedEvent")
+  (c-name "ephy_embed_event_get_context")
+  (return-type "EphyEmbedEventContext")
+)
+
+(define-method get_button
+  (of-object "EphyEmbedEvent")
+  (c-name "ephy_embed_event_get_button")
+  (return-type "guint")
+)
+
+(define-method get_modifier
+  (of-object "EphyEmbedEvent")
+  (c-name "ephy_embed_event_get_modifier")
+  (return-type "guint")
+)
+
+(define-method get_coords
+  (of-object "EphyEmbedEvent")
+  (c-name "ephy_embed_event_get_coords")
+  (return-type "none")
+  (parameters
+    '("guint*" "x")
+    '("guint*" "y")
+  )
+)
+
+(define-method get_property
+  (of-object "EphyEmbedEvent")
+  (c-name "ephy_embed_event_get_property")
+  (return-type "none")
+  (parameters
+    '("const-char*" "name")
+    '("const-GValue**" "value")
+  )
+)
+
+(define-method has_property
+  (of-object "EphyEmbedEvent")
+  (c-name "ephy_embed_event_has_property")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "name")
+  )
+)
+
+(define-method get_dom_event
+  (of-object "EphyEmbedEvent")
+  (c-name "ephy_embed_event_get_dom_event")
+  (return-type "gpointer")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-embed-factory.h
+
+(define-function ephy_embed_factory_new_object
+  (c-name "ephy_embed_factory_new_object")
+  (return-type "GObject*")
+  (parameters
+    '("GType" "type")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-embed.h
+
+(define-function ephy_embed_net_state_get_type
+  (c-name "ephy_embed_net_state_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_chrome_get_type
+  (c-name "ephy_embed_chrome_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_ppv_navigation_get_type
+  (c-name "ephy_embed_ppv_navigation_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_security_level_get_type
+  (c-name "ephy_embed_security_level_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_document_type_get_type
+  (c-name "ephy_embed_document_type_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_get_type
+  (c-name "ephy_embed_get_type")
+  (return-type "GType")
+)
+
+(define-method load_url
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_load_url")
+  (return-type "none")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-method stop_load
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_stop_load")
+  (return-type "none")
+)
+
+(define-method reload
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_reload")
+  (return-type "none")
+  (parameters
+    '("gboolean" "force")
+  )
+)
+
+(define-method get_title
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_get_title")
+  (return-type "char*")
+)
+
+(define-method get_location
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_get_location")
+  (return-type "char*")
+  (parameters
+    '("gboolean" "toplevel")
+  )
+)
+
+(define-method get_link_message
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_get_link_message")
+  (return-type "char*")
+)
+
+(define-method get_js_status
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_get_js_status")
+  (return-type "char*")
+)
+
+(define-method can_go_back
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_can_go_back")
+  (return-type "gboolean")
+)
+
+(define-method can_go_forward
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_can_go_forward")
+  (return-type "gboolean")
+)
+
+(define-method can_go_up
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_can_go_up")
+  (return-type "gboolean")
+)
+
+(define-method get_go_up_list
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_get_go_up_list")
+  (return-type "GSList*")
+)
+
+(define-method go_back
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_go_back")
+  (return-type "none")
+)
+
+(define-method go_forward
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_go_forward")
+  (return-type "none")
+)
+
+(define-method go_up
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_go_up")
+  (return-type "none")
+)
+
+(define-method shistory_n_items
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_shistory_n_items")
+  (return-type "int")
+)
+
+(define-method shistory_get_nth
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_shistory_get_nth")
+  (return-type "none")
+  (parameters
+    '("int" "nth")
+    '("gboolean" "is_relative")
+    '("char**" "url")
+    '("char**" "title")
+  )
+)
+
+(define-method shistory_get_pos
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_shistory_get_pos")
+  (return-type "int")
+)
+
+(define-method shistory_go_nth
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_shistory_go_nth")
+  (return-type "none")
+  (parameters
+    '("int" "nth")
+  )
+)
+
+(define-method get_security_level
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_get_security_level")
+  (return-type "none")
+  (parameters
+    '("EphyEmbedSecurityLevel*" "level")
+    '("char**" "description")
+  )
+)
+
+(define-method show_page_certificate
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_show_page_certificate")
+  (return-type "none")
+)
+
+(define-method set_zoom
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_set_zoom")
+  (return-type "none")
+  (parameters
+    '("float" "zoom")
+  )
+)
+
+(define-method get_zoom
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_get_zoom")
+  (return-type "float")
+)
+
+(define-method find_set_properties
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_find_set_properties")
+  (return-type "none")
+  (parameters
+    '("const-char*" "search_string")
+    '("gboolean" "case_sensitive")
+    '("gboolean" "wrap_around")
+  )
+)
+
+(define-method find_next
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_find_next")
+  (return-type "gboolean")
+  (parameters
+    '("gboolean" "backwards")
+  )
+)
+
+(define-method get_encoding
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_get_encoding")
+  (return-type "char*")
+)
+
+(define-method has_automatic_encoding
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_has_automatic_encoding")
+  (return-type "gboolean")
+)
+
+(define-method set_encoding
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_set_encoding")
+  (return-type "none")
+  (parameters
+    '("const-char*" "encoding")
+  )
+)
+
+(define-method print
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_print")
+  (return-type "none")
+)
+
+(define-method set_print_preview_mode
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_set_print_preview_mode")
+  (return-type "none")
+  (parameters
+    '("gboolean" "preview_mode")
+  )
+)
+
+(define-method print_preview_n_pages
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_print_preview_n_pages")
+  (return-type "int")
+)
+
+(define-method print_preview_navigate
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_print_preview_navigate")
+  (return-type "none")
+  (parameters
+    '("EphyEmbedPrintPreviewNavType" "type")
+    '("int" "page")
+  )
+)
+
+(define-method activate
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_activate")
+  (return-type "none")
+)
+
+(define-method has_modified_forms
+  (of-object "EphyEmbed")
+  (c-name "ephy_embed_has_modified_forms")
+  (return-type "gboolean")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-embed-persist.h
+
+(define-function ephy_embed_persist_flags_get_type
+  (c-name "ephy_embed_persist_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_persist_get_type
+  (c-name "ephy_embed_persist_get_type")
+  (return-type "GType")
+)
+
+(define-method save
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_save")
+  (return-type "gboolean")
+)
+
+(define-method cancel
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_cancel")
+  (return-type "none")
+)
+
+(define-method set_dest
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_set_dest")
+  (return-type "none")
+  (parameters
+    '("const-char*" "value")
+  )
+)
+
+(define-method set_embed
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_set_embed")
+  (return-type "none")
+  (parameters
+    '("EphyEmbed*" "value")
+  )
+)
+
+(define-method set_fc_title
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_set_fc_title")
+  (return-type "none")
+  (parameters
+    '("const-char*" "value")
+  )
+)
+
+(define-method set_fc_parent
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_set_fc_parent")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "value")
+  )
+)
+
+(define-method set_flags
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_set_flags")
+  (return-type "none")
+  (parameters
+    '("EphyEmbedPersistFlags" "value")
+  )
+)
+
+(define-method set_max_size
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_set_max_size")
+  (return-type "none")
+  (parameters
+    '("gint64" "value")
+  )
+)
+
+(define-method set_persist_key
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_set_persist_key")
+  (return-type "none")
+  (parameters
+    '("const-char*" "value")
+  )
+)
+
+(define-method set_source
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_set_source")
+  (return-type "none")
+  (parameters
+    '("const-char*" "value")
+  )
+)
+
+(define-method set_user_time
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_set_user_time")
+  (return-type "none")
+  (parameters
+    '("guint32" "user_time")
+  )
+)
+
+(define-method get_dest
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_get_dest")
+  (return-type "const-char*")
+)
+
+(define-method get_embed
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_get_embed")
+  (return-type "EphyEmbed*")
+)
+
+(define-method get_fc_title
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_get_fc_title")
+  (return-type "const-char*")
+)
+
+(define-method get_fc_parent
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_get_fc_parent")
+  (return-type "GtkWindow*")
+)
+
+(define-method get_flags
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_get_flags")
+  (return-type "EphyEmbedPersistFlags")
+)
+
+(define-method get_max_size
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_get_max_size")
+  (return-type "gint64")
+)
+
+(define-method get_persist_key
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_get_persist_key")
+  (return-type "const-char*")
+)
+
+(define-method get_source
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_get_source")
+  (return-type "const-char*")
+)
+
+(define-method get_user_time
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_get_user_time")
+  (return-type "guint32")
+)
+
+(define-method to_string
+  (of-object "EphyEmbedPersist")
+  (c-name "ephy_embed_persist_to_string")
+  (return-type "char*")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-embed-prefs.h
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-embed-shell.h
+
+(define-function ephy_embed_shell_get_type
+  (c-name "ephy_embed_shell_get_type")
+  (return-type "GType")
+)
+
+(define-method get_favicon_cache
+  (of-object "EphyEmbedShell")
+  (c-name "ephy_embed_shell_get_favicon_cache")
+  (return-type "GObject*")
+)
+
+(define-method get_global_history
+  (of-object "EphyEmbedShell")
+  (c-name "ephy_embed_shell_get_global_history")
+  (return-type "GObject*")
+)
+
+(define-method get_downloader_view
+  (of-object "EphyEmbedShell")
+  (c-name "ephy_embed_shell_get_downloader_view")
+  (return-type "GObject*")
+)
+
+(define-method get_encodings
+  (of-object "EphyEmbedShell")
+  (c-name "ephy_embed_shell_get_encodings")
+  (return-type "GObject*")
+)
+
+(define-method get_embed_single
+  (of-object "EphyEmbedShell")
+  (c-name "ephy_embed_shell_get_embed_single")
+  (return-type "GObject*")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-embed-single.h
+
+(define-function ephy_embed_single_get_type
+  (c-name "ephy_embed_single_get_type")
+  (return-type "GType")
+)
+
+(define-method open_window
+  (of-object "EphyEmbedSingle")
+  (c-name "ephy_embed_single_open_window")
+  (return-type "GtkWidget*")
+  (parameters
+    '("EphyEmbed*" "parent")
+    '("const-char*" "address")
+    '("const-char*" "name")
+    '("const-char*" "features")
+  )
+)
+
+(define-method clear_cache
+  (of-object "EphyEmbedSingle")
+  (c-name "ephy_embed_single_clear_cache")
+  (return-type "none")
+)
+
+(define-method clear_auth_cache
+  (of-object "EphyEmbedSingle")
+  (c-name "ephy_embed_single_clear_auth_cache")
+  (return-type "none")
+)
+
+(define-method set_offline_mode
+  (of-object "EphyEmbedSingle")
+  (c-name "ephy_embed_single_set_offline_mode")
+  (return-type "none")
+  (parameters
+    '("gboolean" "offline")
+  )
+)
+
+(define-method get_offline_mode
+  (of-object "EphyEmbedSingle")
+  (c-name "ephy_embed_single_get_offline_mode")
+  (return-type "gboolean")
+)
+
+(define-method get_font_list
+  (of-object "EphyEmbedSingle")
+  (c-name "ephy_embed_single_get_font_list")
+  (return-type "GList*")
+  (parameters
+    '("const-char*" "lang_group")
+  )
+)
+
+(define-method get_printer_list
+  (of-object "EphyEmbedSingle")
+  (c-name "ephy_embed_single_get_printer_list")
+  (return-type "GList*")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-embed-type-builtins.h
+
+(define-function ephy_embed_net_state_get_type
+  (c-name "ephy_embed_net_state_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_chrome_get_type
+  (c-name "ephy_embed_chrome_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_print_preview_nav_type_get_type
+  (c-name "ephy_embed_print_preview_nav_type_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_security_level_get_type
+  (c-name "ephy_embed_security_level_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_document_type_get_type
+  (c-name "ephy_embed_document_type_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_event_context_get_type
+  (c-name "ephy_embed_event_context_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_embed_persist_flags_get_type
+  (c-name "ephy_embed_persist_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_content_check_type_get_type
+  (c-name "ephy_content_check_type_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_permission_get_type
+  (c-name "ephy_permission_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-extension.h
+
+(define-function ephy_extension_get_type
+  (c-name "ephy_extension_get_type")
+  (return-type "GType")
+)
+
+(define-method attach_window
+  (of-object "EphyExtension")
+  (c-name "ephy_extension_attach_window")
+  (return-type "none")
+  (parameters
+    '("EphyWindow*" "window")
+  )
+)
+
+(define-method detach_window
+  (of-object "EphyExtension")
+  (c-name "ephy_extension_detach_window")
+  (return-type "none")
+  (parameters
+    '("EphyWindow*" "window")
+  )
+)
+
+(define-method attach_tab
+  (of-object "EphyExtension")
+  (c-name "ephy_extension_attach_tab")
+  (return-type "none")
+  (parameters
+    '("EphyWindow*" "window")
+    '("EphyTab*" "tab")
+  )
+)
+
+(define-method detach_tab
+  (of-object "EphyExtension")
+  (c-name "ephy_extension_detach_tab")
+  (return-type "none")
+  (parameters
+    '("EphyWindow*" "window")
+    '("EphyTab*" "tab")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-extensions-manager.h
+
+(define-function ephy_extensions_manager_get_type
+  (c-name "ephy_extensions_manager_get_type")
+  (return-type "GType")
+)
+
+(define-method startup
+  (of-object "EphyExtensionsManager")
+  (c-name "ephy_extensions_manager_startup")
+  (return-type "none")
+)
+
+(define-method load
+  (of-object "EphyExtensionsManager")
+  (c-name "ephy_extensions_manager_load")
+  (return-type "none")
+  (parameters
+    '("const-char*" "identifier")
+  )
+)
+
+(define-method unload
+  (of-object "EphyExtensionsManager")
+  (c-name "ephy_extensions_manager_unload")
+  (return-type "none")
+  (parameters
+    '("const-char*" "identifier")
+  )
+)
+
+(define-method register
+  (of-object "EphyExtensionsManager")
+  (c-name "ephy_extensions_manager_register")
+  (return-type "none")
+  (parameters
+    '("GObject*" "object")
+  )
+)
+
+(define-method get_extensions
+  (of-object "EphyExtensionsManager")
+  (c-name "ephy_extensions_manager_get_extensions")
+  (return-type "GList*")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-history.h
+
+(define-function ephy_history_get_type
+  (c-name "ephy_history_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_history_new
+  (c-name "ephy_history_new")
+  (is-constructor-of "EphyHistory")
+  (return-type "EphyHistory*")
+)
+
+(define-method get_hosts
+  (of-object "EphyHistory")
+  (c-name "ephy_history_get_hosts")
+  (return-type "EphyNode*")
+)
+
+(define-method get_host
+  (of-object "EphyHistory")
+  (c-name "ephy_history_get_host")
+  (return-type "EphyNode*")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-method get_pages
+  (of-object "EphyHistory")
+  (c-name "ephy_history_get_pages")
+  (return-type "EphyNode*")
+)
+
+(define-method get_page
+  (of-object "EphyHistory")
+  (c-name "ephy_history_get_page")
+  (return-type "EphyNode*")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-method add_page
+  (of-object "EphyHistory")
+  (c-name "ephy_history_add_page")
+  (return-type "none")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-method is_page_visited
+  (of-object "EphyHistory")
+  (c-name "ephy_history_is_page_visited")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-method get_page_visits
+  (of-object "EphyHistory")
+  (c-name "ephy_history_get_page_visits")
+  (return-type "int")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-method set_page_title
+  (of-object "EphyHistory")
+  (c-name "ephy_history_set_page_title")
+  (return-type "none")
+  (parameters
+    '("const-char*" "url")
+    '("const-char*" "title")
+  )
+)
+
+(define-method get_last_page
+  (of-object "EphyHistory")
+  (c-name "ephy_history_get_last_page")
+  (return-type "const-char*")
+)
+
+(define-method set_icon
+  (of-object "EphyHistory")
+  (c-name "ephy_history_set_icon")
+  (return-type "none")
+  (parameters
+    '("const-char*" "url")
+    '("const-char*" "icon")
+  )
+)
+
+(define-method get_icon
+  (of-object "EphyHistory")
+  (c-name "ephy_history_get_icon")
+  (return-type "const-char*")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-method clear
+  (of-object "EphyHistory")
+  (c-name "ephy_history_clear")
+  (return-type "none")
+)
+
+(define-method is_enabled
+  (of-object "EphyHistory")
+  (c-name "ephy_history_is_enabled")
+  (return-type "gboolean")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-lib-type-builtins.h
+
+(define-function ephy_node_signal_type_get_type
+  (c-name "ephy_node_signal_type_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_state_window_flags_get_type
+  (c-name "ephy_state_window_flags_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-link.h
+
+(define-function ephy_link_flags_get_type
+  (c-name "ephy_link_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_link_get_type
+  (c-name "ephy_link_get_type")
+  (return-type "GType")
+)
+
+(define-method open
+  (of-object "EphyLink")
+  (c-name "ephy_link_open")
+  (return-type "EphyTab*")
+  (parameters
+    '("const-char*" "address")
+    '("EphyTab*" "tab")
+    '("EphyLinkFlags" "flags")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-loader.h
+
+(define-function ephy_loader_get_type
+  (c-name "ephy_loader_get_type")
+  (return-type "GType")
+)
+
+(define-method type
+  (of-object "EphyLoader")
+  (c-name "ephy_loader_type")
+  (return-type "const-char*")
+)
+
+(define-method get_object
+  (of-object "EphyLoader")
+  (c-name "ephy_loader_get_object")
+  (return-type "GObject*")
+  (parameters
+    '("GData**" "attributes")
+  )
+)
+
+(define-method release_object
+  (of-object "EphyLoader")
+  (c-name "ephy_loader_release_object")
+  (return-type "none")
+  (parameters
+    '("GObject*" "object")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-node-db.h
+
+(define-function ephy_node_db_get_type
+  (c-name "ephy_node_db_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_node_db_new
+  (c-name "ephy_node_db_new")
+  (is-constructor-of "EphyNodeDb")
+  (return-type "EphyNodeDb*")
+  (parameters
+    '("const-char*" "name")
+  )
+)
+
+(define-method load_from_file
+  (of-object "EphyNodeDb")
+  (c-name "ephy_node_db_load_from_file")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "xml_file")
+    '("const-xmlChar*" "xml_root")
+    '("const-xmlChar*" "xml_version")
+  )
+)
+
+(define-method write_to_xml_safe
+  (of-object "EphyNodeDb")
+  (c-name "ephy_node_db_write_to_xml_safe")
+  (return-type "int")
+  (parameters
+    '("const-xmlChar*" "filename")
+    '("const-xmlChar*" "root")
+    '("const-xmlChar*" "version")
+    '("const-xmlChar*" "comment")
+    '("EphyNode*" "node")
+  )
+  (varargs #t)
+)
+
+(define-method get_name
+  (of-object "EphyNodeDb")
+  (c-name "ephy_node_db_get_name")
+  (return-type "const-char*")
+)
+
+(define-method is_immutable
+  (of-object "EphyNodeDb")
+  (c-name "ephy_node_db_is_immutable")
+  (return-type "gboolean")
+)
+
+(define-method set_immutable
+  (of-object "EphyNodeDb")
+  (c-name "ephy_node_db_set_immutable")
+  (return-type "none")
+  (parameters
+    '("gboolean" "immutable")
+  )
+)
+
+(define-method get_node_from_id
+  (of-object "EphyNodeDb")
+  (c-name "ephy_node_db_get_node_from_id")
+  (return-type "EphyNode*")
+  (parameters
+    '("guint" "id")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-node.h
+
+(define-function ephy_node_get_type
+  (c-name "ephy_node_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_node_new
+  (c-name "ephy_node_new")
+  (is-constructor-of "EphyNode")
+  (return-type "EphyNode*")
+  (parameters
+    '("EphyNodeDb*" "db")
+  )
+)
+
+(define-function ephy_node_new_with_id
+  (c-name "ephy_node_new_with_id")
+  (return-type "EphyNode*")
+  (parameters
+    '("EphyNodeDb*" "db")
+    '("guint" "reserved_id")
+  )
+)
+
+(define-method get_db
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_db")
+  (return-type "EphyNodeDb*")
+)
+
+(define-method get_id
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_id")
+  (return-type "guint")
+)
+
+(define-method ref
+  (of-object "EphyNode")
+  (c-name "ephy_node_ref")
+  (return-type "none")
+)
+
+(define-method unref
+  (of-object "EphyNode")
+  (c-name "ephy_node_unref")
+  (return-type "none")
+)
+
+(define-method signal_connect_object
+  (of-object "EphyNode")
+  (c-name "ephy_node_signal_connect_object")
+  (return-type "int")
+  (parameters
+    '("EphyNodeSignalType" "type")
+    '("EphyNodeCallback" "callback")
+    '("GObject*" "object")
+  )
+)
+
+(define-method signal_disconnect_object
+  (of-object "EphyNode")
+  (c-name "ephy_node_signal_disconnect_object")
+  (return-type "guint")
+  (parameters
+    '("EphyNodeSignalType" "type")
+    '("EphyNodeCallback" "callback")
+    '("GObject*" "object")
+  )
+)
+
+(define-method signal_disconnect
+  (of-object "EphyNode")
+  (c-name "ephy_node_signal_disconnect")
+  (return-type "none")
+  (parameters
+    '("int" "signal_id")
+  )
+)
+
+(define-method set_property
+  (of-object "EphyNode")
+  (c-name "ephy_node_set_property")
+  (return-type "none")
+  (parameters
+    '("guint" "property_id")
+    '("const-GValue*" "value")
+  )
+)
+
+(define-method get_property
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_property")
+  (return-type "gboolean")
+  (parameters
+    '("guint" "property_id")
+    '("GValue*" "value")
+  )
+)
+
+(define-method get_property_string
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_property_string")
+  (return-type "const-char*")
+  (parameters
+    '("guint" "property_id")
+  )
+)
+
+(define-method get_property_boolean
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_property_boolean")
+  (return-type "gboolean")
+  (parameters
+    '("guint" "property_id")
+  )
+)
+
+(define-method get_property_long
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_property_long")
+  (return-type "long")
+  (parameters
+    '("guint" "property_id")
+  )
+)
+
+(define-method get_property_int
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_property_int")
+  (return-type "int")
+  (parameters
+    '("guint" "property_id")
+  )
+)
+
+(define-method get_property_double
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_property_double")
+  (return-type "double")
+  (parameters
+    '("guint" "property_id")
+  )
+)
+
+(define-method get_property_float
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_property_float")
+  (return-type "float")
+  (parameters
+    '("guint" "property_id")
+  )
+)
+
+(define-method get_property_node
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_property_node")
+  (return-type "EphyNode*")
+  (parameters
+    '("guint" "property_id")
+  )
+)
+
+(define-method write_to_xml
+  (of-object "EphyNode")
+  (c-name "ephy_node_write_to_xml")
+  (return-type "int")
+  (parameters
+    '("xmlTextWriterPtr" "writer")
+  )
+)
+
+(define-function ephy_node_new_from_xml
+  (c-name "ephy_node_new_from_xml")
+  (return-type "EphyNode*")
+  (parameters
+    '("EphyNodeDb*" "db")
+    '("xmlNodePtr" "xml_node")
+  )
+)
+
+(define-method add_child
+  (of-object "EphyNode")
+  (c-name "ephy_node_add_child")
+  (return-type "none")
+  (parameters
+    '("EphyNode*" "child")
+  )
+)
+
+(define-method remove_child
+  (of-object "EphyNode")
+  (c-name "ephy_node_remove_child")
+  (return-type "none")
+  (parameters
+    '("EphyNode*" "child")
+  )
+)
+
+(define-method sort_children
+  (of-object "EphyNode")
+  (c-name "ephy_node_sort_children")
+  (return-type "none")
+  (parameters
+    '("GCompareFunc" "compare_func")
+  )
+)
+
+(define-method has_child
+  (of-object "EphyNode")
+  (c-name "ephy_node_has_child")
+  (return-type "gboolean")
+  (parameters
+    '("EphyNode*" "child")
+  )
+)
+
+(define-method reorder_children
+  (of-object "EphyNode")
+  (c-name "ephy_node_reorder_children")
+  (return-type "none")
+  (parameters
+    '("int*" "new_order")
+  )
+)
+
+(define-method get_children
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_children")
+  (return-type "GPtrArray*")
+)
+
+(define-method get_n_children
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_n_children")
+  (return-type "int")
+)
+
+(define-method get_nth_child
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_nth_child")
+  (return-type "EphyNode*")
+  (parameters
+    '("guint" "n")
+  )
+)
+
+(define-method get_child_index
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_child_index")
+  (return-type "int")
+  (parameters
+    '("EphyNode*" "child")
+  )
+)
+
+(define-method get_next_child
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_next_child")
+  (return-type "EphyNode*")
+  (parameters
+    '("EphyNode*" "child")
+  )
+)
+
+(define-method get_previous_child
+  (of-object "EphyNode")
+  (c-name "ephy_node_get_previous_child")
+  (return-type "EphyNode*")
+  (parameters
+    '("EphyNode*" "child")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-notebook.h
+
+(define-function ephy_notebook_get_type
+  (c-name "ephy_notebook_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_notebook_new
+  (c-name "ephy_notebook_new")
+  (is-constructor-of "EphyNotebook")
+  (return-type "GtkWidget*")
+)
+
+(define-method add_tab
+  (of-object "EphyNotebook")
+  (c-name "ephy_notebook_add_tab")
+  (return-type "none")
+  (parameters
+    '("EphyTab*" "tab")
+    '("int" "position")
+    '("gboolean" "jump_to")
+  )
+)
+
+(define-method remove_tab
+  (of-object "EphyNotebook")
+  (c-name "ephy_notebook_remove_tab")
+  (return-type "none")
+  (parameters
+    '("EphyTab*" "tab")
+  )
+)
+
+(define-method move_tab
+  (of-object "EphyNotebook")
+  (c-name "ephy_notebook_move_tab")
+  (return-type "none")
+  (parameters
+    '("EphyNotebook*" "dest")
+    '("EphyTab*" "tab")
+    '("int" "dest_position")
+  )
+)
+
+(define-method set_show_tabs
+  (of-object "EphyNotebook")
+  (c-name "ephy_notebook_set_show_tabs")
+  (return-type "none")
+  (parameters
+    '("gboolean" "show_tabs")
+  )
+)
+
+(define-method set_dnd_enabled
+  (of-object "EphyNotebook")
+  (c-name "ephy_notebook_set_dnd_enabled")
+  (return-type "none")
+  (parameters
+    '("gboolean" "enabled")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-password-manager.h
+
+(define-function ephy_password_info_get_type
+  (c-name "ephy_password_info_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_password_info_new
+  (c-name "ephy_password_info_new")
+  (is-constructor-of "EphyPasswordInfo")
+  (return-type "EphyPasswordInfo*")
+  (parameters
+    '("const-char*" "host")
+    '("const-char*" "username")
+    '("const-char*" "password")
+  )
+)
+
+(define-method copy
+  (of-object "EphyPasswordInfo")
+  (c-name "ephy_password_info_copy")
+  (return-type "EphyPasswordInfo*")
+)
+
+(define-method free
+  (of-object "EphyPasswordInfo")
+  (c-name "ephy_password_info_free")
+  (return-type "none")
+)
+
+(define-function ephy_password_manager_get_type
+  (c-name "ephy_password_manager_get_type")
+  (return-type "GType")
+)
+
+(define-method add_password
+  (of-object "EphyPasswordManager")
+  (c-name "ephy_password_manager_add_password")
+  (return-type "none")
+  (parameters
+    '("EphyPasswordInfo*" "info")
+  )
+)
+
+(define-method remove_password
+  (of-object "EphyPasswordManager")
+  (c-name "ephy_password_manager_remove_password")
+  (return-type "none")
+  (parameters
+    '("EphyPasswordInfo*" "info")
+  )
+)
+
+(define-method list_passwords
+  (of-object "EphyPasswordManager")
+  (c-name "ephy_password_manager_list_passwords")
+  (return-type "GList*")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-permission-manager.h
+
+(define-function ephy_permission_get_type
+  (c-name "ephy_permission_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_permission_info_get_type
+  (c-name "ephy_permission_info_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_permission_info_new
+  (c-name "ephy_permission_info_new")
+  (is-constructor-of "EphyPermissionInfo")
+  (return-type "EphyPermissionInfo*")
+  (parameters
+    '("const-char*" "host")
+    '("const-char*" "type")
+    '("EphyPermission" "permission")
+  )
+)
+
+(define-method copy
+  (of-object "EphyPermissionInfo")
+  (c-name "ephy_permission_info_copy")
+  (return-type "EphyPermissionInfo*")
+)
+
+(define-method free
+  (of-object "EphyPermissionInfo")
+  (c-name "ephy_permission_info_free")
+  (return-type "none")
+)
+
+(define-function ephy_permission_manager_get_type
+  (c-name "ephy_permission_manager_get_type")
+  (return-type "GType")
+)
+
+(define-method add
+  (of-object "EphyPermissionManager")
+  (c-name "ephy_permission_manager_add")
+  (return-type "none")
+  (parameters
+    '("const-char*" "host")
+    '("const-char*" "type")
+    '("EphyPermission" "permission")
+  )
+)
+
+(define-method remove
+  (of-object "EphyPermissionManager")
+  (c-name "ephy_permission_manager_remove")
+  (return-type "none")
+  (parameters
+    '("const-char*" "host")
+    '("const-char*" "type")
+  )
+)
+
+(define-method clear
+  (of-object "EphyPermissionManager")
+  (c-name "ephy_permission_manager_clear")
+  (return-type "none")
+)
+
+(define-method test
+  (of-object "EphyPermissionManager")
+  (c-name "ephy_permission_manager_test")
+  (return-type "EphyPermission")
+  (parameters
+    '("const-char*" "host")
+    '("const-char*" "type")
+  )
+)
+
+(define-method list
+  (of-object "EphyPermissionManager")
+  (c-name "ephy_permission_manager_list")
+  (return-type "GList*")
+  (parameters
+    '("const-char*" "type")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-session.h
+
+(define-function ephy_session_get_type
+  (c-name "ephy_session_get_type")
+  (return-type "GType")
+)
+
+(define-method get_active_window
+  (of-object "EphySession")
+  (c-name "ephy_session_get_active_window")
+  (return-type "EphyWindow*")
+)
+
+(define-method save
+  (of-object "EphySession")
+  (c-name "ephy_session_save")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "filename")
+  )
+)
+
+(define-method load
+  (of-object "EphySession")
+  (c-name "ephy_session_load")
+  (return-type "gboolean")
+  (parameters
+    '("const-char*" "filename")
+    '("guint32" "user_time")
+  )
+)
+
+(define-method autoresume
+  (of-object "EphySession")
+  (c-name "ephy_session_autoresume")
+  (return-type "gboolean")
+  (parameters
+    '("guint32" "user_time")
+  )
+)
+
+(define-method close
+  (of-object "EphySession")
+  (c-name "ephy_session_close")
+  (return-type "none")
+)
+
+(define-method get_windows
+  (of-object "EphySession")
+  (c-name "ephy_session_get_windows")
+  (return-type "GList*")
+)
+
+(define-method add_window
+  (of-object "EphySession")
+  (c-name "ephy_session_add_window")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "window")
+  )
+)
+
+(define-method remove_window
+  (of-object "EphySession")
+  (c-name "ephy_session_remove_window")
+  (return-type "none")
+  (parameters
+    '("GtkWindow*" "window")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-shell.h
+
+(define-function ephy_shell_error_get_type
+  (c-name "ephy_shell_error_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_shell_startup_flags_get_type
+  (c-name "ephy_shell_startup_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_new_tab_flags_get_type
+  (c-name "ephy_new_tab_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_shell_get_type
+  (c-name "ephy_shell_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_shell_error_quark
+  (c-name "ephy_shell_error_quark")
+  (return-type "GQuark")
+)
+
+(define-function ephy_shell_get_default
+  (c-name "ephy_shell_get_default")
+  (return-type "EphyShell*")
+)
+
+(define-function ephy_shell_new
+  (c-name "ephy_shell_new")
+  (is-constructor-of "EphyShell")
+  (return-type "EphyShell*")
+)
+
+(define-method startup
+  (of-object "EphyShell")
+  (c-name "ephy_shell_startup")
+  (return-type "gboolean")
+  (parameters
+    '("EphyShellStartupFlags" "flags")
+    '("guint32" "user_time")
+    '("const-char**" "args")
+    '("const-char*" "string_arg")
+    '("GError**" "error")
+  )
+)
+
+(define-method new_tab
+  (of-object "EphyShell")
+  (c-name "ephy_shell_new_tab")
+  (return-type "EphyTab*")
+  (parameters
+    '("EphyWindow*" "parent_window")
+    '("EphyTab*" "previous_tab")
+    '("const-char*" "url")
+    '("EphyNewTabFlags" "flags")
+  )
+)
+
+(define-method new_tab_full
+  (of-object "EphyShell")
+  (c-name "ephy_shell_new_tab_full")
+  (return-type "EphyTab*")
+  (parameters
+    '("EphyWindow*" "parent_window")
+    '("EphyTab*" "previous_tab")
+    '("const-char*" "url")
+    '("EphyNewTabFlags" "flags")
+    '("EphyEmbedChrome" "chrome")
+    '("gboolean" "is_popup")
+    '("guint32" "user_time")
+  )
+)
+
+(define-method get_session
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_session")
+  (return-type "GObject*")
+)
+
+(define-method get_bookmarks
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_bookmarks")
+  (return-type "EphyBookmarks*")
+)
+
+(define-method get_toolbars_model
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_toolbars_model")
+  (return-type "GObject*")
+  (parameters
+    '("gboolean" "fullscreen")
+  )
+)
+
+(define-method get_extensions_manager
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_extensions_manager")
+  (return-type "GObject*")
+)
+
+(define-method get_bookmarks_editor
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_bookmarks_editor")
+  (return-type "GtkWidget*")
+)
+
+(define-method get_history_window
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_history_window")
+  (return-type "GtkWidget*")
+)
+
+(define-method get_pdm_dialog
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_pdm_dialog")
+  (return-type "GObject*")
+)
+
+(define-method get_prefs_dialog
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_prefs_dialog")
+  (return-type "GObject*")
+)
+
+(define-method get_print_setup_dialog
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_print_setup_dialog")
+  (return-type "GObject*")
+)
+
+(define-method get_dbus_service
+  (of-object "EphyShell")
+  (c-name "ephy_shell_get_dbus_service")
+  (return-type "GObject*")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-state.h
+
+(define-function ephy_state_add_window
+  (c-name "ephy_state_add_window")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "window")
+    '("const-char*" "name")
+    '("int" "default_width")
+    '("int" "default_heigth")
+    '("gboolean" "maximize")
+    '("EphyStateWindowFlags" "flags")
+  )
+)
+
+(define-function ephy_state_add_paned
+  (c-name "ephy_state_add_paned")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "paned")
+    '("const-char*" "name")
+    '("int" "default_width")
+  )
+)
+
+(define-function ephy_state_add_expander
+  (c-name "ephy_state_add_expander")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "expander")
+    '("const-char*" "name")
+    '("gboolean" "default_state")
+  )
+)
+
+(define-function ephy_state_save
+  (c-name "ephy_state_save")
+  (return-type "none")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-statusbar.h
+
+(define-function ephy_statusbar_get_type
+  (c-name "ephy_statusbar_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_statusbar_new
+  (c-name "ephy_statusbar_new")
+  (is-constructor-of "EphyStatusbar")
+  (return-type "GtkWidget*")
+)
+
+(define-method set_security_state
+  (of-object "EphyStatusbar")
+  (c-name "ephy_statusbar_set_security_state")
+  (return-type "none")
+  (parameters
+    '("const-char*" "stock_id")
+    '("const-char*" "tooltip")
+  )
+)
+
+(define-method set_popups_state
+  (of-object "EphyStatusbar")
+  (c-name "ephy_statusbar_set_popups_state")
+  (return-type "none")
+  (parameters
+    '("gboolean" "hidden")
+    '("const-char*" "tooltip")
+  )
+)
+
+(define-method set_progress
+  (of-object "EphyStatusbar")
+  (c-name "ephy_statusbar_set_progress")
+  (return-type "none")
+  (parameters
+    '("int" "progress")
+  )
+)
+
+(define-method add_widget
+  (of-object "EphyStatusbar")
+  (c-name "ephy_statusbar_add_widget")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "widget")
+  )
+)
+
+(define-method remove_widget
+  (of-object "EphyStatusbar")
+  (c-name "ephy_statusbar_remove_widget")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "widget")
+  )
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-tab.h
+
+(define-function ephy_tab_get_type
+  (c-name "ephy_tab_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_tab_new
+  (c-name "ephy_tab_new")
+  (is-constructor-of "EphyTab")
+  (return-type "EphyTab*")
+)
+
+(define-method get_embed
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_embed")
+  (return-type "EphyEmbed*")
+)
+
+(define-function ephy_tab_for_embed
+  (c-name "ephy_tab_for_embed")
+  (return-type "EphyTab*")
+  (parameters
+    '("EphyEmbed*" "embed")
+  )
+)
+
+(define-method get_document_type
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_document_type")
+  (return-type "EphyEmbedDocumentType")
+)
+
+(define-method get_icon_address
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_icon_address")
+  (return-type "const-char*")
+)
+
+(define-method get_load_status
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_load_status")
+  (return-type "gboolean")
+)
+
+(define-method get_link_message
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_link_message")
+  (return-type "const-char*")
+)
+
+(define-method get_load_percent
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_load_percent")
+  (return-type "int")
+)
+
+(define-method set_location
+  (of-object "EphyTab")
+  (c-name "ephy_tab_set_location")
+  (return-type "none")
+  (parameters
+    '("const-char*" "location")
+    '("EphyTabAddressExpire" "expire")
+  )
+)
+
+(define-method get_location
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_location")
+  (return-type "const-char*")
+)
+
+(define-method get_navigation_flags
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_navigation_flags")
+  (return-type "EphyTabNavigationFlags")
+)
+
+(define-method get_security_level
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_security_level")
+  (return-type "EphyEmbedSecurityLevel")
+)
+
+(define-method get_size
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_size")
+  (return-type "none")
+  (parameters
+    '("int*" "width")
+    '("int*" "height")
+  )
+)
+
+(define-method set_size
+  (of-object "EphyTab")
+  (c-name "ephy_tab_set_size")
+  (return-type "none")
+  (parameters
+    '("int" "width")
+    '("int" "height")
+  )
+)
+(define-method get_status_message
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_status_message")
+  (return-type "const-char*")
+)
+
+(define-method get_title
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_title")
+  (return-type "const-char*")
+)
+
+(define-method get_visibility
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_visibility")
+  (return-type "gboolean")
+)
+
+(define-method get_zoom
+  (of-object "EphyTab")
+  (c-name "ephy_tab_get_zoom")
+  (return-type "float")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-type-builtins.h
+
+(define-function ephy_link_flags_get_type
+  (c-name "ephy_link_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_shell_error_get_type
+  (c-name "ephy_shell_error_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_shell_startup_flags_get_type
+  (c-name "ephy_shell_startup_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_new_tab_flags_get_type
+  (c-name "ephy_new_tab_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_tab_navigation_flags_get_type
+  (c-name "ephy_tab_navigation_flags_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_tab_address_expire_get_type
+  (c-name "ephy_tab_address_expire_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_navigation_direction_get_type
+  (c-name "ephy_navigation_direction_get_type")
+  (return-type "GType")
+)
+
+
+
+;; From /opt/gnome2/include/epiphany-1.5/epiphany/ephy-window.h
+
+(define-function ephy_window_get_type
+  (c-name "ephy_window_get_type")
+  (return-type "GType")
+)
+
+(define-function ephy_window_new
+  (c-name "ephy_window_new")
+  (is-constructor-of "EphyWindow")
+  (return-type "EphyWindow*")
+)
+
+(define-function ephy_window_new_with_chrome
+  (c-name "ephy_window_new_with_chrome")
+  (return-type "EphyWindow*")
+  (parameters
+    '("EphyEmbedChrome" "chrome")
+    '("gboolean" "is_popup")
+  )
+)
+
+(define-method set_print_preview
+  (of-object "EphyWindow")
+  (c-name "ephy_window_set_print_preview")
+  (return-type "none")
+  (parameters
+    '("gboolean" "enabled")
+  )
+)
+
+(define-method get_ui_manager
+  (of-object "EphyWindow")
+  (c-name "ephy_window_get_ui_manager")
+  (return-type "GObject*")
+)
+
+(define-method get_toolbar
+  (of-object "EphyWindow")
+  (c-name "ephy_window_get_toolbar")
+  (return-type "GtkWidget*")
+)
+
+(define-method get_bookmarksbar
+  (of-object "EphyWindow")
+  (c-name "ephy_window_get_bookmarksbar")
+  (return-type "GtkWidget*")
+)
+
+(define-method get_notebook
+  (of-object "EphyWindow")
+  (c-name "ephy_window_get_notebook")
+  (return-type "GtkWidget*")
+)
+
+(define-method get_statusbar
+  (of-object "EphyWindow")
+  (c-name "ephy_window_get_statusbar")
+  (return-type "GtkWidget*")
+)
+
+(define-method add_tab
+  (of-object "EphyWindow")
+  (c-name "ephy_window_add_tab")
+  (return-type "none")
+  (parameters
+    '("EphyTab*" "tab")
+    '("gint" "position")
+    '("gboolean" "jump_to")
+  )
+)
+
+(define-method remove_tab
+  (of-object "EphyWindow")
+  (c-name "ephy_window_remove_tab")
+  (return-type "none")
+  (parameters
+    '("EphyTab*" "tab")
+  )
+)
+
+(define-method jump_to_tab
+  (of-object "EphyWindow")
+  (c-name "ephy_window_jump_to_tab")
+  (return-type "none")
+  (parameters
+    '("EphyTab*" "tab")
+  )
+)
+
+(define-method load_url
+  (of-object "EphyWindow")
+  (c-name "ephy_window_load_url")
+  (return-type "none")
+  (parameters
+    '("const-char*" "url")
+  )
+)
+
+(define-method set_zoom
+  (of-object "EphyWindow")
+  (c-name "ephy_window_set_zoom")
+  (return-type "none")
+  (parameters
+    '("float" "zoom")
+  )
+)
+
+(define-method activate_location
+  (of-object "EphyWindow")
+  (c-name "ephy_window_activate_location")
+  (return-type "none")
+)
+
+(define-method get_active_tab
+  (of-object "EphyWindow")
+  (c-name "ephy_window_get_active_tab")
+  (return-type "EphyTab*")
+)
+
+(define-method get_active_embed
+  (of-object "EphyWindow")
+  (c-name "ephy_window_get_active_embed")
+  (return-type "EphyEmbed*")
+)
+
+(define-method get_tabs
+  (of-object "EphyWindow")
+  (c-name "ephy_window_get_tabs")
+  (return-type "GList*")
+)
+
+(define-method find
+  (of-object "EphyWindow")
+  (c-name "ephy_window_find")
+  (return-type "none")
+)
+
+(define-method get_is_popup
+  (of-object "EphyWindow")
+  (c-name "ephy_window_get_is_popup")
+  (return-type "gboolean")
+)
+
diff --git a/src/epiphany.override b/src/epiphany.override
new file mode 100644
index 000000000..7a0224d0e
--- /dev/null
+++ b/src/epiphany.override
@@ -0,0 +1,392 @@
+/* -*- Mode: C; c-basic-offset: 4 -*-
+ * Copyright (C) 2005 Adam Hooper <adamh@cvs.gnome.org>
+ * Copyright (C) 2005 Christian Persch <chpe@cvs.gnome.org>
+ * Copyright (C) 2005 Crispin Flowerday <gnome@flowerday.cx>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+%%
+headers
+#include <Python.h>               
+#include <pygobject.h>
+#include <pygtk/pygtk.h>
+#include "ephy-bookmarks.h"
+#include "ephy-bookmarks-type-builtins.h"
+#include "ephy-command-manager.h"
+#include "ephy-cookie-manager.h"
+#include "ephy-dialog.h"
+#include "ephy-embed-event.h"
+#include "ephy-embed-factory.h"
+#include "ephy-embed.h"
+#include "ephy-embed-persist.h"
+#include "ephy-embed-prefs.h"
+#include "ephy-embed-shell.h"
+#include "ephy-embed-single.h"
+#include "ephy-embed-type-builtins.h"
+#include "ephy-extension.h"
+#include "ephy-extensions-manager.h"
+#include "ephy-history.h"
+#include "ephy-lib-type-builtins.h"
+#include "ephy-loader.h"
+#include "ephy-node-db.h"
+#include "ephy-node.h"
+#include "ephy-notebook.h"
+#include "ephy-password-manager.h"
+#include "ephy-permission-manager.h"
+#include "ephy-session.h"
+#include "ephy-shell.h"
+#include "ephy-state.h"
+#include "ephy-statusbar.h"
+#include "ephy-tab.h"
+#include "ephy-type-builtins.h"
+#include "ephy-window.h"
+#include "ephy-link.h"
+
+void pyepiphany_register_classes (PyObject *d); 
+void pyepiphany_add_constants (PyObject *module, const gchar *strip_prefix);
+
+static PyObject *
+_helper_wrap_string_glist (GList *list)
+{
+    GList *tmp;
+    PyObject *py_list;
+
+    if ((py_list = PyList_New(0)) == NULL) {
+        g_list_foreach(list, (GFunc)g_free, NULL);
+        g_list_free(list);
+        return NULL;
+    }
+    for (tmp = list; tmp != NULL; tmp = tmp->next) {
+        PyObject *str_obj =  PyString_FromString ((char*)tmp->data);
+
+        if (str_obj == NULL) {
+            g_list_foreach(list, (GFunc)g_free, NULL);
+            g_list_free(list);
+            Py_DECREF(py_list);
+            return NULL;
+        }
+        PyList_Append(py_list, str_obj);
+        Py_DECREF(str_obj);
+    }
+    g_list_foreach(list, (GFunc)g_free, NULL);
+    g_list_free(list);
+    return py_list;
+}
+
+static PyObject *
+_helper_wrap_gobject_glist (GList *list)
+{
+    PyObject *py_list;
+    GList *tmp;
+
+    if ((py_list = PyList_New(0)) == NULL) {
+        return NULL;
+    }
+    for (tmp = list; tmp != NULL; tmp = tmp->next) {
+        PyObject *py_obj = pygobject_new(G_OBJECT(tmp->data));
+
+        if (py_obj == NULL) {
+            Py_DECREF(py_list);
+            return NULL;
+        }
+        PyList_Append(py_list, py_obj);
+        Py_DECREF(py_obj);
+    }
+    return py_list;
+}
+
+static void
+free_boxed_type (gpointer data, gpointer type)
+{
+    g_boxed_free (GPOINTER_TO_INT(type), data);
+}
+
+
+static PyObject *
+_helper_wrap_boxed_glist (GType type, GList *list)
+{
+    GList *tmp;
+    PyObject *py_list;
+
+    if ((py_list = PyList_New(0)) == NULL) {
+        g_list_foreach(list, free_boxed_type, GINT_TO_POINTER(type));
+        g_list_free(list);
+        return NULL;
+    }
+    for (tmp = list; tmp != NULL; tmp = tmp->next) {
+        PyObject *obj = pyg_boxed_new (type, tmp->data, FALSE, TRUE);
+        PyList_Append(py_list, obj);
+        Py_DECREF(obj);
+    }
+    g_list_free(list);
+    return py_list;
+}
+
+static PyObject *
+_helper_wrap_boxed_gptrarray (GType type, GPtrArray *list, gboolean own_ref, gboolean dealloc)
+{
+    PyObject *py_list;
+    int i;
+
+    if ((py_list = PyList_New(0)) == NULL) {
+        return NULL;
+    }
+    for( i = 0; i < list->len; i++ ) {
+        PyObject *obj = pyg_boxed_new (type, g_ptr_array_index(list,i), FALSE, own_ref);
+        PyList_Append(py_list, obj);
+        Py_DECREF(obj);
+    }
+    if (dealloc) g_ptr_array_free (list, TRUE);
+    return py_list;
+}
+
+%%
+modulename epiphany                     
+%%
+import gtk.Bin as PyGtkBin_Type
+import gtk.Window as PyGtkWindow_Type
+import gtk.UIManager as PyGtkUIManager_Type
+import gtk.Widget as PyGtkWidget_Type
+import gtk.Statusbar as PyGtkStatusbar_Type
+import gtk.Notebook as PyGtkNotebook_Type
+import gobject.GObject as PyGObject_Type 
+%%
+ignore-glob
+  *_get_type
+%%
+ignore
+  ephy_embed_event_get_dom_event
+  ephy_tab_for_embed
+  ephy_shell_error_quark
+  ephy_shell_startup
+  ephy_shell_get_dbus_service
+%%
+override ephy_tab_get_size noargs
+static PyObject *
+_wrap_ephy_tab_get_size(PyGObject *self)
+{
+    gint width;
+    gint height;
+
+    ephy_tab_get_size(EPHY_TAB(self->obj), &width, &height);
+    return Py_BuildValue("(ii)", width, height);
+}
+%%
+override ephy_embed_event_get_coords noargs
+static PyObject *
+_wrap_ephy_embed_event_get_coords(PyGObject *self)
+{
+    gint x, y;
+
+    ephy_embed_event_get_coords (EPHY_EMBED_EVENT(self->obj), &x, &y);
+    return Py_BuildValue("(ii)", x, y);
+}
+%%
+override ephy_window_get_tabs noargs
+static PyObject *
+_wrap_ephy_window_get_tabs(PyGObject *self)
+{
+    GList *list;
+    PyObject *py_list;
+
+    list = ephy_window_get_tabs(EPHY_WINDOW (self->obj));
+
+    py_list = _helper_wrap_gobject_glist (list);
+
+    g_list_free(list);
+
+    return py_list;
+}
+%%
+override ephy_embed_shistory_get_nth kwargs
+static PyObject*
+_wrap_ephy_embed_shistory_get_nth (PyGObject *self,
+                                   PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = {"nth", "is_relative", NULL}; 
+    int nth, is_relative;
+    char *url, *title;
+    PyObject *py_url, *py_title;
+    PyObject *py_list;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,    
+                                     "ii:EphyEmbed.shistory_get_nth", kwlist,
+                                     &nth, &is_relative)) {
+        return NULL;
+    }
+
+    ephy_embed_shistory_get_nth (EPHY_EMBED (self->obj), nth, is_relative,
+                                 &url, &title);
+
+    if (!url || !title) {
+        return Py_None;
+    }
+
+    if ((py_list = PyList_New(0)) == NULL) {
+        g_free (url);
+        g_free (title);
+        return NULL;
+    }
+
+    py_url   = PyString_FromString (url);
+    g_free (url);
+    if (!py_url) {
+        g_free (title);
+        Py_DECREF(py_list);
+        return NULL;
+    }
+
+    PyList_Append(py_list, py_url);
+    Py_DECREF(py_url);
+
+    py_title = PyString_FromString (title);
+    g_free (title);
+
+    if (!py_title) {
+        Py_DECREF(py_list);
+        return NULL;
+    }
+
+    PyList_Append(py_list, py_title);
+    Py_DECREF(py_title);
+    return py_list;
+}
+%%
+override ephy_embed_get_go_up_list noargs
+static PyObject*
+_wrap_ephy_embed_get_go_up_list (PyGObject *self)
+{
+    GSList *list, *tmp;
+    PyObject *py_list;
+
+    list = ephy_embed_get_go_up_list (EPHY_EMBED (self->obj));
+
+    if ((py_list = PyList_New(0)) == NULL) {
+        g_slist_foreach(list, (GFunc)g_free, NULL);
+        g_slist_free(list);
+        return NULL;
+    }
+    for (tmp = list; tmp != NULL; tmp = tmp->next) {
+        PyObject *str_obj =  PyString_FromString ((char*)tmp->data);
+
+        if (str_obj == NULL) {
+            g_slist_foreach(list, (GFunc)g_free, NULL);
+            g_slist_free(list);
+            Py_DECREF(py_list);
+            return NULL;
+        }
+        PyList_Append(py_list, str_obj);
+        Py_DECREF(str_obj);
+    }
+    g_slist_foreach(list, (GFunc)g_free, NULL);
+    g_slist_free(list);
+    return py_list;
+}
+%%
+override ephy_embed_single_get_printer_list noargs
+static PyObject*
+_wrap_ephy_embed_single_get_printer_list (PyGObject *self)
+{
+    GList *list;
+
+    list = ephy_embed_single_get_printer_list (EPHY_EMBED_SINGLE (self->obj));
+
+    return _helper_wrap_string_glist (list);
+}
+%%
+override ephy_embed_single_get_font_list kwargs
+static PyObject*
+_wrap_ephy_embed_single_get_font_list (PyGObject *self,
+                                       PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = {"font_group", NULL}; 
+    char *font_group;
+    GList *list;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "s:EphyEmbedSingle.get_font_list", kwlist, &font_group))
+        return NULL;
+
+
+    list = ephy_embed_single_get_font_list (EPHY_EMBED_SINGLE (self->obj), font_group);
+
+    return _helper_wrap_string_glist (list);
+}
+%%
+override ephy_embed_event_get_property kwargs
+static PyObject*
+_wrap_ephy_embed_event_get_property (PyGObject *self,
+                                     PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = {"property", NULL}; 
+    char *prop;
+    const GValue *value;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
+                                     "s:EphyEmbedEvent.get_property", kwlist, &prop))
+        return NULL;
+
+    ephy_embed_event_get_property (EPHY_EMBED_EVENT (self->obj), prop, &value);
+
+    return pyg_value_as_pyobject(value, TRUE);
+}
+%%
+override ephy_password_manager_list_passwords noargs
+static PyObject*
+_wrap_ephy_password_manager_list_passwords (PyGObject *self)
+{
+    GList *list;
+
+    list = ephy_password_manager_list_passwords (EPHY_PASSWORD_MANAGER (self->obj));
+
+    return _helper_wrap_boxed_glist (EPHY_TYPE_PASSWORD_INFO, list);
+}
+%%
+override ephy_cookie_manager_list_cookies noargs
+static PyObject *
+_wrap_ephy_cookie_manager_list_cookies(PyGObject *self)
+{
+    GList *list;
+
+    list = ephy_cookie_manager_list_cookies(EPHY_COOKIE_MANAGER (self->obj));
+
+    return _helper_wrap_boxed_glist (EPHY_TYPE_COOKIE, list);
+}
+%%
+override ephy_node_get_children noargs
+static PyObject *
+_wrap_ephy_node_get_children (PyGObject *self)
+{
+    GPtrArray *list = ephy_node_get_children ((EphyNode *) (self->obj));
+
+    return _helper_wrap_boxed_gptrarray (EPHY_TYPE_NODE, list, FALSE, FALSE);
+}
+%%
+override ephy_session_get_windows noargs
+static PyObject *
+_wrap_ephy_session_get_windows (PyGObject *self)
+{    
+    GList *list;
+    PyObject *py_list;
+
+    list = ephy_session_get_windows (EPHY_SESSION (self->obj));
+
+    py_list = _helper_wrap_gobject_glist (list);
+
+    g_list_free(list);
+
+    return py_list;
+}