12 files changed, 1101 insertions, 0 deletions

diff --git a/binding/python/Makefile.am b/binding/python/Makefile.am
new file mode 100644
index 00000000..dd74229a
--- /dev/null
+++ b/binding/python/Makefile.am
@@ -0,0 +1,6 @@
+include $(top_srcdir)/Makefile.inc
+AM_CPPFLAGS = @NAVIT_CFLAGS@ @PYTHON_CFLAGS@ -I$(top_srcdir)/navit -DMODULE=binding_python
+modulebinding_LTLIBRARIES = libbinding_python.la
+libbinding_python_la_SOURCES = binding_python.c main.c navit.c pcoord.c route.c navigation.c attr.c common.h
+libbinding_python_la_LIBADD = @PYTHON_LIBS@
+libbinding_python_la_LDFLAGS = -module -avoid-version
diff --git a/binding/python/attr.c b/binding/python/attr.c
new file mode 100644
index 00000000..2d5ed92b
--- /dev/null
+++ b/binding/python/attr.c
@@ -0,0 +1,99 @@
+/**
+ * Navit, a modular navigation system.
+ * Copyright (C) 2005-2008 Navit Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "common.h"
+#include "item.h"
+#include "attr.h"
+
+typedef struct {
+	PyObject_HEAD
+	int ref;
+	struct attr *attr;
+} attrObject;
+
+static PyObject *
+attr_func(attrObject *self, PyObject *args)
+{
+	const char *file;
+	int ret;
+	if (!PyArg_ParseTuple(args, "s", &file))
+		return NULL;
+	ret=0;
+	return Py_BuildValue("i",ret);
+}
+
+
+
+static PyMethodDef attr_methods[] = {
+	{"func",	(PyCFunction) attr_func, METH_VARARGS },
+	{NULL, NULL },
+};
+
+
+static PyObject *
+attr_getattr_py(PyObject *self, char *name)
+{
+	return Py_FindMethod(attr_methods, self, name);
+}
+
+static void
+attr_destroy_py(attrObject *self)
+{
+	if (! self->ref)
+		attr_free(self->attr);
+}
+
+PyTypeObject attr_Type = {
+	Obj_HEAD
+	.tp_name="attr",
+	.tp_basicsize=sizeof(attrObject),
+	.tp_dealloc=(destructor)attr_destroy_py,
+	.tp_getattr=attr_getattr_py,
+};
+
+struct attr *
+attr_py_get(PyObject *self)
+{
+	return ((attrObject *)self)->attr;
+}
+
+PyObject *
+attr_new_py(PyObject *self, PyObject *args)
+{
+	attrObject *ret;
+	const char *name,*value;
+        if (!PyArg_ParseTuple(args, "ss", &name, &value))
+                return NULL;
+	ret=PyObject_NEW(attrObject, &attr_Type);
+	ret->attr=attr_new_from_text(name, value);
+	ret->ref=0;
+	return (PyObject *)ret;
+}
+
+PyObject *
+attr_new_py_ref(struct attr *attr)
+{
+	attrObject *ret;
+
+	ret=PyObject_NEW(attrObject, &attr_Type);
+	ret->ref=1;
+	ret->attr=attr;
+	return (PyObject *)ret;
+}
+
diff --git a/binding/python/binding_python.c b/binding/python/binding_python.c
new file mode 100644
index 00000000..6d4fcc78
--- /dev/null
+++ b/binding/python/binding_python.c
@@ -0,0 +1,370 @@
+/**
+ * Navit, a modular navigation system.
+ * Copyright (C) 2005-2008 Navit Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "config.h"
+#include <glib.h>
+#include "common.h"
+#include <fcntl.h>
+#include "coord.h"
+#include "projection.h"
+#include "debug.h"
+#include "item.h"
+#include "map.h"
+#include "mapset.h"
+#include "plugin.h"
+#include "debug.h"
+#include "item.h"
+#include "attr.h"
+#include "xmlconfig.h"
+
+#if defined(MS_WINDOWS) || defined(__CYGWIN__)
+#define Obj_HEAD PyObject_HEAD_INIT(NULL);
+#else
+#define Obj_HEAD PyObject_HEAD_INIT(&PyType_Type)
+#endif
+
+/* *** coord *** */
+
+typedef struct {
+	PyObject_HEAD
+	struct coord *c;
+} coordObject;
+
+static void coord_destroy_py(coordObject *self);
+
+PyTypeObject coord_Type = {
+	Obj_HEAD
+	.tp_name="coord",
+	.tp_basicsize=sizeof(coordObject),
+	.tp_dealloc=(destructor)coord_destroy_py,
+};
+
+
+/* *** map *** */
+
+typedef struct {
+	PyObject_HEAD
+	int ref;
+	struct map *m;
+} mapObject;
+
+static void map_destroy_py(mapObject *self);
+static PyObject *map_getattr_py(PyObject *self, char *name);
+
+PyTypeObject map_Type = {
+	Obj_HEAD
+	.tp_name="map",
+	.tp_basicsize=sizeof(mapObject),
+	.tp_dealloc=(destructor)map_destroy_py,
+	.tp_getattr=map_getattr_py,
+};
+
+/* *** IMPLEMENTATIONS *** */
+
+/* *** coord *** */
+
+static PyObject *
+coord_new_py(PyObject *self, PyObject *args)
+{
+	coordObject *ret;
+	int x,y;
+	if (!PyArg_ParseTuple(args, "ii:navit.coord",&x,&y))
+		return NULL;
+	ret=PyObject_NEW(coordObject, &coord_Type);
+	ret->c=coord_new(x,y);
+	return (PyObject *)ret;
+}
+
+static void
+coord_destroy_py(coordObject *self)
+{
+		coord_destroy(self->c);
+}
+
+/* *** coord_rect *** */
+
+typedef struct {
+	PyObject_HEAD
+	struct coord_rect *r;
+} coord_rectObject;
+
+
+static void coord_rect_destroy_py(coord_rectObject *self);
+
+PyTypeObject coord_rect_Type = {
+#if defined(MS_WINDOWS) || defined(__CYGWIN__)
+	PyObject_HEAD_INIT(NULL);
+#else
+	PyObject_HEAD_INIT(&PyType_Type)
+#endif
+	.tp_name="coord_rect",
+	.tp_basicsize=sizeof(coord_rectObject),
+	.tp_dealloc=(destructor)coord_rect_destroy_py,
+};
+
+static PyObject *
+coord_rect_new_py(PyObject *self, PyObject *args)
+{
+	coord_rectObject *ret;
+	coordObject *lu,*rd;
+	if (!PyArg_ParseTuple(args, "O!O!:navit.coord_rect_rect",&coord_Type,&lu,&coord_Type,&rd))
+		return NULL;
+	ret=PyObject_NEW(coord_rectObject, &coord_rect_Type);
+	ret->r=coord_rect_new(lu->c,rd->c);
+	return (PyObject *)ret;
+}
+
+static void
+coord_rect_destroy_py(coord_rectObject *self)
+{
+	coord_rect_destroy(self->r);
+}
+
+/* *** map_rect *** */
+
+typedef struct {
+	PyObject_HEAD
+	struct map_rect *mr;
+} map_rectObject;
+
+
+static void map_rect_destroy_py(map_rectObject *self);
+
+PyTypeObject map_rect_Type = {
+#if defined(MS_WINDOWS) || defined(__CYGWIN__)
+	PyObject_HEAD_INIT(NULL);
+#else
+	PyObject_HEAD_INIT(&PyType_Type)
+#endif
+	.tp_name="map_rect",
+	.tp_basicsize=sizeof(map_rectObject),
+	.tp_dealloc=(destructor)map_rect_destroy_py,
+};
+
+static PyObject *
+map_rect_new_py(mapObject *self, PyObject *args)
+{
+	map_rectObject *ret;
+	coord_rectObject *r;
+	if (!PyArg_ParseTuple(args, "O!:navit.map_rect_rect",&coord_rect_Type,&r))
+		return NULL;
+	ret=PyObject_NEW(map_rectObject, &map_rect_Type);
+	ret->mr=map_rect_new(self->m, NULL);
+	return (PyObject *)ret;
+}
+
+static void
+map_rect_destroy_py(map_rectObject *self)
+{
+	map_rect_destroy(self->mr);
+}
+
+
+/* *** map *** */
+
+static PyObject *
+map_dump_file_py(mapObject *self, PyObject *args)
+{
+	const char *s;
+	if (!PyArg_ParseTuple(args, "s",&s))
+		return NULL;
+	map_dump_file(self->m, s);
+	Py_RETURN_NONE;
+}
+
+
+static PyObject *
+map_set_attr_py(mapObject *self, PyObject *args)
+{
+	PyObject *attr;
+	if (!PyArg_ParseTuple(args, "O!", &attr_Type, &attr))
+		return NULL;
+	map_set_attr(self->m, attr_py_get(attr));
+	Py_RETURN_NONE;
+}
+
+
+
+static PyMethodDef map_methods[] = {
+	{"dump_file",		(PyCFunction) map_dump_file_py, METH_VARARGS },
+	{"map_rect_new",	(PyCFunction) map_rect_new_py, METH_VARARGS },
+	{"set_attr",		(PyCFunction) map_set_attr_py, METH_VARARGS },
+	{NULL, NULL },
+};
+
+static PyObject *
+map_getattr_py(PyObject *self, char *name)
+{
+	return Py_FindMethod(map_methods, self, name);
+}
+
+
+static PyObject *
+map_new_py(PyObject *self, PyObject *args)
+{
+	mapObject *ret;
+	char *type, *filename;
+	
+	if (!PyArg_ParseTuple(args, "ss:navit.map", &type, &filename))
+		return NULL;
+	ret=PyObject_NEW(mapObject, &map_Type);
+	ret->m=map_new(NULL,NULL);
+	ret->ref=0;
+	return (PyObject *)ret;
+}
+
+PyObject *
+map_py_ref(struct map *map)
+{
+	mapObject *ret;
+	ret=PyObject_NEW(mapObject, &map_Type);
+	ret->m=map;
+	ret->ref=1;
+	return (PyObject *)ret;
+}
+
+static void
+map_destroy_py(mapObject *self)
+{
+	if (!self->ref)
+		map_destroy(self->m);
+}
+
+/* *** mapset *** */
+
+
+typedef struct {
+	PyObject_HEAD
+	struct mapset *ms;
+} mapsetObject;
+
+
+static void mapset_destroy_py(mapsetObject *self);
+static PyObject *mapset_getattr_py(PyObject *self, char *name);
+
+PyTypeObject mapset_Type = {
+#if defined(MS_WINDOWS) || defined(__CYGWIN__)
+	PyObject_HEAD_INIT(NULL);
+#else
+	PyObject_HEAD_INIT(&PyType_Type)
+#endif
+	.tp_name="mapset",
+	.tp_basicsize=sizeof(mapsetObject),
+	.tp_dealloc=(destructor)mapset_destroy_py,
+	.tp_getattr=mapset_getattr_py,
+};
+
+static PyObject *
+mapset_add_py(mapsetObject *self, PyObject *args)
+{
+	mapObject *map;
+	if (!PyArg_ParseTuple(args, "O:navit.mapset", &map))
+		return NULL;
+	Py_INCREF(map);
+	mapset_add_attr(self->ms, &(struct attr){attr_map,.u.map=map->m});
+	return Py_BuildValue("");
+}
+
+static PyMethodDef mapset_methods[] = {
+	{"add",	(PyCFunction) mapset_add_py, METH_VARARGS },
+	{NULL, NULL },
+};
+
+static PyObject *
+mapset_getattr_py(PyObject *self, char *name)
+{
+	return Py_FindMethod(mapset_methods, self, name);
+}
+
+static PyObject *
+mapset_new_py(PyObject *self, PyObject *args)
+{
+	mapsetObject *ret;
+	if (!PyArg_ParseTuple(args, ":navit.mapset"))
+		return NULL;
+	ret=PyObject_NEW(mapsetObject, &mapset_Type);
+	ret->ms=mapset_new(NULL,NULL);
+	return (PyObject *)ret;
+}
+
+static void
+mapset_destroy_py(mapsetObject *self)
+{
+	mapset_destroy(self->ms);
+}
+
+static PyObject *
+config_load_py(PyObject *self, PyObject *args)
+{
+	const char *file;
+	int ret;
+	xmlerror *error;
+	if (!PyArg_ParseTuple(args, "s", &file))
+		return NULL;
+	ret=config_load(file, &error);
+	return Py_BuildValue("i",ret);
+}
+
+static PyMethodDef navitMethods[]={
+	{"attr", attr_new_py, METH_VARARGS},
+	{"coord", coord_new_py, METH_VARARGS, "Create a new coordinate point."},
+	{"coord_rect", coord_rect_new_py, METH_VARARGS, "Create a new coordinate rectangle."},
+	{"map", map_new_py, METH_VARARGS, "Create a new map."},
+	{"mapset", mapset_new_py, METH_VARARGS, "Create a new mapset."},
+	{"config_load", config_load_py, METH_VARARGS, "Load a config"},
+	{"main", main_py, METH_VARARGS, "Get Main Object"},
+	{"pcoord", pcoord_py, METH_VARARGS},
+	{NULL, NULL, 0, NULL}
+};
+
+
+PyObject *
+python_object_from_attr(struct attr *attr)
+{
+	switch (attr->type) {
+	case attr_navigation:
+		return navigation_py_ref(attr->u.navigation);
+	case attr_route:
+		return route_py_ref(attr->u.route);
+	default:
+		return NULL;
+	}
+	return NULL;
+}
+
+
+void
+plugin_init(void)
+{
+	int fd,size;
+	char buffer[65536];
+
+	Py_Initialize();
+	Py_InitModule("navit", navitMethods);
+	fd=open("startup.py",O_RDONLY);
+	if (fd >= 0) {
+		size=read(fd, buffer, 65535);
+		if (size > 0) {
+			buffer[size]='\0';
+			PyRun_SimpleString(buffer);
+		}
+	}
+	
+	Py_Finalize();
+}
diff --git a/binding/python/common.h b/binding/python/common.h
new file mode 100644
index 00000000..5c1a270c
--- /dev/null
+++ b/binding/python/common.h
@@ -0,0 +1,55 @@
+/**
+ * Navit, a modular navigation system.
+ * Copyright (C) 2005-2008 Navit Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include <Python.h>
+#include "debug.h"
+
+#if defined(MS_WINDOWS) || defined(__CYGWIN__)
+#define Obj_HEAD PyObject_HEAD_INIT(NULL);
+#else
+#define Obj_HEAD PyObject_HEAD_INIT(&PyType_Type)
+#endif
+
+struct navit;
+struct map;
+
+PyObject * python_object_from_attr(struct attr *attr);
+
+PyObject * main_py(PyObject *self, PyObject *args);
+
+PyObject * map_py_ref(struct map *map);
+
+struct navigation;
+PyObject * navigation_py(PyObject *self, PyObject *args);
+PyObject * navigation_py_ref(struct navigation *navigation);
+
+PyObject * navit_py(PyObject *self, PyObject *args);
+PyObject * navit_py_ref(struct navit *navit);
+extern PyTypeObject pcoord_Type;
+PyObject * pcoord_py(PyObject *self, PyObject *args);
+struct pcoord *pcoord_py_get(PyObject *self);
+
+struct route;
+PyObject * route_py(PyObject *self, PyObject *args);
+PyObject * route_py_ref(struct route *route);
+
+extern PyTypeObject attr_Type;
+PyObject * attr_new_py(PyObject *self, PyObject *args);
+PyObject * attr_new_py_ref(struct attr *attr);
+struct attr * attr_py_get(PyObject *self);
diff --git a/binding/python/main.c b/binding/python/main.c
new file mode 100644
index 00000000..5a782cc7
--- /dev/null
+++ b/binding/python/main.c
@@ -0,0 +1,71 @@
+/**
+ * Navit, a modular navigation system.
+ * Copyright (C) 2005-2008 Navit Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "common.h"
+#include "main.h"
+
+typedef struct {
+	PyObject_HEAD
+} mainObject;
+
+static PyObject *
+main_navit(PyObject *self, PyObject *args)
+{
+	struct navit *navit;
+	navit=main_get_navit(NULL);
+	return navit_py_ref(navit);
+}
+
+
+
+static PyMethodDef main_methods[] = {
+	{"navit",	(PyCFunction) main_navit, METH_VARARGS },
+	{NULL, NULL },
+};
+
+
+static PyObject *
+main_getattr_py(PyObject *self, char *name)
+{
+	return Py_FindMethod(main_methods, self, name);
+}
+
+static void
+main_destroy_py(mainObject *self)
+{
+}
+
+PyTypeObject main_Type = {
+	Obj_HEAD
+	.tp_name="main",
+	.tp_basicsize=sizeof(mainObject),
+	.tp_dealloc=(destructor)main_destroy_py,
+	.tp_getattr=main_getattr_py,
+};
+
+PyObject *
+main_py(PyObject *self, PyObject *args)
+{
+	mainObject *ret;
+
+	dbg(0,"enter\n");	
+	ret=PyObject_NEW(mainObject, &main_Type);
+	return (PyObject *)ret;
+}
+
diff --git a/binding/python/navigation.c b/binding/python/navigation.c
new file mode 100644
index 00000000..75a421d5
--- /dev/null
+++ b/binding/python/navigation.c
@@ -0,0 +1,82 @@
+/**
+ * Navit, a modular navigation system.
+ * Copyright (C) 2005-2008 Navit Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "common.h"
+#include "navigation.h"
+
+typedef struct {
+	PyObject_HEAD
+	struct navigation *navigation;
+} navigationObject;
+
+static PyObject *
+navigation_get_map_py(navigationObject *self, PyObject *args)
+{
+	if (!PyArg_ParseTuple(args, ""))
+		return NULL;
+	return map_py_ref(navigation_get_map(self->navigation));
+}
+
+
+
+static PyMethodDef navigation_methods[] = {
+	{"get_map",	(PyCFunction) navigation_get_map_py, METH_VARARGS },
+	{NULL, NULL },
+};
+
+
+static PyObject *
+navigation_getattr_py(PyObject *self, char *name)
+{
+	return Py_FindMethod(navigation_methods, self, name);
+}
+
+static void
+navigation_destroy_py(navigationObject *self)
+{
+}
+
+PyTypeObject navigation_Type = {
+	Obj_HEAD
+	.tp_name="navigation",
+	.tp_basicsize=sizeof(navigationObject),
+	.tp_dealloc=(destructor)navigation_destroy_py,
+	.tp_getattr=navigation_getattr_py,
+};
+
+PyObject *
+navigation_py(PyObject *self, PyObject *args)
+{
+	navigationObject *ret;
+
+	ret=PyObject_NEW(navigationObject, &navigation_Type);
+	return (PyObject *)ret;
+}
+
+PyObject *
+navigation_py_ref(struct navigation *navigation)
+{
+	navigationObject *ret;
+
+	ret=PyObject_NEW(navigationObject, &navigation_Type);
+	ret->navigation=navigation;
+	return (PyObject *)ret;
+}
+
+
diff --git a/binding/python/navit.c b/binding/python/navit.c
new file mode 100644
index 00000000..ada8cd7f
--- /dev/null
+++ b/binding/python/navit.c
@@ -0,0 +1,135 @@
+/**
+ * Navit, a modular navigation system.
+ * Copyright (C) 2005-2008 Navit Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "common.h"
+#include "item.h"
+#include "navit.h"
+
+typedef struct {
+	PyObject_HEAD
+	struct navit *navit;
+} navitObject;
+
+static PyObject *
+navit_get_attr_py(navitObject *self, PyObject *args)
+{
+	char *name;
+	struct attr attr;
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return NULL;
+	if (!navit_get_attr(self->navit, attr_from_name(name), &attr, NULL)) {
+		dbg(0,"get_attr not ok\n");
+		Py_RETURN_NONE;
+	}
+	dbg(0,"get_attr ok\n");
+	return python_object_from_attr(&attr);
+}
+
+static PyObject *
+navit_set_center_py(navitObject *self, PyObject *args)
+{
+	PyObject *pcoord;
+	if (!PyArg_ParseTuple(args, "O!", &pcoord_Type, &pcoord))
+		return NULL;
+	navit_set_center(self->navit, pcoord_py_get(pcoord), 0);
+	Py_RETURN_NONE;
+}
+
+static PyObject *
+navit_set_destination_py(navitObject *self, PyObject *args)
+{
+	PyObject *pcoord;
+	const char *description;
+	int async;
+	if (!PyArg_ParseTuple(args, "O!si", &pcoord_Type, &pcoord, &description, &async))
+		return NULL;
+	navit_set_destination(self->navit, pcoord_py_get(pcoord), description, async);
+	Py_RETURN_NONE;
+}
+
+static PyObject *
+navit_set_position_py(navitObject *self, PyObject *args)
+{
+	PyObject *pcoord;
+	if (!PyArg_ParseTuple(args, "O!", &pcoord_Type, &pcoord))
+		return NULL;
+	navit_set_position(self->navit, pcoord_py_get(pcoord));
+	Py_RETURN_NONE;
+}
+
+
+static PyObject *
+navit_zoom_to_route_py(navitObject *self, PyObject *args)
+{
+	if (!PyArg_ParseTuple(args, ""))
+		return NULL;
+	navit_zoom_to_route(self->navit,0);
+	Py_RETURN_NONE;
+}
+
+
+
+
+static PyMethodDef navit_methods[] = {
+	{"get_attr",		(PyCFunction) navit_get_attr_py, METH_VARARGS },
+	{"set_center",		(PyCFunction) navit_set_center_py, METH_VARARGS },
+	{"set_destination",	(PyCFunction) navit_set_destination_py, METH_VARARGS },
+	{"set_position",	(PyCFunction) navit_set_position_py, METH_VARARGS },
+	{"zoom_to_route",	(PyCFunction) navit_zoom_to_route_py, METH_VARARGS },
+	{NULL, NULL },
+};
+
+
+static PyObject *
+navit_getattr_py(PyObject *self, char *name)
+{
+	return Py_FindMethod(navit_methods, self, name);
+}
+
+static void
+navit_destroy_py(navitObject *self)
+{
+}
+
+PyTypeObject navit_Type = {
+	Obj_HEAD
+	.tp_name="navit",
+	.tp_basicsize=sizeof(navitObject),
+	.tp_dealloc=(destructor)navit_destroy_py,
+	.tp_getattr=navit_getattr_py,
+};
+
+PyObject *
+navit_py(PyObject *self, PyObject *args)
+{
+	navitObject *ret;
+
+	dbg(0,"enter\n");	
+	ret=PyObject_NEW(navitObject, &navit_Type);
+	return (PyObject *)ret;
+}
+
+PyObject *
+navit_py_ref(struct navit *navit)
+{
+	dbg(0,"navit=%p\n", navit);
+	navitObject *ret=PyObject_NEW(navitObject, &navit_Type);
+	ret->navit=navit;
+	return (PyObject *)ret;
+}
diff --git a/binding/python/navit.xml.python b/binding/python/navit.xml.python
new file mode 100644
index 00000000..ec3e99de
--- /dev/null
+++ b/binding/python/navit.xml.python
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE config SYSTEM "navit.dtd">
+<config xmlns:xi="http://www.w3.org/2001/XInclude">
+    <plugins>
+        <plugin path="$NAVIT_LIBDIR/*/${NAVIT_LIBPREFIX}libbinding_python.so" active="yes"/>
+    </plugins>
+</config>
diff --git a/binding/python/pcoord.c b/binding/python/pcoord.c
new file mode 100644
index 00000000..a4cb2640
--- /dev/null
+++ b/binding/python/pcoord.c
@@ -0,0 +1,88 @@
+/**
+ * Navit, a modular navigation system.
+ * Copyright (C) 2005-2008 Navit Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "common.h"
+#include "coord.h"
+
+typedef struct {
+	PyObject_HEAD
+	struct pcoord pc;
+} pcoordObject;
+
+static PyObject *
+pcoord_func(pcoordObject *self, PyObject *args)
+{
+	const char *file;
+	int ret=0;
+	if (!PyArg_ParseTuple(args, "s", &file))
+		return NULL;
+	return Py_BuildValue("i",ret);
+}
+
+
+
+static PyMethodDef pcoord_methods[] = {
+	{"func",	(PyCFunction) pcoord_func, METH_VARARGS },
+	{NULL, NULL },
+};
+
+
+static PyObject *
+pcoord_getattr_py(PyObject *self, char *name)
+{
+	return Py_FindMethod(pcoord_methods, self, name);
+}
+
+static void
+pcoord_destroy_py(pcoordObject *self)
+{
+}
+
+PyTypeObject pcoord_Type = {
+	Obj_HEAD
+	.tp_name="pcoord",
+	.tp_basicsize=sizeof(pcoordObject),
+	.tp_dealloc=(destructor)pcoord_destroy_py,
+	.tp_getattr=pcoord_getattr_py,
+};
+
+PyObject *
+pcoord_py(PyObject *self, PyObject *args)
+{
+	pcoordObject *ret;
+	const char *str;
+	enum projection pro;
+	struct coord c;
+	if (!PyArg_ParseTuple(args, "si", &str, &pro))
+		return NULL;
+	ret=PyObject_NEW(pcoordObject, &pcoord_Type);
+	coord_parse(str, pro, &c);
+	ret->pc.pro=pro;
+	ret->pc.x=c.x;
+	ret->pc.y=c.y;
+	dbg(0,"0x%x,0x%x\n", c.x, c.y);
+	return (PyObject *)ret;
+}
+
+struct pcoord *
+pcoord_py_get(PyObject *self)
+{
+	return &((pcoordObject *)self)->pc;
+}
+
diff --git a/binding/python/route.c b/binding/python/route.c
new file mode 100644
index 00000000..dfbd08cf
--- /dev/null
+++ b/binding/python/route.c
@@ -0,0 +1,84 @@
+/**
+ * Navit, a modular navigation system.
+ * Copyright (C) 2005-2008 Navit Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "common.h"
+#include "item.h"
+#include "coord.h"
+#include "route.h"
+
+typedef struct {
+	PyObject_HEAD
+	struct route *route;
+} routeObject;
+
+static PyObject *
+route_get_map_py(routeObject *self, PyObject *args)
+{
+	if (!PyArg_ParseTuple(args, ""))
+		return NULL;
+	return map_py_ref(route_get_map(self->route));
+}
+
+
+
+static PyMethodDef route_methods[] = {
+	{"get_map",	(PyCFunction) route_get_map_py, METH_VARARGS },
+	{NULL, NULL },
+};
+
+
+static PyObject *
+route_getattr_py(PyObject *self, char *name)
+{
+	return Py_FindMethod(route_methods, self, name);
+}
+
+static void
+route_destroy_py(routeObject *self)
+{
+}
+
+PyTypeObject route_Type = {
+	Obj_HEAD
+	.tp_name="route",
+	.tp_basicsize=sizeof(routeObject),
+	.tp_dealloc=(destructor)route_destroy_py,
+	.tp_getattr=route_getattr_py,
+};
+
+PyObject *
+route_py(PyObject *self, PyObject *args)
+{
+	routeObject *ret;
+
+	ret=PyObject_NEW(routeObject, &route_Type);
+	return (PyObject *)ret;
+}
+
+PyObject *
+route_py_ref(struct route *route)
+{
+	routeObject *ret;
+
+	ret=PyObject_NEW(routeObject, &route_Type);
+	ret->route=route;
+	return (PyObject *)ret;
+}
+
+
diff --git a/binding/python/startup.py b/binding/python/startup.py
new file mode 100644
index 00000000..02b20700
--- /dev/null
+++ b/binding/python/startup.py
@@ -0,0 +1,8 @@
+import navit
+navit.config_load("navit.xml.local")
+pos=navit.pcoord("5023.7493 N 00730.2898 E",1);
+dest=navit.pcoord("5023.6604 N 00729.8500 E",1);
+inst=navit.main().navit();
+inst.set_position(pos);
+inst.set_destination(dest,"Test");
+inst.set_center(pos);
diff --git a/binding/python/template.c b/binding/python/template.c
new file mode 100644
index 00000000..088cb5ee
--- /dev/null
+++ b/binding/python/template.c
@@ -0,0 +1,96 @@
+/**
+ * Navit, a modular navigation system.
+ * Copyright (C) 2005-2008 Navit Team
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301, USA.
+ */
+
+#include "common.h"
+#include "template.h"
+
+typedef struct {
+	PyObject_HEAD
+	int ref;
+	struct template *template;
+} templateObject;
+
+static PyObject *
+template_func(templateObject *self, PyObject *args)
+{
+	const char *file;
+	int ret;
+	if (!PyArg_ParseTuple(args, "s", &file))
+		return NULL;
+	ret=0;
+	return Py_BuildValue("i",ret);
+}
+
+
+
+static PyMethodDef template_methods[] = {
+	{"func",	(PyCFunction) template_func, METH_VARARGS },
+	{NULL, NULL },
+};
+
+
+static PyObject *
+template_getattr_py(PyObject *self, char *name)
+{
+	return Py_FindMethod(template_methods, self, name);
+}
+
+static void
+template_destroy_py(templateObject *self)
+{
+	if (! self->ref)
+		template_destroy(self->template);
+}
+
+PyTypeObject template_Type = {
+	Obj_HEAD
+	.tp_name="template",
+	.tp_basicsize=sizeof(templateObject),
+	.tp_dealloc=(destructor)template_destroy_py,
+	.tp_getattr=template_getattr_py,
+};
+
+struct template *
+template_py_get(PyObject *self)
+{
+	return ((templateObject *)self)->template;
+}
+
+PyObject *
+template_new_py(PyObject *self, PyObject *args)
+{
+	templateObject *ret;
+
+	ret=PyObject_NEW(templateObject, &template_Type);
+	ret->template=template_new();
+	ret->ref=0;
+	return (PyObject *)ret;
+}
+
+PyObject *
+template_new_py_ref(struct template *template)
+{
+	templateObject *ret;
+
+	ret=PyObject_NEW(templateObject, &template_Type);
+	ret->ref=1;
+	ret->template=template;
+	return (PyObject *)ret;
+}
+