aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorChristian Persch <chpe@cvs.gnome.org>2005-05-21 21:58:23 +0800
committerChristian Persch <chpe@src.gnome.org>2005-05-21 21:58:23 +0800
commit37e4cc15c39af9a10c7d0aaf46210c0d31db9e8e (patch)
tree65541b23b2e74375140408522ca87ff022cb8ef6 /src
parent97c1cd51ff1384591c7f137cb3075bc9fcb56dba (diff)
downloadgsoc2013-epiphany-37e4cc15c39af9a10c7d0aaf46210c0d31db9e8e.tar
gsoc2013-epiphany-37e4cc15c39af9a10c7d0aaf46210c0d31db9e8e.tar.gz
gsoc2013-epiphany-37e4cc15c39af9a10c7d0aaf46210c0d31db9e8e.tar.bz2
gsoc2013-epiphany-37e4cc15c39af9a10c7d0aaf46210c0d31db9e8e.tar.lz
gsoc2013-epiphany-37e4cc15c39af9a10c7d0aaf46210c0d31db9e8e.tar.xz
gsoc2013-epiphany-37e4cc15c39af9a10c7d0aaf46210c0d31db9e8e.tar.zst
gsoc2013-epiphany-37e4cc15c39af9a10c7d0aaf46210c0d31db9e8e.zip
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.
Diffstat (limited to 'src')
-rw-r--r--src/Makefile.am91
-rw-r--r--src/ephy-extensions-manager.c18
-rw-r--r--src/ephy-python-extension.c370
-rw-r--r--src/ephy-python-extension.h59
-rw-r--r--src/ephy-python-loader.c143
-rw-r--r--src/ephy-python-loader.h59
-rw-r--r--src/ephy-python.c57
-rw-r--r--src/ephy-python.h32
-rw-r--r--src/epiphany.defs3044
-rw-r--r--src/epiphany.override392
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;
+}