r24729 - in /packages/unstable/libchamplain/debian: changelog patches/ patches/01fix_python_bindings.patch patches/series

bigon at users.alioth.debian.org bigon at users.alioth.debian.org
Sun Jul 11 01:30:33 UTC 2010


Author: bigon
Date: Sun Jul 11 01:30:33 2010
New Revision: 24729

URL: http://svn.debian.org/wsvn/pkg-gnome/?sc=1&rev=24729
Log:
debian/patches/01fix_python_bindings.patch: Fix python bindings
(Closes: #587881)

Added:
    packages/unstable/libchamplain/debian/patches/
    packages/unstable/libchamplain/debian/patches/01fix_python_bindings.patch
    packages/unstable/libchamplain/debian/patches/series
Modified:
    packages/unstable/libchamplain/debian/changelog

Modified: packages/unstable/libchamplain/debian/changelog
URL: http://svn.debian.org/wsvn/pkg-gnome/packages/unstable/libchamplain/debian/changelog?rev=24729&op=diff
==============================================================================
--- packages/unstable/libchamplain/debian/changelog [utf-8] (original)
+++ packages/unstable/libchamplain/debian/changelog [utf-8] Sun Jul 11 01:30:33 2010
@@ -1,3 +1,10 @@
+libchamplain (0.4.6-2) UNRELEASED; urgency=low
+
+  * debian/patches/01fix_python_bindings.patch: Fix python bindings
+    (Closes: #587881)
+
+ -- Laurent Bigonville <bigon at debian.org>  Sun, 11 Jul 2010 03:28:54 +0200
+
 libchamplain (0.4.6-1) unstable; urgency=low
 
   * New upstream release (thanks to Łukasz Jernaś <deejay1 at srem.org>)

Added: packages/unstable/libchamplain/debian/patches/01fix_python_bindings.patch
URL: http://svn.debian.org/wsvn/pkg-gnome/packages/unstable/libchamplain/debian/patches/01fix_python_bindings.patch?rev=24729&op=file
==============================================================================
--- packages/unstable/libchamplain/debian/patches/01fix_python_bindings.patch (added)
+++ packages/unstable/libchamplain/debian/patches/01fix_python_bindings.patch [utf-8] Sun Jul 11 01:30:33 2010
@@ -1,0 +1,4833 @@
+--- /dev/null
++++ b/bindings/python/champlain/pychamplain.c
+@@ -0,0 +1,4830 @@
++/* -- THIS FILE IS GENERATED - DO NOT EDIT *//* -*- Mode: C; c-basic-offset: 4 -*- */
++
++#include <Python.h>
++
++
++
++#line 3 "./pychamplain.override"
++#include <Python.h>
++#include <pygobject.h>
++#include <champlain/champlain.h>
++#include <clutter/clutter.h>
++#include "pychamplain.h"
++
++#line 15 "./pychamplain.c"
++
++
++/* ---------- types from other modules ---------- */
++static PyTypeObject *_PyGObject_Type;
++#define PyGObject_Type (*_PyGObject_Type)
++static PyTypeObject *_PyGInitiallyUnowned_Type;
++#define PyGInitiallyUnowned_Type (*_PyGInitiallyUnowned_Type)
++static PyTypeObject *_PyClutterActor_Type;
++#define PyClutterActor_Type (*_PyClutterActor_Type)
++static PyTypeObject *_PyClutterGroup_Type;
++#define PyClutterGroup_Type (*_PyClutterGroup_Type)
++static PyTypeObject *_PyClutterColor_Type;
++#define PyClutterColor_Type (*_PyClutterColor_Type)
++
++
++/* ---------- forward type declarations ---------- */
++PyTypeObject G_GNUC_INTERNAL PyChamplainPoint_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainMapSourceDesc_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainBaseMarker_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainCache_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainLayer_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainMapSource_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainMapSourceFactory_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainMarker_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainNetworkMapSource_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainPolygon_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainSelectionLayer_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainTile_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainView_Type;
++PyTypeObject G_GNUC_INTERNAL PyChamplainZoomLevel_Type;
++
++#line 47 "./pychamplain.c"
++
++
++
++/* ----------- ChamplainPoint ----------- */
++
++static int
++_wrap_champlain_point_new(PyGBoxed *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "lat", "lon", NULL };
++    double lat, lon;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Champlain.Point.__init__", kwlist, &lat, &lon))
++        return -1;
++    self->gtype = CHAMPLAIN_TYPE_POINT;
++    self->free_on_dealloc = FALSE;
++    self->boxed = champlain_point_new(lat, lon);
++
++    if (!self->boxed) {
++        PyErr_SetString(PyExc_RuntimeError, "could not create ChamplainPoint object");
++        return -1;
++    }
++    self->free_on_dealloc = TRUE;
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_point_copy(PyObject *self)
++{
++    ChamplainPoint *ret;
++
++    
++    ret = champlain_point_copy(pyg_boxed_get(self, ChamplainPoint));
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CHAMPLAIN_TYPE_POINT, ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_point_free(PyObject *self)
++{
++    
++    champlain_point_free(pyg_boxed_get(self, ChamplainPoint));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static const PyMethodDef _PyChamplainPoint_methods[] = {
++    { "copy", (PyCFunction)_wrap_champlain_point_copy, METH_NOARGS,
++      NULL },
++    { "free", (PyCFunction)_wrap_champlain_point_free, METH_NOARGS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++#line 466 "./pychamplain.override"
++static int
++_wrap_champlain_point__set_lat (PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    gdouble val;
++
++    val = PyFloat_AsDouble(value);
++    if (PyErr_Occurred())
++        return -1;
++
++    pyg_boxed_get(self, ChamplainPoint)->lat = val;
++    return 0;
++}
++#line 117 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_point__get_lat(PyObject *self, void *closure)
++{
++    double ret;
++
++    ret = pyg_boxed_get(self, ChamplainPoint)->lat;
++    return PyFloat_FromDouble(ret);
++}
++
++#line 481 "./pychamplain.override"
++static int
++_wrap_champlain_point__set_lon(PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    gdouble val;
++
++    val = PyFloat_AsDouble(value);
++    if (PyErr_Occurred())
++        return -1;
++
++    pyg_boxed_get(self, ChamplainPoint)->lon = val;
++    return 0;
++}
++#line 143 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_point__get_lon(PyObject *self, void *closure)
++{
++    double ret;
++
++    ret = pyg_boxed_get(self, ChamplainPoint)->lon;
++    return PyFloat_FromDouble(ret);
++}
++
++static const PyGetSetDef champlain_point_getsets[] = {
++    { "lat", (getter)_wrap_champlain_point__get_lat, (setter)_wrap_champlain_point__set_lat },
++    { "lon", (getter)_wrap_champlain_point__get_lon, (setter)_wrap_champlain_point__set_lon },
++    { NULL, (getter)0, (setter)0 },
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainPoint_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.Point",                   /* tp_name */
++    sizeof(PyGBoxed),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    0,             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainPoint_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)champlain_point_getsets,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    0,                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_point_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainMapSourceDesc ----------- */
++
++#line 431 "./pychamplain.override"
++static int
++_wrap_champlain_map_source_desc_new(PyGBoxed *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = {"id", "name", "license", "license_uri", 
++        "min_zoom_level", "max_zoom_level", "projection", "uri_format", NULL };
++    ChamplainMapSourceDesc *desc;
++    PyObject *py_projection;
++
++    desc = champlain_map_source_desc_new();
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs, 
++            "ssssiiOs:ChamplainMapSourceDesc.__init__", kwlist,
++            &desc->id, &desc->name, &desc->license, &desc->license_uri, 
++            &desc->min_zoom_level, &desc->max_zoom_level, &py_projection, 
++            &desc->uri_format)){
++        return -1;
++    }
++
++    if (pyg_enum_get_value(CHAMPLAIN_TYPE_MAP_PROJECTION, py_projection, 
++            (gpointer)&desc->projection) != 0)
++        return -1;
++
++    self->boxed = g_boxed_copy(CHAMPLAIN_TYPE_MAP_SOURCE_DESC, desc);
++    self->free_on_dealloc = TRUE;
++    self->gtype = CHAMPLAIN_TYPE_MAP_SOURCE_DESC;
++
++    if (!self->boxed) {
++        PyErr_SetString(PyExc_RuntimeError, 
++            "could not create ChamplainMapSourceDesc object");
++        return -1;
++    }
++    return 0;
++}
++#line 244 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_map_source_desc_copy(PyObject *self)
++{
++    ChamplainMapSourceDesc *ret;
++
++    
++    ret = champlain_map_source_desc_copy(pyg_boxed_get(self, ChamplainMapSourceDesc));
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CHAMPLAIN_TYPE_MAP_SOURCE_DESC, ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_map_source_desc_free(PyObject *self)
++{
++    
++    champlain_map_source_desc_free(pyg_boxed_get(self, ChamplainMapSourceDesc));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static const PyMethodDef _PyChamplainMapSourceDesc_methods[] = {
++    { "copy", (PyCFunction)_wrap_champlain_map_source_desc_copy, METH_NOARGS,
++      NULL },
++    { "free", (PyCFunction)_wrap_champlain_map_source_desc_free, METH_NOARGS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++#line 282 "./pychamplain.override"
++static int
++_wrap_champlain_map_source_desc__set_id (PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    gchar *val;
++
++	val = PyString_AsString (value);
++	if (PyErr_Occurred ())
++		return -1;
++
++	pyg_boxed_get (self, ChamplainMapSourceDesc)->id = val;
++	return 0;
++}
++static PyObject *
++_wrap_champlain_map_source_desc__get_id (PyGBoxed *self, void *closure)
++{
++    gchar *id = pyg_boxed_get(self, ChamplainMapSourceDesc)->id;
++    return PyString_FromString (id);
++}
++#line 297 "./pychamplain.c"
++
++
++#line 303 "./pychamplain.override"
++static int
++_wrap_champlain_map_source_desc__set_name (PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    gchar *val;
++
++	val = PyString_AsString (value);
++	if (PyErr_Occurred ())
++		return -1;
++
++	pyg_boxed_get (self, ChamplainMapSourceDesc)->name = val;
++	return 0;
++}
++static PyObject *
++_wrap_champlain_map_source_desc__get_name (PyGBoxed *self, void *closure)
++{
++    gchar *name = pyg_boxed_get(self, ChamplainMapSourceDesc)->name;
++    return PyString_FromString (name);
++}
++#line 320 "./pychamplain.c"
++
++
++#line 324 "./pychamplain.override"
++static int
++_wrap_champlain_map_source_desc__set_license (PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    gchar *val;
++
++	val = PyString_AsString (value);
++	if (PyErr_Occurred ())
++		return -1;
++
++	pyg_boxed_get (self, ChamplainMapSourceDesc)->license = val;
++	return 0;
++}
++static PyObject *
++_wrap_champlain_map_source_desc__get_license (PyGBoxed *self, void *closure)
++{
++    gchar *license = pyg_boxed_get(self, ChamplainMapSourceDesc)->license;
++    return PyString_FromString (license);
++}
++#line 343 "./pychamplain.c"
++
++
++#line 345 "./pychamplain.override"
++static int
++_wrap_champlain_map_source_desc__set_license_uri (PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    gchar *val;
++
++	val = PyString_AsString (value);
++	if (PyErr_Occurred ())
++		return -1;
++
++	pyg_boxed_get (self, ChamplainMapSourceDesc)->license_uri = val;
++	return 0;
++}
++static PyObject *
++_wrap_champlain_map_source_desc__get_license_uri (PyGBoxed *self, void *closure)
++{
++    gchar *license_uri = pyg_boxed_get(self, ChamplainMapSourceDesc)->license_uri;
++    return PyString_FromString (license_uri);
++}
++#line 366 "./pychamplain.c"
++
++
++#line 402 "./pychamplain.override"
++static int
++_wrap_champlain_map_source_desc__set_min_zoom_level (PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    glong val;
++
++	val = PyLong_AsLong (value);
++	if (PyErr_Occurred ())
++		return -1;
++
++	pyg_boxed_get (self, ChamplainMapSourceDesc)->min_zoom_level = val;
++	return 0;
++}
++#line 383 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_map_source_desc__get_min_zoom_level(PyObject *self, void *closure)
++{
++    int ret;
++
++    ret = pyg_boxed_get(self, ChamplainMapSourceDesc)->min_zoom_level;
++    return PyInt_FromLong(ret);
++}
++
++#line 387 "./pychamplain.override"
++static int
++_wrap_champlain_map_source_desc__set_max_zoom_level (PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    glong val;
++
++	val = PyLong_AsLong (value);
++	if (PyErr_Occurred ())
++		return -1;
++
++	pyg_boxed_get (self, ChamplainMapSourceDesc)->max_zoom_level = val;
++	return 0;
++}
++#line 409 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_map_source_desc__get_max_zoom_level(PyObject *self, void *closure)
++{
++    int ret;
++
++    ret = pyg_boxed_get(self, ChamplainMapSourceDesc)->max_zoom_level;
++    return PyInt_FromLong(ret);
++}
++
++#line 417 "./pychamplain.override"
++static int
++_wrap_champlain_map_source_desc__set_projection (PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    ChamplainMapProjection val;
++
++    if (pyg_enum_get_value(CHAMPLAIN_TYPE_MAP_PROJECTION, value, (gpointer)&val) != 0)
++        return -1;
++
++	pyg_boxed_get (self, ChamplainMapSourceDesc)->projection = val;
++	return 0;
++}
++#line 434 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_map_source_desc__get_projection(PyObject *self, void *closure)
++{
++    gint ret;
++
++    ret = pyg_boxed_get(self, ChamplainMapSourceDesc)->projection;
++    return pyg_enum_from_gtype(CHAMPLAIN_TYPE_MAP_PROJECTION, ret);
++}
++
++#line 366 "./pychamplain.override"
++static int
++_wrap_champlain_map_source_desc__set_uri_format (PyGBoxed *self, PyObject *value, 
++    void *closure)
++{
++    gchar *val;
++
++	val = PyString_AsString (value);
++	if (PyErr_Occurred ())
++		return -1;
++
++	pyg_boxed_get (self, ChamplainMapSourceDesc)->uri_format = val;
++	return 0;
++}
++static PyObject *
++_wrap_champlain_map_source_desc__get_uri_format (PyGBoxed *self, void *closure)
++{
++    gchar *uri_format = pyg_boxed_get(self, ChamplainMapSourceDesc)->uri_format;
++    return PyString_FromString (uri_format);
++}
++#line 466 "./pychamplain.c"
++
++
++static const PyGetSetDef champlain_map_source_desc_getsets[] = {
++    { "id", (getter)_wrap_champlain_map_source_desc__get_id, (setter)_wrap_champlain_map_source_desc__set_id },
++    { "name", (getter)_wrap_champlain_map_source_desc__get_name, (setter)_wrap_champlain_map_source_desc__set_name },
++    { "license", (getter)_wrap_champlain_map_source_desc__get_license, (setter)_wrap_champlain_map_source_desc__set_license },
++    { "license_uri", (getter)_wrap_champlain_map_source_desc__get_license_uri, (setter)_wrap_champlain_map_source_desc__set_license_uri },
++    { "min_zoom_level", (getter)_wrap_champlain_map_source_desc__get_min_zoom_level, (setter)_wrap_champlain_map_source_desc__set_min_zoom_level },
++    { "max_zoom_level", (getter)_wrap_champlain_map_source_desc__get_max_zoom_level, (setter)_wrap_champlain_map_source_desc__set_max_zoom_level },
++    { "projection", (getter)_wrap_champlain_map_source_desc__get_projection, (setter)_wrap_champlain_map_source_desc__set_projection },
++    { "uri_format", (getter)_wrap_champlain_map_source_desc__get_uri_format, (setter)_wrap_champlain_map_source_desc__set_uri_format },
++    { NULL, (getter)0, (setter)0 },
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainMapSourceDesc_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.MapSourceDesc",                   /* tp_name */
++    sizeof(PyGBoxed),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    0,             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainMapSourceDesc_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)champlain_map_source_desc_getsets,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    0,                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_map_source_desc_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainBaseMarker ----------- */
++
++static int
++_wrap_champlain_base_marker_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.BaseMarker.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.BaseMarker object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_base_marker_set_position(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "longitude", "latitude", NULL };
++    double longitude, latitude;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Champlain.BaseMarker.set_position", kwlist, &longitude, &latitude))
++        return NULL;
++    
++    champlain_base_marker_set_position(CHAMPLAIN_BASE_MARKER(self->obj), longitude, latitude);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_base_marker_set_highlighted(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    int value;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.BaseMarker.set_highlighted", kwlist, &value))
++        return NULL;
++    
++    champlain_base_marker_set_highlighted(CHAMPLAIN_BASE_MARKER(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_base_marker_get_highlighted(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_base_marker_get_highlighted(CHAMPLAIN_BASE_MARKER(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_base_marker_animate_in(PyGObject *self)
++{
++    
++    champlain_base_marker_animate_in(CHAMPLAIN_BASE_MARKER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_base_marker_animate_in_with_delay(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "delay", NULL };
++    PyObject *py_delay = NULL;
++    guint delay = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.BaseMarker.animate_in_with_delay", kwlist, &py_delay))
++        return NULL;
++    if (py_delay) {
++        if (PyLong_Check(py_delay))
++            delay = PyLong_AsUnsignedLong(py_delay);
++        else if (PyInt_Check(py_delay))
++            delay = PyInt_AsLong(py_delay);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'delay' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    champlain_base_marker_animate_in_with_delay(CHAMPLAIN_BASE_MARKER(self->obj), delay);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_base_marker_animate_out(PyGObject *self)
++{
++    
++    champlain_base_marker_animate_out(CHAMPLAIN_BASE_MARKER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_base_marker_animate_out_with_delay(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "delay", NULL };
++    PyObject *py_delay = NULL;
++    guint delay = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.BaseMarker.animate_out_with_delay", kwlist, &py_delay))
++        return NULL;
++    if (py_delay) {
++        if (PyLong_Check(py_delay))
++            delay = PyLong_AsUnsignedLong(py_delay);
++        else if (PyInt_Check(py_delay))
++            delay = PyInt_AsLong(py_delay);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'delay' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    champlain_base_marker_animate_out_with_delay(CHAMPLAIN_BASE_MARKER(self->obj), delay);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static const PyMethodDef _PyChamplainBaseMarker_methods[] = {
++    { "set_position", (PyCFunction)_wrap_champlain_base_marker_set_position, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_highlighted", (PyCFunction)_wrap_champlain_base_marker_set_highlighted, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_highlighted", (PyCFunction)_wrap_champlain_base_marker_get_highlighted, METH_NOARGS,
++      NULL },
++    { "animate_in", (PyCFunction)_wrap_champlain_base_marker_animate_in, METH_NOARGS,
++      NULL },
++    { "animate_in_with_delay", (PyCFunction)_wrap_champlain_base_marker_animate_in_with_delay, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "animate_out", (PyCFunction)_wrap_champlain_base_marker_animate_out, METH_NOARGS,
++      NULL },
++    { "animate_out_with_delay", (PyCFunction)_wrap_champlain_base_marker_animate_out_with_delay, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainBaseMarker_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.BaseMarker",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainBaseMarker_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_base_marker_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainCache ----------- */
++
++static PyObject *
++_wrap_champlain_cache_update_tile(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "tile", "filesize", NULL };
++    PyGObject *tile;
++    PyObject *py_filesize = NULL;
++    guint filesize = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!O:Champlain.Cache.update_tile", kwlist, &PyChamplainTile_Type, &tile, &py_filesize))
++        return NULL;
++    if (py_filesize) {
++        if (PyLong_Check(py_filesize))
++            filesize = PyLong_AsUnsignedLong(py_filesize);
++        else if (PyInt_Check(py_filesize))
++            filesize = PyInt_AsLong(py_filesize);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'filesize' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    champlain_cache_update_tile(CHAMPLAIN_CACHE(self->obj), CHAMPLAIN_TILE(tile->obj), filesize);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_cache_fill_tile(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "tile", NULL };
++    PyGObject *tile;
++    int ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.Cache.fill_tile", kwlist, &PyChamplainTile_Type, &tile))
++        return NULL;
++    
++    ret = champlain_cache_fill_tile(CHAMPLAIN_CACHE(self->obj), CHAMPLAIN_TILE(tile->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_cache_tile_is_expired(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "tile", NULL };
++    PyGObject *tile;
++    int ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.Cache.tile_is_expired", kwlist, &PyChamplainTile_Type, &tile))
++        return NULL;
++    
++    ret = champlain_cache_tile_is_expired(CHAMPLAIN_CACHE(self->obj), CHAMPLAIN_TILE(tile->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_cache_set_size_limit(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "size_limit", NULL };
++    PyObject *py_size_limit = NULL;
++    guint size_limit = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Cache.set_size_limit", kwlist, &py_size_limit))
++        return NULL;
++    if (py_size_limit) {
++        if (PyLong_Check(py_size_limit))
++            size_limit = PyLong_AsUnsignedLong(py_size_limit);
++        else if (PyInt_Check(py_size_limit))
++            size_limit = PyInt_AsLong(py_size_limit);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'size_limit' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    champlain_cache_set_size_limit(CHAMPLAIN_CACHE(self->obj), size_limit);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_cache_get_size_limit(PyGObject *self)
++{
++    guint ret;
++
++    
++    ret = champlain_cache_get_size_limit(CHAMPLAIN_CACHE(self->obj));
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_cache_purge(PyGObject *self)
++{
++    
++    champlain_cache_purge(CHAMPLAIN_CACHE(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_cache_purge_on_idle(PyGObject *self)
++{
++    
++    champlain_cache_purge_on_idle(CHAMPLAIN_CACHE(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static const PyMethodDef _PyChamplainCache_methods[] = {
++    { "update_tile", (PyCFunction)_wrap_champlain_cache_update_tile, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "fill_tile", (PyCFunction)_wrap_champlain_cache_fill_tile, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "tile_is_expired", (PyCFunction)_wrap_champlain_cache_tile_is_expired, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_size_limit", (PyCFunction)_wrap_champlain_cache_set_size_limit, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_size_limit", (PyCFunction)_wrap_champlain_cache_get_size_limit, METH_NOARGS,
++      NULL },
++    { "purge", (PyCFunction)_wrap_champlain_cache_purge, METH_NOARGS,
++      NULL },
++    { "purge_on_idle", (PyCFunction)_wrap_champlain_cache_purge_on_idle, METH_NOARGS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainCache_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.Cache",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainCache_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)0,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainLayer ----------- */
++
++static int
++_wrap_champlain_layer_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.Layer.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.Layer object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_layer_show(PyGObject *self)
++{
++    
++    champlain_layer_show(CHAMPLAIN_LAYER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_layer_hide(PyGObject *self)
++{
++    
++    champlain_layer_hide(CHAMPLAIN_LAYER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_layer_add_marker(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "marker", NULL };
++    PyGObject *marker;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.Layer.add_marker", kwlist, &PyChamplainBaseMarker_Type, &marker))
++        return NULL;
++    
++    champlain_layer_add_marker(CHAMPLAIN_LAYER(self->obj), CHAMPLAIN_BASE_MARKER(marker->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_layer_remove_marker(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "marker", NULL };
++    PyGObject *marker;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.Layer.remove_marker", kwlist, &PyChamplainBaseMarker_Type, &marker))
++        return NULL;
++    
++    champlain_layer_remove_marker(CHAMPLAIN_LAYER(self->obj), CHAMPLAIN_BASE_MARKER(marker->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_layer_animate_in_all_markers(PyGObject *self)
++{
++    
++    champlain_layer_animate_in_all_markers(CHAMPLAIN_LAYER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_layer_animate_out_all_markers(PyGObject *self)
++{
++    
++    champlain_layer_animate_out_all_markers(CHAMPLAIN_LAYER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_layer_show_all_markers(PyGObject *self)
++{
++    
++    champlain_layer_show_all_markers(CHAMPLAIN_LAYER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_layer_hide_all_markers(PyGObject *self)
++{
++    
++    champlain_layer_hide_all_markers(CHAMPLAIN_LAYER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static const PyMethodDef _PyChamplainLayer_methods[] = {
++    { "show", (PyCFunction)_wrap_champlain_layer_show, METH_NOARGS,
++      NULL },
++    { "hide", (PyCFunction)_wrap_champlain_layer_hide, METH_NOARGS,
++      NULL },
++    { "add_marker", (PyCFunction)_wrap_champlain_layer_add_marker, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "remove_marker", (PyCFunction)_wrap_champlain_layer_remove_marker, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "animate_in_all_markers", (PyCFunction)_wrap_champlain_layer_animate_in_all_markers, METH_NOARGS,
++      NULL },
++    { "animate_out_all_markers", (PyCFunction)_wrap_champlain_layer_animate_out_all_markers, METH_NOARGS,
++      NULL },
++    { "show_all_markers", (PyCFunction)_wrap_champlain_layer_show_all_markers, METH_NOARGS,
++      NULL },
++    { "hide_all_markers", (PyCFunction)_wrap_champlain_layer_hide_all_markers, METH_NOARGS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainLayer_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.Layer",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainLayer_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_layer_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainMapSource ----------- */
++
++static int
++_wrap_champlain_map_source_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.MapSource.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.MapSource object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_min_zoom_level(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_map_source_get_min_zoom_level(CHAMPLAIN_MAP_SOURCE(self->obj));
++    
++    return PyInt_FromLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_max_zoom_level(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_map_source_get_max_zoom_level(CHAMPLAIN_MAP_SOURCE(self->obj));
++    
++    return PyInt_FromLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_tile_size(PyGObject *self)
++{
++    guint ret;
++
++    
++    ret = champlain_map_source_get_tile_size(CHAMPLAIN_MAP_SOURCE(self->obj));
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_x(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", "longitude", NULL };
++    int zoom_level;
++    double longitude;
++    guint ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"id:Champlain.MapSource.get_x", kwlist, &zoom_level, &longitude))
++        return NULL;
++    
++    ret = champlain_map_source_get_x(CHAMPLAIN_MAP_SOURCE(self->obj), zoom_level, longitude);
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_y(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", "latitude", NULL };
++    int zoom_level;
++    double latitude;
++    guint ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"id:Champlain.MapSource.get_y", kwlist, &zoom_level, &latitude))
++        return NULL;
++    
++    ret = champlain_map_source_get_y(CHAMPLAIN_MAP_SOURCE(self->obj), zoom_level, latitude);
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_longitude(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", "x", NULL };
++    int zoom_level;
++    PyObject *py_x = NULL;
++    guint x = 0;
++    double ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iO:Champlain.MapSource.get_longitude", kwlist, &zoom_level, &py_x))
++        return NULL;
++    if (py_x) {
++        if (PyLong_Check(py_x))
++            x = PyLong_AsUnsignedLong(py_x);
++        else if (PyInt_Check(py_x))
++            x = PyInt_AsLong(py_x);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'x' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    ret = champlain_map_source_get_longitude(CHAMPLAIN_MAP_SOURCE(self->obj), zoom_level, x);
++    
++    return PyFloat_FromDouble(ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_latitude(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", "y", NULL };
++    int zoom_level;
++    PyObject *py_y = NULL;
++    guint y = 0;
++    double ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iO:Champlain.MapSource.get_latitude", kwlist, &zoom_level, &py_y))
++        return NULL;
++    if (py_y) {
++        if (PyLong_Check(py_y))
++            y = PyLong_AsUnsignedLong(py_y);
++        else if (PyInt_Check(py_y))
++            y = PyInt_AsLong(py_y);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'y' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    ret = champlain_map_source_get_latitude(CHAMPLAIN_MAP_SOURCE(self->obj), zoom_level, y);
++    
++    return PyFloat_FromDouble(ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_row_count(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", NULL };
++    int zoom_level;
++    guint ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.MapSource.get_row_count", kwlist, &zoom_level))
++        return NULL;
++    
++    ret = champlain_map_source_get_row_count(CHAMPLAIN_MAP_SOURCE(self->obj), zoom_level);
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_column_count(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", NULL };
++    int zoom_level;
++    guint ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.MapSource.get_column_count", kwlist, &zoom_level))
++        return NULL;
++    
++    ret = champlain_map_source_get_column_count(CHAMPLAIN_MAP_SOURCE(self->obj), zoom_level);
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_fill_tile(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "tile", NULL };
++    PyGObject *tile;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.MapSource.fill_tile", kwlist, &PyChamplainTile_Type, &tile))
++        return NULL;
++    
++    champlain_map_source_fill_tile(CHAMPLAIN_MAP_SOURCE(self->obj), CHAMPLAIN_TILE(tile->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_set_id(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "id", NULL };
++    char *id;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.MapSource.set_id", kwlist, &id))
++        return NULL;
++    
++    champlain_map_source_set_id(CHAMPLAIN_MAP_SOURCE(self->obj), id);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_id(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_map_source_get_id(CHAMPLAIN_MAP_SOURCE(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_set_name(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "name", NULL };
++    char *name;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.MapSource.set_name", kwlist, &name))
++        return NULL;
++    
++    champlain_map_source_set_name(CHAMPLAIN_MAP_SOURCE(self->obj), name);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_name(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_map_source_get_name(CHAMPLAIN_MAP_SOURCE(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_set_license(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "license", NULL };
++    char *license;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.MapSource.set_license", kwlist, &license))
++        return NULL;
++    
++    champlain_map_source_set_license(CHAMPLAIN_MAP_SOURCE(self->obj), license);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_license(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_map_source_get_license(CHAMPLAIN_MAP_SOURCE(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_set_license_uri(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "license_uri", NULL };
++    char *license_uri;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.MapSource.set_license_uri", kwlist, &license_uri))
++        return NULL;
++    
++    champlain_map_source_set_license_uri(CHAMPLAIN_MAP_SOURCE(self->obj), license_uri);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_license_uri(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_map_source_get_license_uri(CHAMPLAIN_MAP_SOURCE(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_set_projection(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "projection", NULL };
++    PyObject *py_projection = NULL;
++    ChamplainMapProjection projection;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.MapSource.set_projection", kwlist, &py_projection))
++        return NULL;
++    if (pyg_enum_get_value(CHAMPLAIN_TYPE_MAP_PROJECTION, py_projection, (gpointer)&projection))
++        return NULL;
++    
++    champlain_map_source_set_projection(CHAMPLAIN_MAP_SOURCE(self->obj), projection);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_projection(PyGObject *self)
++{
++    gint ret;
++
++    
++    ret = champlain_map_source_get_projection(CHAMPLAIN_MAP_SOURCE(self->obj));
++    
++    return pyg_enum_from_gtype(CHAMPLAIN_TYPE_MAP_PROJECTION, ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_get_meters_per_pixel(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", "latitude", "longitude", NULL };
++    int zoom_level;
++    double latitude, longitude, ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"idd:Champlain.MapSource.get_meters_per_pixel", kwlist, &zoom_level, &latitude, &longitude))
++        return NULL;
++    
++    ret = champlain_map_source_get_meters_per_pixel(CHAMPLAIN_MAP_SOURCE(self->obj), zoom_level, latitude, longitude);
++    
++    return PyFloat_FromDouble(ret);
++}
++
++static const PyMethodDef _PyChamplainMapSource_methods[] = {
++    { "get_min_zoom_level", (PyCFunction)_wrap_champlain_map_source_get_min_zoom_level, METH_NOARGS,
++      NULL },
++    { "get_max_zoom_level", (PyCFunction)_wrap_champlain_map_source_get_max_zoom_level, METH_NOARGS,
++      NULL },
++    { "get_tile_size", (PyCFunction)_wrap_champlain_map_source_get_tile_size, METH_NOARGS,
++      NULL },
++    { "get_x", (PyCFunction)_wrap_champlain_map_source_get_x, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_y", (PyCFunction)_wrap_champlain_map_source_get_y, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_longitude", (PyCFunction)_wrap_champlain_map_source_get_longitude, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_latitude", (PyCFunction)_wrap_champlain_map_source_get_latitude, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_row_count", (PyCFunction)_wrap_champlain_map_source_get_row_count, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_column_count", (PyCFunction)_wrap_champlain_map_source_get_column_count, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "fill_tile", (PyCFunction)_wrap_champlain_map_source_fill_tile, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_id", (PyCFunction)_wrap_champlain_map_source_set_id, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_id", (PyCFunction)_wrap_champlain_map_source_get_id, METH_NOARGS,
++      NULL },
++    { "set_name", (PyCFunction)_wrap_champlain_map_source_set_name, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_name", (PyCFunction)_wrap_champlain_map_source_get_name, METH_NOARGS,
++      NULL },
++    { "set_license", (PyCFunction)_wrap_champlain_map_source_set_license, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_license", (PyCFunction)_wrap_champlain_map_source_get_license, METH_NOARGS,
++      NULL },
++    { "set_license_uri", (PyCFunction)_wrap_champlain_map_source_set_license_uri, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_license_uri", (PyCFunction)_wrap_champlain_map_source_get_license_uri, METH_NOARGS,
++      NULL },
++    { "set_projection", (PyCFunction)_wrap_champlain_map_source_set_projection, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_projection", (PyCFunction)_wrap_champlain_map_source_get_projection, METH_NOARGS,
++      NULL },
++    { "get_meters_per_pixel", (PyCFunction)_wrap_champlain_map_source_get_meters_per_pixel, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainMapSource_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.MapSource",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainMapSource_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_map_source_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainMapSourceFactory ----------- */
++
++#line 31 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_map_source_factory_dup_list(PyGObject *self) {
++    GSList *iter, *list;
++    PyObject *ret;
++    PyObject *pydesc;
++
++    list = champlain_map_source_factory_dup_list(
++        CHAMPLAIN_MAP_SOURCE_FACTORY(self->obj));
++	
++    ret = PyList_New(0);    
++    for(iter = list; iter != NULL; iter = iter->next) {
++        ChamplainMapSourceDesc *desc = (ChamplainMapSourceDesc *) iter->data;
++        pydesc = pyg_boxed_new(CHAMPLAIN_TYPE_MAP_SOURCE_DESC, desc, TRUE, TRUE);
++        PyList_Append(ret, pydesc);
++    }
++
++    g_slist_free(list);
++    g_slist_free(iter);
++    return ret;
++}
++#line 1553 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_map_source_factory_create(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "id", NULL };
++    char *id;
++    ChamplainMapSource *ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.MapSourceFactory.create", kwlist, &id))
++        return NULL;
++    
++    ret = champlain_map_source_factory_create(CHAMPLAIN_MAP_SOURCE_FACTORY(self->obj), id);
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++#line 53 "./pychamplain.override"
++static PyObject *_pycallback = NULL;
++
++static ChamplainMapSource *
++champlain_map_source_constructor(ChamplainMapSourceDesc *desc, gpointer data)
++{
++    PyObject *pymap_source = NULL;
++    PyObject *pydesc;
++
++    pydesc = pyg_boxed_new(CHAMPLAIN_TYPE_MAP_SOURCE_DESC, desc, TRUE, TRUE);
++    pymap_source = PyObject_CallFunction(_pycallback, "(OO)", pydesc, data);
++    if (pymap_source == NULL){
++        if (PyErr_Occurred())
++            PyErr_Print();
++        return NULL;
++    }
++    return CHAMPLAIN_MAP_SOURCE(((PyGObject *)pymap_source)->obj);
++}
++
++static PyObject *
++_wrap_champlain_map_source_factory_register(PyGObject *self, PyObject *args, 
++    PyObject *kargs) 
++{
++    ChamplainMapSourceDesc *desc;
++    PyObject *pydesc = NULL, *pyconstructor = NULL, *pyuser_data = NULL;
++    static char *kwlist[] = {"desc", "constructor", "user_data", NULL};
++
++    if (!PyArg_ParseTupleAndKeywords(args, kargs, "OO|O:ChamplainMapSourceFactory.register", 
++        kwlist, &pydesc, &pyconstructor, &pyuser_data))
++        return NULL;
++   
++    if (pyg_boxed_check(pydesc, CHAMPLAIN_TYPE_MAP_SOURCE_DESC))
++        desc = pyg_boxed_get(pydesc, ChamplainMapSourceDesc);
++    else {
++        PyErr_SetString(PyExc_TypeError, "desc must be a MapSourceDesc");
++        return NULL;
++    }
++
++    if (!pyconstructor || !PyCallable_Check(pyconstructor)) {
++        PyErr_SetString(PyExc_TypeError, "constructor parameter must be callable");
++        return NULL;
++    }
++    Py_XINCREF(pyconstructor);  /* Add a reference to new callback */
++    Py_XDECREF(_pycallback); /* Dispose of previous callback */
++    _pycallback = pyconstructor;
++    return PyBool_FromLong(champlain_map_source_factory_register(
++        CHAMPLAIN_MAP_SOURCE_FACTORY(self->obj), desc, 
++        champlain_map_source_constructor, (gpointer)pyuser_data));
++}
++#line 1621 "./pychamplain.c"
++
++
++static const PyMethodDef _PyChamplainMapSourceFactory_methods[] = {
++    { "dup_list", (PyCFunction)_wrap_champlain_map_source_factory_dup_list, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "create", (PyCFunction)_wrap_champlain_map_source_factory_create, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "register", (PyCFunction)_wrap_champlain_map_source_factory_register, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainMapSourceFactory_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.MapSourceFactory",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainMapSourceFactory_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)0,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainMarker ----------- */
++
++static int
++_wrap_champlain_marker_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.Marker.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.Marker object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_text(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "text", NULL };
++    char *text;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.Marker.set_text", kwlist, &text))
++        return NULL;
++    
++    champlain_marker_set_text(CHAMPLAIN_MARKER(self->obj), text);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_image(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "image", NULL };
++    PyGObject *image;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.Marker.set_image", kwlist, &PyClutterActor_Type, &image))
++        return NULL;
++    
++    champlain_marker_set_image(CHAMPLAIN_MARKER(self->obj), CLUTTER_ACTOR(image->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_use_markup(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "use_markup", NULL };
++    int use_markup;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Marker.set_use_markup", kwlist, &use_markup))
++        return NULL;
++    
++    champlain_marker_set_use_markup(CHAMPLAIN_MARKER(self->obj), use_markup);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_alignment(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "alignment", NULL };
++    PyObject *py_alignment = NULL;
++    PangoAlignment alignment;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Marker.set_alignment", kwlist, &py_alignment))
++        return NULL;
++    if (pyg_enum_get_value(PANGO_TYPE_ALIGNMENT, py_alignment, (gpointer)&alignment))
++        return NULL;
++    
++    champlain_marker_set_alignment(CHAMPLAIN_MARKER(self->obj), alignment);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_color(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "color", NULL };
++    ClutterColor *color = NULL;
++    PyObject *py_color;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Marker.set_color", kwlist, &py_color))
++        return NULL;
++    if (pyg_boxed_check(py_color, CLUTTER_TYPE_COLOR))
++        color = pyg_boxed_get(py_color, ClutterColor);
++    else {
++        PyErr_SetString(PyExc_TypeError, "color should be a ClutterColor");
++        return NULL;
++    }
++    
++    champlain_marker_set_color(CHAMPLAIN_MARKER(self->obj), color);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_text_color(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "color", NULL };
++    ClutterColor *color = NULL;
++    PyObject *py_color;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Marker.set_text_color", kwlist, &py_color))
++        return NULL;
++    if (pyg_boxed_check(py_color, CLUTTER_TYPE_COLOR))
++        color = pyg_boxed_get(py_color, ClutterColor);
++    else {
++        PyErr_SetString(PyExc_TypeError, "color should be a ClutterColor");
++        return NULL;
++    }
++    
++    champlain_marker_set_text_color(CHAMPLAIN_MARKER(self->obj), color);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_font_name(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "font_name", NULL };
++    char *font_name;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.Marker.set_font_name", kwlist, &font_name))
++        return NULL;
++    
++    champlain_marker_set_font_name(CHAMPLAIN_MARKER(self->obj), font_name);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_wrap(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "wrap", NULL };
++    int wrap;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Marker.set_wrap", kwlist, &wrap))
++        return NULL;
++    
++    champlain_marker_set_wrap(CHAMPLAIN_MARKER(self->obj), wrap);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_wrap_mode(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "wrap_mode", NULL };
++    PyObject *py_wrap_mode = NULL;
++    PangoWrapMode wrap_mode;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Marker.set_wrap_mode", kwlist, &py_wrap_mode))
++        return NULL;
++    if (pyg_enum_get_value(PANGO_TYPE_WRAP_MODE, py_wrap_mode, (gpointer)&wrap_mode))
++        return NULL;
++    
++    champlain_marker_set_wrap_mode(CHAMPLAIN_MARKER(self->obj), wrap_mode);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_attributes(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "list", NULL };
++    PyObject *py_list;
++    PangoAttrList *list = NULL;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Marker.set_attributes", kwlist, &py_list))
++        return NULL;
++    if (pyg_boxed_check(py_list, PANGO_TYPE_ATTR_LIST))
++        list = pyg_boxed_get(py_list, PangoAttrList);
++    else {
++        PyErr_SetString(PyExc_TypeError, "list should be a PangoAttrList");
++        return NULL;
++    }
++    
++    champlain_marker_set_attributes(CHAMPLAIN_MARKER(self->obj), list);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_single_line_mode(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "mode", NULL };
++    int mode;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Marker.set_single_line_mode", kwlist, &mode))
++        return NULL;
++    
++    champlain_marker_set_single_line_mode(CHAMPLAIN_MARKER(self->obj), mode);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_ellipsize(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "mode", NULL };
++    PyObject *py_mode = NULL;
++    PangoEllipsizeMode mode;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Marker.set_ellipsize", kwlist, &py_mode))
++        return NULL;
++    if (pyg_enum_get_value(PANGO_TYPE_ELLIPSIZE_MODE, py_mode, (gpointer)&mode))
++        return NULL;
++    
++    champlain_marker_set_ellipsize(CHAMPLAIN_MARKER(self->obj), mode);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_set_draw_background(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "background", NULL };
++    int background;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Marker.set_draw_background", kwlist, &background))
++        return NULL;
++    
++    champlain_marker_set_draw_background(CHAMPLAIN_MARKER(self->obj), background);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_get_use_markup(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_marker_get_use_markup(CHAMPLAIN_MARKER(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_marker_get_text(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_marker_get_text(CHAMPLAIN_MARKER(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_get_image(PyGObject *self)
++{
++    ClutterActor *ret;
++
++    
++    ret = champlain_marker_get_image(CHAMPLAIN_MARKER(self->obj));
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static PyObject *
++_wrap_champlain_marker_get_alignment(PyGObject *self)
++{
++    gint ret;
++
++    
++    ret = champlain_marker_get_alignment(CHAMPLAIN_MARKER(self->obj));
++    
++    return pyg_enum_from_gtype(PANGO_TYPE_ALIGNMENT, ret);
++}
++
++static PyObject *
++_wrap_champlain_marker_get_color(PyGObject *self)
++{
++    ClutterColor *ret;
++
++    
++    ret = champlain_marker_get_color(CHAMPLAIN_MARKER(self->obj));
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CLUTTER_TYPE_COLOR, ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_marker_get_text_color(PyGObject *self)
++{
++    ClutterColor *ret;
++
++    
++    ret = champlain_marker_get_text_color(CHAMPLAIN_MARKER(self->obj));
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CLUTTER_TYPE_COLOR, ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_marker_get_font_name(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_marker_get_font_name(CHAMPLAIN_MARKER(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_get_wrap(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_marker_get_wrap(CHAMPLAIN_MARKER(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_marker_get_wrap_mode(PyGObject *self)
++{
++    gint ret;
++
++    
++    ret = champlain_marker_get_wrap_mode(CHAMPLAIN_MARKER(self->obj));
++    
++    return pyg_enum_from_gtype(PANGO_TYPE_WRAP_MODE, ret);
++}
++
++static PyObject *
++_wrap_champlain_marker_get_ellipsize(PyGObject *self)
++{
++    gint ret;
++
++    
++    ret = champlain_marker_get_ellipsize(CHAMPLAIN_MARKER(self->obj));
++    
++    return pyg_enum_from_gtype(PANGO_TYPE_ELLIPSIZE_MODE, ret);
++}
++
++static PyObject *
++_wrap_champlain_marker_get_single_line_mode(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_marker_get_single_line_mode(CHAMPLAIN_MARKER(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_marker_get_draw_background(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_marker_get_draw_background(CHAMPLAIN_MARKER(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_marker_queue_redraw(PyGObject *self)
++{
++    
++    champlain_marker_queue_redraw(CHAMPLAIN_MARKER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static const PyMethodDef _PyChamplainMarker_methods[] = {
++    { "set_text", (PyCFunction)_wrap_champlain_marker_set_text, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_image", (PyCFunction)_wrap_champlain_marker_set_image, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_use_markup", (PyCFunction)_wrap_champlain_marker_set_use_markup, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_alignment", (PyCFunction)_wrap_champlain_marker_set_alignment, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_color", (PyCFunction)_wrap_champlain_marker_set_color, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_text_color", (PyCFunction)_wrap_champlain_marker_set_text_color, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_font_name", (PyCFunction)_wrap_champlain_marker_set_font_name, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_wrap", (PyCFunction)_wrap_champlain_marker_set_wrap, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_wrap_mode", (PyCFunction)_wrap_champlain_marker_set_wrap_mode, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_attributes", (PyCFunction)_wrap_champlain_marker_set_attributes, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_single_line_mode", (PyCFunction)_wrap_champlain_marker_set_single_line_mode, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_ellipsize", (PyCFunction)_wrap_champlain_marker_set_ellipsize, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_draw_background", (PyCFunction)_wrap_champlain_marker_set_draw_background, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_use_markup", (PyCFunction)_wrap_champlain_marker_get_use_markup, METH_NOARGS,
++      NULL },
++    { "get_text", (PyCFunction)_wrap_champlain_marker_get_text, METH_NOARGS,
++      NULL },
++    { "get_image", (PyCFunction)_wrap_champlain_marker_get_image, METH_NOARGS,
++      NULL },
++    { "get_alignment", (PyCFunction)_wrap_champlain_marker_get_alignment, METH_NOARGS,
++      NULL },
++    { "get_color", (PyCFunction)_wrap_champlain_marker_get_color, METH_NOARGS,
++      NULL },
++    { "get_text_color", (PyCFunction)_wrap_champlain_marker_get_text_color, METH_NOARGS,
++      NULL },
++    { "get_font_name", (PyCFunction)_wrap_champlain_marker_get_font_name, METH_NOARGS,
++      NULL },
++    { "get_wrap", (PyCFunction)_wrap_champlain_marker_get_wrap, METH_NOARGS,
++      NULL },
++    { "get_wrap_mode", (PyCFunction)_wrap_champlain_marker_get_wrap_mode, METH_NOARGS,
++      NULL },
++    { "get_ellipsize", (PyCFunction)_wrap_champlain_marker_get_ellipsize, METH_NOARGS,
++      NULL },
++    { "get_single_line_mode", (PyCFunction)_wrap_champlain_marker_get_single_line_mode, METH_NOARGS,
++      NULL },
++    { "get_draw_background", (PyCFunction)_wrap_champlain_marker_get_draw_background, METH_NOARGS,
++      NULL },
++    { "queue_redraw", (PyCFunction)_wrap_champlain_marker_queue_redraw, METH_NOARGS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainMarker_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.Marker",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainMarker_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_marker_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainNetworkMapSource ----------- */
++
++static int
++_wrap_champlain_network_map_source_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.NetworkMapSource.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.NetworkMapSource object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_network_map_source_get_tile_uri(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "x", "y", "z", NULL };
++    int x, y, z;
++    gchar *ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iii:Champlain.NetworkMapSource.get_tile_uri", kwlist, &x, &y, &z))
++        return NULL;
++    
++    ret = champlain_network_map_source_get_tile_uri(CHAMPLAIN_NETWORK_MAP_SOURCE(self->obj), x, y, z);
++    
++    if (ret) {
++        PyObject *py_ret = PyString_FromString(ret);
++        g_free(ret);
++        return py_ret;
++    }
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_network_map_source_set_uri_format(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "uri_format", NULL };
++    char *uri_format;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.NetworkMapSource.set_uri_format", kwlist, &uri_format))
++        return NULL;
++    
++    champlain_network_map_source_set_uri_format(CHAMPLAIN_NETWORK_MAP_SOURCE(self->obj), uri_format);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static const PyMethodDef _PyChamplainNetworkMapSource_methods[] = {
++    { "get_tile_uri", (PyCFunction)_wrap_champlain_network_map_source_get_tile_uri, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_uri_format", (PyCFunction)_wrap_champlain_network_map_source_set_uri_format, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainNetworkMapSource_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.NetworkMapSource",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainNetworkMapSource_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_network_map_source_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainPolygon ----------- */
++
++static int
++_wrap_champlain_polygon_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.Polygon.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.Polygon object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_polygon_append_point(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "lat", "lon", NULL };
++    double lat, lon;
++    ChamplainPoint *ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Champlain.Polygon.append_point", kwlist, &lat, &lon))
++        return NULL;
++    
++    ret = champlain_polygon_append_point(CHAMPLAIN_POLYGON(self->obj), lat, lon);
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CHAMPLAIN_TYPE_POINT, ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_polygon_insert_point(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "lat", "lon", "pos", NULL };
++    int pos;
++    double lat, lon;
++    ChamplainPoint *ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ddi:Champlain.Polygon.insert_point", kwlist, &lat, &lon, &pos))
++        return NULL;
++    
++    ret = champlain_polygon_insert_point(CHAMPLAIN_POLYGON(self->obj), lat, lon, pos);
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CHAMPLAIN_TYPE_POINT, ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_polygon_remove_point(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "point", NULL };
++    PyObject *py_point;
++    ChamplainPoint *point = NULL;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Polygon.remove_point", kwlist, &py_point))
++        return NULL;
++    if (pyg_boxed_check(py_point, CHAMPLAIN_TYPE_POINT))
++        point = pyg_boxed_get(py_point, ChamplainPoint);
++    else {
++        PyErr_SetString(PyExc_TypeError, "point should be a ChamplainPoint");
++        return NULL;
++    }
++    
++    champlain_polygon_remove_point(CHAMPLAIN_POLYGON(self->obj), point);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_polygon_clear_points(PyGObject *self)
++{
++    
++    champlain_polygon_clear_points(CHAMPLAIN_POLYGON(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++#line 103 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_polygon_get_points(PyGObject *self, PyObject *args) 
++{
++    GList *iter, *list = champlain_polygon_get_points(CHAMPLAIN_POLYGON(self->obj));
++    PyObject *ret = PyList_New(0);
++    PyObject *pypoint;
++
++	for(iter = list; iter != NULL; iter = iter->next) {
++		ChamplainPoint *point = (ChamplainPoint *) iter->data;
++        pypoint = pyg_boxed_new(CHAMPLAIN_TYPE_POINT, point, TRUE, TRUE);
++		PyList_Append(ret, pypoint);
++		Py_DECREF(pypoint);
++    }
++    return ret;
++}
++#line 2402 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_polygon_set_fill_color(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "color", NULL };
++    ClutterColor *color = NULL;
++    PyObject *py_color;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Polygon.set_fill_color", kwlist, &py_color))
++        return NULL;
++    if (pyg_boxed_check(py_color, CLUTTER_TYPE_COLOR))
++        color = pyg_boxed_get(py_color, ClutterColor);
++    else {
++        PyErr_SetString(PyExc_TypeError, "color should be a ClutterColor");
++        return NULL;
++    }
++    
++    champlain_polygon_set_fill_color(CHAMPLAIN_POLYGON(self->obj), color);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_polygon_set_stroke_color(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "color", NULL };
++    ClutterColor *color = NULL;
++    PyObject *py_color;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Polygon.set_stroke_color", kwlist, &py_color))
++        return NULL;
++    if (pyg_boxed_check(py_color, CLUTTER_TYPE_COLOR))
++        color = pyg_boxed_get(py_color, ClutterColor);
++    else {
++        PyErr_SetString(PyExc_TypeError, "color should be a ClutterColor");
++        return NULL;
++    }
++    
++    champlain_polygon_set_stroke_color(CHAMPLAIN_POLYGON(self->obj), color);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_polygon_get_fill_color(PyGObject *self)
++{
++    ClutterColor *ret;
++
++    
++    ret = champlain_polygon_get_fill_color(CHAMPLAIN_POLYGON(self->obj));
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CLUTTER_TYPE_COLOR, ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_polygon_get_stroke_color(PyGObject *self)
++{
++    ClutterColor *ret;
++
++    
++    ret = champlain_polygon_get_stroke_color(CHAMPLAIN_POLYGON(self->obj));
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CLUTTER_TYPE_COLOR, ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_polygon_get_fill(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_polygon_get_fill(CHAMPLAIN_POLYGON(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_polygon_set_fill(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    int value;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Polygon.set_fill", kwlist, &value))
++        return NULL;
++    
++    champlain_polygon_set_fill(CHAMPLAIN_POLYGON(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_polygon_get_stroke(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_polygon_get_stroke(CHAMPLAIN_POLYGON(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_polygon_set_stroke(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    int value;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Polygon.set_stroke", kwlist, &value))
++        return NULL;
++    
++    champlain_polygon_set_stroke(CHAMPLAIN_POLYGON(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_polygon_set_stroke_width(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    double value;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"d:Champlain.Polygon.set_stroke_width", kwlist, &value))
++        return NULL;
++    
++    champlain_polygon_set_stroke_width(CHAMPLAIN_POLYGON(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_polygon_get_stroke_width(PyGObject *self)
++{
++    double ret;
++
++    
++    ret = champlain_polygon_get_stroke_width(CHAMPLAIN_POLYGON(self->obj));
++    
++    return PyFloat_FromDouble(ret);
++}
++
++static PyObject *
++_wrap_champlain_polygon_set_mark_points(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    int value;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Polygon.set_mark_points", kwlist, &value))
++        return NULL;
++    
++    champlain_polygon_set_mark_points(CHAMPLAIN_POLYGON(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_polygon_get_mark_points(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_polygon_get_mark_points(CHAMPLAIN_POLYGON(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_polygon_show(PyGObject *self)
++{
++    
++    champlain_polygon_show(CHAMPLAIN_POLYGON(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_polygon_hide(PyGObject *self)
++{
++    
++    champlain_polygon_hide(CHAMPLAIN_POLYGON(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static const PyMethodDef _PyChamplainPolygon_methods[] = {
++    { "append_point", (PyCFunction)_wrap_champlain_polygon_append_point, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "insert_point", (PyCFunction)_wrap_champlain_polygon_insert_point, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "remove_point", (PyCFunction)_wrap_champlain_polygon_remove_point, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "clear_points", (PyCFunction)_wrap_champlain_polygon_clear_points, METH_NOARGS,
++      NULL },
++    { "get_points", (PyCFunction)_wrap_champlain_polygon_get_points, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_fill_color", (PyCFunction)_wrap_champlain_polygon_set_fill_color, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_stroke_color", (PyCFunction)_wrap_champlain_polygon_set_stroke_color, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_fill_color", (PyCFunction)_wrap_champlain_polygon_get_fill_color, METH_NOARGS,
++      NULL },
++    { "get_stroke_color", (PyCFunction)_wrap_champlain_polygon_get_stroke_color, METH_NOARGS,
++      NULL },
++    { "get_fill", (PyCFunction)_wrap_champlain_polygon_get_fill, METH_NOARGS,
++      NULL },
++    { "set_fill", (PyCFunction)_wrap_champlain_polygon_set_fill, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_stroke", (PyCFunction)_wrap_champlain_polygon_get_stroke, METH_NOARGS,
++      NULL },
++    { "set_stroke", (PyCFunction)_wrap_champlain_polygon_set_stroke, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_stroke_width", (PyCFunction)_wrap_champlain_polygon_set_stroke_width, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_stroke_width", (PyCFunction)_wrap_champlain_polygon_get_stroke_width, METH_NOARGS,
++      NULL },
++    { "set_mark_points", (PyCFunction)_wrap_champlain_polygon_set_mark_points, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_mark_points", (PyCFunction)_wrap_champlain_polygon_get_mark_points, METH_NOARGS,
++      NULL },
++    { "show", (PyCFunction)_wrap_champlain_polygon_show, METH_NOARGS,
++      NULL },
++    { "hide", (PyCFunction)_wrap_champlain_polygon_hide, METH_NOARGS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++#line 559 "./pychamplain.override"
++static void
++_wrap_champlain_polygon_tp_dealloc (PyObject *self)
++{
++    self->ob_type->tp_free((PyObject*)self);
++}
++#line 2648 "./pychamplain.c"
++
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainPolygon_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.Polygon",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)_wrap_champlain_polygon_tp_dealloc,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainPolygon_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_polygon_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainSelectionLayer ----------- */
++
++static int
++_wrap_champlain_selection_layer_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.SelectionLayer.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.SelectionLayer object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_selection_layer_get_selected(PyGObject *self)
++{
++    ChamplainBaseMarker *ret;
++
++    
++    ret = champlain_selection_layer_get_selected(CHAMPLAIN_SELECTION_LAYER(self->obj));
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++#line 496 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_selection_layer_get_selected_markers(PyGObject *self) {
++    const GList *iter, *list;
++    PyObject *ret;
++
++    list = champlain_selection_layer_get_selected_markers(
++        CHAMPLAIN_SELECTION_LAYER(self->obj));
++       
++    if ((ret = PyList_New(0)) == NULL)
++        return NULL;
++
++    for(iter = list; iter != NULL; iter = iter->next) {
++        ChamplainMarker *marker = (ChamplainMarker *) iter->data;
++        PyObject *py_marker = NULL;
++
++        py_marker = pygobject_new((GObject *) marker);
++        if (!py_marker){
++            Py_DECREF(ret);
++            return NULL;
++        }
++        PyList_Append(ret, py_marker);
++        Py_DECREF(py_marker);
++    }
++    return ret;
++}
++#line 2758 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_selection_layer_count_selected_markers(PyGObject *self)
++{
++    guint ret;
++
++    
++    ret = champlain_selection_layer_count_selected_markers(CHAMPLAIN_SELECTION_LAYER(self->obj));
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_selection_layer_select(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "marker", NULL };
++    PyGObject *marker;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.SelectionLayer.select", kwlist, &PyChamplainBaseMarker_Type, &marker))
++        return NULL;
++    
++    champlain_selection_layer_select(CHAMPLAIN_SELECTION_LAYER(self->obj), CHAMPLAIN_BASE_MARKER(marker->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_selection_layer_unselect(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "marker", NULL };
++    PyGObject *marker;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.SelectionLayer.unselect", kwlist, &PyChamplainBaseMarker_Type, &marker))
++        return NULL;
++    
++    champlain_selection_layer_unselect(CHAMPLAIN_SELECTION_LAYER(self->obj), CHAMPLAIN_BASE_MARKER(marker->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_selection_layer_marker_is_selected(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "marker", NULL };
++    PyGObject *marker;
++    int ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.SelectionLayer.marker_is_selected", kwlist, &PyChamplainBaseMarker_Type, &marker))
++        return NULL;
++    
++    ret = champlain_selection_layer_marker_is_selected(CHAMPLAIN_SELECTION_LAYER(self->obj), CHAMPLAIN_BASE_MARKER(marker->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_selection_layer_select_all(PyGObject *self)
++{
++    
++    champlain_selection_layer_select_all(CHAMPLAIN_SELECTION_LAYER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_selection_layer_unselect_all(PyGObject *self)
++{
++    
++    champlain_selection_layer_unselect_all(CHAMPLAIN_SELECTION_LAYER(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_selection_layer_set_selection_mode(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "mode", NULL };
++    PyObject *py_mode = NULL;
++    ChamplainSelectionMode mode;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.SelectionLayer.set_selection_mode", kwlist, &py_mode))
++        return NULL;
++    if (pyg_enum_get_value(CHAMPLAIN_TYPE_SELECTION_MODE, py_mode, (gpointer)&mode))
++        return NULL;
++    
++    champlain_selection_layer_set_selection_mode(CHAMPLAIN_SELECTION_LAYER(self->obj), mode);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_selection_layer_get_selection_mode(PyGObject *self)
++{
++    gint ret;
++
++    
++    ret = champlain_selection_layer_get_selection_mode(CHAMPLAIN_SELECTION_LAYER(self->obj));
++    
++    return pyg_enum_from_gtype(CHAMPLAIN_TYPE_SELECTION_MODE, ret);
++}
++
++static const PyMethodDef _PyChamplainSelectionLayer_methods[] = {
++    { "get_selected", (PyCFunction)_wrap_champlain_selection_layer_get_selected, METH_NOARGS,
++      NULL },
++    { "get_selected_markers", (PyCFunction)_wrap_champlain_selection_layer_get_selected_markers, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "count_selected_markers", (PyCFunction)_wrap_champlain_selection_layer_count_selected_markers, METH_NOARGS,
++      NULL },
++    { "select", (PyCFunction)_wrap_champlain_selection_layer_select, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "unselect", (PyCFunction)_wrap_champlain_selection_layer_unselect, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "marker_is_selected", (PyCFunction)_wrap_champlain_selection_layer_marker_is_selected, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "select_all", (PyCFunction)_wrap_champlain_selection_layer_select_all, METH_NOARGS,
++      NULL },
++    { "unselect_all", (PyCFunction)_wrap_champlain_selection_layer_unselect_all, METH_NOARGS,
++      NULL },
++    { "set_selection_mode", (PyCFunction)_wrap_champlain_selection_layer_set_selection_mode, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_selection_mode", (PyCFunction)_wrap_champlain_selection_layer_get_selection_mode, METH_NOARGS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainSelectionLayer_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.SelectionLayer",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainSelectionLayer_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_selection_layer_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainTile ----------- */
++
++static int
++_wrap_champlain_tile_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.Tile.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.Tile object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_tile_get_x(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_tile_get_x(CHAMPLAIN_TILE(self->obj));
++    
++    return PyInt_FromLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_tile_get_y(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_tile_get_y(CHAMPLAIN_TILE(self->obj));
++    
++    return PyInt_FromLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_tile_get_zoom_level(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_tile_get_zoom_level(CHAMPLAIN_TILE(self->obj));
++    
++    return PyInt_FromLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_tile_get_size(PyGObject *self)
++{
++    guint ret;
++
++    
++    ret = champlain_tile_get_size(CHAMPLAIN_TILE(self->obj));
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_tile_get_state(PyGObject *self)
++{
++    gint ret;
++
++    
++    ret = champlain_tile_get_state(CHAMPLAIN_TILE(self->obj));
++    
++    return pyg_enum_from_gtype(CHAMPLAIN_TYPE_STATE, ret);
++}
++
++static PyObject *
++_wrap_champlain_tile_get_uri(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_tile_get_uri(CHAMPLAIN_TILE(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_get_filename(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_tile_get_filename(CHAMPLAIN_TILE(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_get_actor(PyGObject *self)
++{
++    ClutterActor *ret;
++
++    
++    ret = champlain_tile_get_actor(CHAMPLAIN_TILE(self->obj));
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static PyObject *
++_wrap_champlain_tile_get_content(PyGObject *self)
++{
++    ClutterActor *ret;
++
++    
++    ret = champlain_tile_get_content(CHAMPLAIN_TILE(self->obj));
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++#line 266 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_tile_get_modified_time(PyGObject *self, PyObject *args) 
++{
++    const GTimeVal *modified_time = NULL;
++
++    modified_time = champlain_tile_get_modified_time(CHAMPLAIN_TILE(self->obj));
++    if (modified_time == NULL){
++        Py_INCREF(Py_None);
++        return Py_None;
++    }
++
++    return PyFloat_FromDouble((double)modified_time->tv_sec + \
++        (double)modified_time->tv_usec * 0.000001);
++}
++#line 3082 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_tile_get_modified_time_string(PyGObject *self)
++{
++    gchar *ret;
++
++    
++    ret = champlain_tile_get_modified_time_string(CHAMPLAIN_TILE(self->obj));
++    
++    if (ret) {
++        PyObject *py_ret = PyString_FromString(ret);
++        g_free(ret);
++        return py_ret;
++    }
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_get_etag(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_tile_get_etag(CHAMPLAIN_TILE(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_set_x(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "x", NULL };
++    int x;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Tile.set_x", kwlist, &x))
++        return NULL;
++    
++    champlain_tile_set_x(CHAMPLAIN_TILE(self->obj), x);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_set_y(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "y", NULL };
++    int y;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Tile.set_y", kwlist, &y))
++        return NULL;
++    
++    champlain_tile_set_y(CHAMPLAIN_TILE(self->obj), y);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_set_zoom_level(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", NULL };
++    int zoom_level;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.Tile.set_zoom_level", kwlist, &zoom_level))
++        return NULL;
++    
++    champlain_tile_set_zoom_level(CHAMPLAIN_TILE(self->obj), zoom_level);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_set_size(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "size", NULL };
++    PyObject *py_size = NULL;
++    guint size = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Tile.set_size", kwlist, &py_size))
++        return NULL;
++    if (py_size) {
++        if (PyLong_Check(py_size))
++            size = PyLong_AsUnsignedLong(py_size);
++        else if (PyInt_Check(py_size))
++            size = PyInt_AsLong(py_size);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'size' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    champlain_tile_set_size(CHAMPLAIN_TILE(self->obj), size);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_set_state(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "state", NULL };
++    PyObject *py_state = NULL;
++    ChamplainState state;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.Tile.set_state", kwlist, &py_state))
++        return NULL;
++    if (pyg_enum_get_value(CHAMPLAIN_TYPE_STATE, py_state, (gpointer)&state))
++        return NULL;
++    
++    champlain_tile_set_state(CHAMPLAIN_TILE(self->obj), state);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_set_uri(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "uri", NULL };
++    char *uri;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.Tile.set_uri", kwlist, &uri))
++        return NULL;
++    
++    champlain_tile_set_uri(CHAMPLAIN_TILE(self->obj), uri);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_set_filename(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "filename", NULL };
++    char *filename;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.Tile.set_filename", kwlist, &filename))
++        return NULL;
++    
++    champlain_tile_set_filename(CHAMPLAIN_TILE(self->obj), filename);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_set_content(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "actor", "fade_in", NULL };
++    PyGObject *actor;
++    int fade_in;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!i:Champlain.Tile.set_content", kwlist, &PyClutterActor_Type, &actor, &fade_in))
++        return NULL;
++    
++    champlain_tile_set_content(CHAMPLAIN_TILE(self->obj), CLUTTER_ACTOR(actor->obj), fade_in);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_tile_set_etag(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "etag", NULL };
++    char *etag;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.Tile.set_etag", kwlist, &etag))
++        return NULL;
++    
++    champlain_tile_set_etag(CHAMPLAIN_TILE(self->obj), etag);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++#line 236 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_tile_set_modified_time(PyGObject *self, PyObject *args,     
++    PyObject *kwargs) 
++{
++    static char *kwlist[] = {"modified_time", NULL};
++    double pymodified_time = 0.0;
++    GTimeVal modified_time = {0,};
++
++    if (!PyArg_ParseTupleAndKeywords(
++            args, kwargs, "d:ChamplainTile.set_modified_time",
++            kwlist, &pymodified_time))
++        return NULL;
++
++    if (pymodified_time < 0.0) {
++        PyErr_SetString(PyExc_ValueError, "modified_time must be >= 0.0");
++        return NULL;
++    }
++
++    if (pymodified_time > 0.0) {
++        modified_time.tv_sec = (glong) pymodified_time;
++        modified_time.tv_usec = (glong)((pymodified_time - modified_time.tv_sec)
++                                    * G_USEC_PER_SEC);
++    } 
++    champlain_tile_set_modified_time(CHAMPLAIN_TILE(self->obj), &modified_time);
++
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++#line 3295 "./pychamplain.c"
++
++
++static const PyMethodDef _PyChamplainTile_methods[] = {
++    { "get_x", (PyCFunction)_wrap_champlain_tile_get_x, METH_NOARGS,
++      NULL },
++    { "get_y", (PyCFunction)_wrap_champlain_tile_get_y, METH_NOARGS,
++      NULL },
++    { "get_zoom_level", (PyCFunction)_wrap_champlain_tile_get_zoom_level, METH_NOARGS,
++      NULL },
++    { "get_size", (PyCFunction)_wrap_champlain_tile_get_size, METH_NOARGS,
++      NULL },
++    { "get_state", (PyCFunction)_wrap_champlain_tile_get_state, METH_NOARGS,
++      NULL },
++    { "get_uri", (PyCFunction)_wrap_champlain_tile_get_uri, METH_NOARGS,
++      NULL },
++    { "get_filename", (PyCFunction)_wrap_champlain_tile_get_filename, METH_NOARGS,
++      NULL },
++    { "get_actor", (PyCFunction)_wrap_champlain_tile_get_actor, METH_NOARGS,
++      NULL },
++    { "get_content", (PyCFunction)_wrap_champlain_tile_get_content, METH_NOARGS,
++      NULL },
++    { "get_modified_time", (PyCFunction)_wrap_champlain_tile_get_modified_time, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_modified_time_string", (PyCFunction)_wrap_champlain_tile_get_modified_time_string, METH_NOARGS,
++      NULL },
++    { "get_etag", (PyCFunction)_wrap_champlain_tile_get_etag, METH_NOARGS,
++      NULL },
++    { "set_x", (PyCFunction)_wrap_champlain_tile_set_x, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_y", (PyCFunction)_wrap_champlain_tile_set_y, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_zoom_level", (PyCFunction)_wrap_champlain_tile_set_zoom_level, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_size", (PyCFunction)_wrap_champlain_tile_set_size, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_state", (PyCFunction)_wrap_champlain_tile_set_state, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_uri", (PyCFunction)_wrap_champlain_tile_set_uri, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_filename", (PyCFunction)_wrap_champlain_tile_set_filename, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_content", (PyCFunction)_wrap_champlain_tile_set_content, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_etag", (PyCFunction)_wrap_champlain_tile_set_etag, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_modified_time", (PyCFunction)_wrap_champlain_tile_set_modified_time, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainTile_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.Tile",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainTile_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_tile_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainView ----------- */
++
++static int
++_wrap_champlain_view_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.View.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.View object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_view_center_on(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "latitude", "longitude", NULL };
++    double latitude, longitude;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Champlain.View.center_on", kwlist, &latitude, &longitude))
++        return NULL;
++    
++    champlain_view_center_on(CHAMPLAIN_VIEW(self->obj), latitude, longitude);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_go_to(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "latitude", "longitude", NULL };
++    double latitude, longitude;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"dd:Champlain.View.go_to", kwlist, &latitude, &longitude))
++        return NULL;
++    
++    champlain_view_go_to(CHAMPLAIN_VIEW(self->obj), latitude, longitude);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_stop_go_to(PyGObject *self)
++{
++    
++    champlain_view_stop_go_to(CHAMPLAIN_VIEW(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_zoom_in(PyGObject *self)
++{
++    
++    champlain_view_zoom_in(CHAMPLAIN_VIEW(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_zoom_out(PyGObject *self)
++{
++    
++    champlain_view_zoom_out(CHAMPLAIN_VIEW(self->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_zoom_level(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", NULL };
++    int zoom_level;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.View.set_zoom_level", kwlist, &zoom_level))
++        return NULL;
++    
++    champlain_view_set_zoom_level(CHAMPLAIN_VIEW(self->obj), zoom_level);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_min_zoom_level(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", NULL };
++    int zoom_level;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.View.set_min_zoom_level", kwlist, &zoom_level))
++        return NULL;
++    
++    champlain_view_set_min_zoom_level(CHAMPLAIN_VIEW(self->obj), zoom_level);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_max_zoom_level(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", NULL };
++    int zoom_level;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.View.set_max_zoom_level", kwlist, &zoom_level))
++        return NULL;
++    
++    champlain_view_set_max_zoom_level(CHAMPLAIN_VIEW(self->obj), zoom_level);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_ensure_visible(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "lat1", "lon1", "lat2", "lon2", "animate", NULL };
++    int animate;
++    double lat1, lon1, lat2, lon2;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ddddi:Champlain.View.ensure_visible", kwlist, &lat1, &lon1, &lat2, &lon2, &animate))
++        return NULL;
++    
++    champlain_view_ensure_visible(CHAMPLAIN_VIEW(self->obj), lat1, lon1, lat2, lon2, animate);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++#line 197 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_view_ensure_markers_visible(PyGObject *self, PyObject *args) 
++{
++    PyObject *pymarkers, *pyanimate=0;
++    gboolean animate = 1; 
++    long i = 0;
++    ChamplainBaseMarker **markers = NULL;
++
++    if (!PyArg_ParseTuple(args, "O|O:ChamplainView.ensure_markers_visible", 
++        &pymarkers, &pyanimate)){
++        return NULL;
++    }
++
++    if (!PySequence_Check(pymarkers)){
++        PyErr_SetString(PyExc_TypeError, 
++            "must be called with a list of markers as first argument");
++        return NULL;
++    }
++
++    if (pyanimate){
++        if (!PyObject_IsTrue(pyanimate))
++            animate = 0;
++    }
++
++    markers = g_new0(ChamplainBaseMarker*, PyList_Size(pymarkers)+2);
++    for (i=0; i < PyList_Size(pymarkers); i++){
++        ChamplainBaseMarker *marker = pyg_boxed_get(PyList_GetItem(pymarkers, i),
++             ChamplainBaseMarker);
++        markers[i] = marker;
++    }
++
++    champlain_view_ensure_markers_visible(CHAMPLAIN_VIEW(self->obj), markers, animate);
++    g_free(markers);
++
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++#line 3574 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_view_set_map_source(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "map_source", NULL };
++    PyGObject *map_source;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.View.set_map_source", kwlist, &PyChamplainMapSource_Type, &map_source))
++        return NULL;
++    
++    champlain_view_set_map_source(CHAMPLAIN_VIEW(self->obj), CHAMPLAIN_MAP_SOURCE(map_source->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++#line 146 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_view_set_size(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "width", "height", NULL };
++    PyObject *py_width = NULL, *py_height = NULL;
++    guint width = 0, height = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"OO:ChamplainView.set_size", kwlist, &py_width, &py_height))
++        return NULL;
++    if (py_width) {
++        if (PyLong_Check(py_width))
++            width = PyLong_AsUnsignedLong(py_width);
++        else if (PyInt_Check(py_width))
++            width = PyInt_AsLong(py_width);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'width' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    if (py_height) {
++        if (PyLong_Check(py_height))
++            height = PyLong_AsUnsignedLong(py_height);
++        else if (PyInt_Check(py_height))
++            height = PyInt_AsLong(py_height);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'height' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++
++    clutter_actor_set_size(CLUTTER_ACTOR(self->obj), width, height);
++
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++#line 3628 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_view_set_decel_rate(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "rate", NULL };
++    double rate;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"d:Champlain.View.set_decel_rate", kwlist, &rate))
++        return NULL;
++    
++    champlain_view_set_decel_rate(CHAMPLAIN_VIEW(self->obj), rate);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_scroll_mode(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "mode", NULL };
++    ChamplainScrollMode mode;
++    PyObject *py_mode = NULL;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.View.set_scroll_mode", kwlist, &py_mode))
++        return NULL;
++    if (pyg_enum_get_value(CHAMPLAIN_TYPE_SCROLL_MODE, py_mode, (gpointer)&mode))
++        return NULL;
++    
++    champlain_view_set_scroll_mode(CHAMPLAIN_VIEW(self->obj), mode);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_keep_center_on_resize(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    int value;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.View.set_keep_center_on_resize", kwlist, &value))
++        return NULL;
++    
++    champlain_view_set_keep_center_on_resize(CHAMPLAIN_VIEW(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_show_license(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    int value;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.View.set_show_license", kwlist, &value))
++        return NULL;
++    
++    champlain_view_set_show_license(CHAMPLAIN_VIEW(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_license_text(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "text", NULL };
++    char *text;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:Champlain.View.set_license_text", kwlist, &text))
++        return NULL;
++    
++    champlain_view_set_license_text(CHAMPLAIN_VIEW(self->obj), text);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_show_scale(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    int value;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.View.set_show_scale", kwlist, &value))
++        return NULL;
++    
++    champlain_view_set_show_scale(CHAMPLAIN_VIEW(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_scale_unit(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "unit", NULL };
++    PyObject *py_unit = NULL;
++    ChamplainUnit unit;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.View.set_scale_unit", kwlist, &py_unit))
++        return NULL;
++    if (pyg_enum_get_value(CHAMPLAIN_TYPE_UNIT, py_unit, (gpointer)&unit))
++        return NULL;
++    
++    champlain_view_set_scale_unit(CHAMPLAIN_VIEW(self->obj), unit);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_max_scale_width(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    PyObject *py_value = NULL;
++    guint value = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.View.set_max_scale_width", kwlist, &py_value))
++        return NULL;
++    if (py_value) {
++        if (PyLong_Check(py_value))
++            value = PyLong_AsUnsignedLong(py_value);
++        else if (PyInt_Check(py_value))
++            value = PyInt_AsLong(py_value);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'value' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    champlain_view_set_max_scale_width(CHAMPLAIN_VIEW(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_set_zoom_on_double_click(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "value", NULL };
++    int value;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.View.set_zoom_on_double_click", kwlist, &value))
++        return NULL;
++    
++    champlain_view_set_zoom_on_double_click(CHAMPLAIN_VIEW(self->obj), value);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_add_layer(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "layer", NULL };
++    PyGObject *layer;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.View.add_layer", kwlist, &PyChamplainLayer_Type, &layer))
++        return NULL;
++    
++    champlain_view_add_layer(CHAMPLAIN_VIEW(self->obj), CHAMPLAIN_LAYER(layer->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_remove_layer(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "layer", NULL };
++    PyGObject *layer;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.View.remove_layer", kwlist, &PyChamplainLayer_Type, &layer))
++        return NULL;
++    
++    champlain_view_remove_layer(CHAMPLAIN_VIEW(self->obj), CHAMPLAIN_LAYER(layer->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++#line 120 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_view_get_coords_from_event(PyGObject *self, PyObject *args, 
++    PyObject *kargs) 
++{
++    static char *kwlist[] = {"event", NULL};
++    gdouble lat, lon;
++    PyObject *pyevent;
++    ClutterEvent *event;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kargs, 
++        "O:ChamplainView.get_coords_from_event", kwlist, &pyevent))
++        return NULL;
++
++    if (pyg_boxed_check(pyevent, CLUTTER_TYPE_EVENT))
++        event = pyg_boxed_get(pyevent, ClutterEvent);
++    else {
++        PyErr_SetString(PyExc_TypeError, "event must be a ClutterEvent");
++        return NULL;
++    }
++ 
++    champlain_view_get_coords_from_event(CHAMPLAIN_VIEW(self->obj), event, &lat, 
++        &lon);
++    return Py_BuildValue("(dd)", lat, lon);
++}
++#line 3838 "./pychamplain.c"
++
++
++#line 183 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_view_get_coords_at(PyGObject *self, PyObject *args) 
++{
++    guint x, y;
++    gdouble lat, lon;
++
++    if (!PyArg_ParseTuple(args, "ii:ChamplainView.get_coords_at", &x, &y))
++        return NULL;
++
++    champlain_view_get_coords_at(CHAMPLAIN_VIEW(self->obj), x, y, &lat, &lon);
++    return Py_BuildValue("(dd)", lat, lon);
++}
++#line 3854 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_view_get_zoom_level(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_view_get_zoom_level(CHAMPLAIN_VIEW(self->obj));
++    
++    return PyInt_FromLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_view_get_min_zoom_level(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_view_get_min_zoom_level(CHAMPLAIN_VIEW(self->obj));
++    
++    return PyInt_FromLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_view_get_max_zoom_level(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_view_get_max_zoom_level(CHAMPLAIN_VIEW(self->obj));
++    
++    return PyInt_FromLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_view_get_map_source(PyGObject *self)
++{
++    ChamplainMapSource *ret;
++
++    
++    ret = champlain_view_get_map_source(CHAMPLAIN_VIEW(self->obj));
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static PyObject *
++_wrap_champlain_view_get_decel_rate(PyGObject *self)
++{
++    double ret;
++
++    
++    ret = champlain_view_get_decel_rate(CHAMPLAIN_VIEW(self->obj));
++    
++    return PyFloat_FromDouble(ret);
++}
++
++static PyObject *
++_wrap_champlain_view_get_scroll_mode(PyGObject *self)
++{
++    gint ret;
++
++    
++    ret = champlain_view_get_scroll_mode(CHAMPLAIN_VIEW(self->obj));
++    
++    return pyg_enum_from_gtype(CHAMPLAIN_TYPE_SCROLL_MODE, ret);
++}
++
++static PyObject *
++_wrap_champlain_view_get_keep_center_on_resize(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_view_get_keep_center_on_resize(CHAMPLAIN_VIEW(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_view_get_show_license(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_view_get_show_license(CHAMPLAIN_VIEW(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_view_get_license_text(PyGObject *self)
++{
++    const gchar *ret;
++
++    
++    ret = champlain_view_get_license_text(CHAMPLAIN_VIEW(self->obj));
++    
++    if (ret)
++        return PyString_FromString(ret);
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_get_show_scale(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_view_get_show_scale(CHAMPLAIN_VIEW(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_view_get_max_scale_width(PyGObject *self)
++{
++    guint ret;
++
++    
++    ret = champlain_view_get_max_scale_width(CHAMPLAIN_VIEW(self->obj));
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_view_get_scale_unit(PyGObject *self)
++{
++    gint ret;
++
++    
++    ret = champlain_view_get_scale_unit(CHAMPLAIN_VIEW(self->obj));
++    
++    return pyg_enum_from_gtype(CHAMPLAIN_TYPE_UNIT, ret);
++}
++
++static PyObject *
++_wrap_champlain_view_get_zoom_on_double_click(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_view_get_zoom_on_double_click(CHAMPLAIN_VIEW(self->obj));
++    
++    return PyBool_FromLong(ret);
++
++}
++
++static PyObject *
++_wrap_champlain_view_add_polygon(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "polygon", NULL };
++    PyGObject *polygon;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.View.add_polygon", kwlist, &PyChamplainPolygon_Type, &polygon))
++        return NULL;
++    
++    champlain_view_add_polygon(CHAMPLAIN_VIEW(self->obj), CHAMPLAIN_POLYGON(polygon->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_view_remove_polygon(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "polygon", NULL };
++    PyGObject *polygon;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.View.remove_polygon", kwlist, &PyChamplainPolygon_Type, &polygon))
++        return NULL;
++    
++    champlain_view_remove_polygon(CHAMPLAIN_VIEW(self->obj), CHAMPLAIN_POLYGON(polygon->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static const PyMethodDef _PyChamplainView_methods[] = {
++    { "center_on", (PyCFunction)_wrap_champlain_view_center_on, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "go_to", (PyCFunction)_wrap_champlain_view_go_to, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "stop_go_to", (PyCFunction)_wrap_champlain_view_stop_go_to, METH_NOARGS,
++      NULL },
++    { "zoom_in", (PyCFunction)_wrap_champlain_view_zoom_in, METH_NOARGS,
++      NULL },
++    { "zoom_out", (PyCFunction)_wrap_champlain_view_zoom_out, METH_NOARGS,
++      NULL },
++    { "set_zoom_level", (PyCFunction)_wrap_champlain_view_set_zoom_level, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_min_zoom_level", (PyCFunction)_wrap_champlain_view_set_min_zoom_level, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_max_zoom_level", (PyCFunction)_wrap_champlain_view_set_max_zoom_level, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "ensure_visible", (PyCFunction)_wrap_champlain_view_ensure_visible, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "ensure_markers_visible", (PyCFunction)_wrap_champlain_view_ensure_markers_visible, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_map_source", (PyCFunction)_wrap_champlain_view_set_map_source, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_size", (PyCFunction)_wrap_champlain_view_set_size, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_decel_rate", (PyCFunction)_wrap_champlain_view_set_decel_rate, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_scroll_mode", (PyCFunction)_wrap_champlain_view_set_scroll_mode, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_keep_center_on_resize", (PyCFunction)_wrap_champlain_view_set_keep_center_on_resize, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_show_license", (PyCFunction)_wrap_champlain_view_set_show_license, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_license_text", (PyCFunction)_wrap_champlain_view_set_license_text, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_show_scale", (PyCFunction)_wrap_champlain_view_set_show_scale, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_scale_unit", (PyCFunction)_wrap_champlain_view_set_scale_unit, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_max_scale_width", (PyCFunction)_wrap_champlain_view_set_max_scale_width, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_zoom_on_double_click", (PyCFunction)_wrap_champlain_view_set_zoom_on_double_click, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "add_layer", (PyCFunction)_wrap_champlain_view_add_layer, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "remove_layer", (PyCFunction)_wrap_champlain_view_remove_layer, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_coords_from_event", (PyCFunction)_wrap_champlain_view_get_coords_from_event, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_coords_at", (PyCFunction)_wrap_champlain_view_get_coords_at, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "get_zoom_level", (PyCFunction)_wrap_champlain_view_get_zoom_level, METH_NOARGS,
++      NULL },
++    { "get_min_zoom_level", (PyCFunction)_wrap_champlain_view_get_min_zoom_level, METH_NOARGS,
++      NULL },
++    { "get_max_zoom_level", (PyCFunction)_wrap_champlain_view_get_max_zoom_level, METH_NOARGS,
++      NULL },
++    { "get_map_source", (PyCFunction)_wrap_champlain_view_get_map_source, METH_NOARGS,
++      NULL },
++    { "get_decel_rate", (PyCFunction)_wrap_champlain_view_get_decel_rate, METH_NOARGS,
++      NULL },
++    { "get_scroll_mode", (PyCFunction)_wrap_champlain_view_get_scroll_mode, METH_NOARGS,
++      NULL },
++    { "get_keep_center_on_resize", (PyCFunction)_wrap_champlain_view_get_keep_center_on_resize, METH_NOARGS,
++      NULL },
++    { "get_show_license", (PyCFunction)_wrap_champlain_view_get_show_license, METH_NOARGS,
++      NULL },
++    { "get_license_text", (PyCFunction)_wrap_champlain_view_get_license_text, METH_NOARGS,
++      NULL },
++    { "get_show_scale", (PyCFunction)_wrap_champlain_view_get_show_scale, METH_NOARGS,
++      NULL },
++    { "get_max_scale_width", (PyCFunction)_wrap_champlain_view_get_max_scale_width, METH_NOARGS,
++      NULL },
++    { "get_scale_unit", (PyCFunction)_wrap_champlain_view_get_scale_unit, METH_NOARGS,
++      NULL },
++    { "get_zoom_on_double_click", (PyCFunction)_wrap_champlain_view_get_zoom_on_double_click, METH_NOARGS,
++      NULL },
++    { "add_polygon", (PyCFunction)_wrap_champlain_view_add_polygon, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "remove_polygon", (PyCFunction)_wrap_champlain_view_remove_polygon, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainView_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.View",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainView_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_view_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- ChamplainZoomLevel ----------- */
++
++static int
++_wrap_champlain_zoom_level_new(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char* kwlist[] = { NULL };
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
++                                     ":champlain.ZoomLevel.__init__",
++                                     kwlist))
++        return -1;
++
++    pygobject_constructv(self, 0, NULL);
++    if (!self->obj) {
++        PyErr_SetString(
++            PyExc_RuntimeError, 
++            "could not create champlain.ZoomLevel object");
++        return -1;
++    }
++    return 0;
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_get_width(PyGObject *self)
++{
++    guint ret;
++
++    
++    ret = champlain_zoom_level_get_width(CHAMPLAIN_ZOOM_LEVEL(self->obj));
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_get_height(PyGObject *self)
++{
++    guint ret;
++
++    
++    ret = champlain_zoom_level_get_height(CHAMPLAIN_ZOOM_LEVEL(self->obj));
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_get_zoom_level(PyGObject *self)
++{
++    int ret;
++
++    
++    ret = champlain_zoom_level_get_zoom_level(CHAMPLAIN_ZOOM_LEVEL(self->obj));
++    
++    return PyInt_FromLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_get_actor(PyGObject *self)
++{
++    ClutterActor *ret;
++
++    
++    ret = champlain_zoom_level_get_actor(CHAMPLAIN_ZOOM_LEVEL(self->obj));
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_set_width(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "width", NULL };
++    PyObject *py_width = NULL;
++    guint width = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.ZoomLevel.set_width", kwlist, &py_width))
++        return NULL;
++    if (py_width) {
++        if (PyLong_Check(py_width))
++            width = PyLong_AsUnsignedLong(py_width);
++        else if (PyInt_Check(py_width))
++            width = PyInt_AsLong(py_width);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'width' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    champlain_zoom_level_set_width(CHAMPLAIN_ZOOM_LEVEL(self->obj), width);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_set_height(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "height", NULL };
++    PyObject *py_height = NULL;
++    guint height = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.ZoomLevel.set_height", kwlist, &py_height))
++        return NULL;
++    if (py_height) {
++        if (PyLong_Check(py_height))
++            height = PyLong_AsUnsignedLong(py_height);
++        else if (PyInt_Check(py_height))
++            height = PyInt_AsLong(py_height);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'height' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    champlain_zoom_level_set_height(CHAMPLAIN_ZOOM_LEVEL(self->obj), height);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_set_zoom_level(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "zoom_level", NULL };
++    int zoom_level;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"i:Champlain.ZoomLevel.set_zoom_level", kwlist, &zoom_level))
++        return NULL;
++    
++    champlain_zoom_level_set_zoom_level(CHAMPLAIN_ZOOM_LEVEL(self->obj), zoom_level);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_add_tile(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "tile", NULL };
++    PyGObject *tile;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.ZoomLevel.add_tile", kwlist, &PyChamplainTile_Type, &tile))
++        return NULL;
++    
++    champlain_zoom_level_add_tile(CHAMPLAIN_ZOOM_LEVEL(self->obj), CHAMPLAIN_TILE(tile->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_remove_tile(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "tile", NULL };
++    PyGObject *tile;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:Champlain.ZoomLevel.remove_tile", kwlist, &PyChamplainTile_Type, &tile))
++        return NULL;
++    
++    champlain_zoom_level_remove_tile(CHAMPLAIN_ZOOM_LEVEL(self->obj), CHAMPLAIN_TILE(tile->obj));
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_tile_count(PyGObject *self)
++{
++    guint ret;
++
++    
++    ret = champlain_zoom_level_tile_count(CHAMPLAIN_ZOOM_LEVEL(self->obj));
++    
++    return PyLong_FromUnsignedLong(ret);
++}
++
++static PyObject *
++_wrap_champlain_zoom_level_get_nth_tile(PyGObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "index", NULL };
++    PyObject *py_index = NULL;
++    ChamplainTile *ret;
++    guint index = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:Champlain.ZoomLevel.get_nth_tile", kwlist, &py_index))
++        return NULL;
++    if (py_index) {
++        if (PyLong_Check(py_index))
++            index = PyLong_AsUnsignedLong(py_index);
++        else if (PyInt_Check(py_index))
++            index = PyInt_AsLong(py_index);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'index' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    ret = champlain_zoom_level_get_nth_tile(CHAMPLAIN_ZOOM_LEVEL(self->obj), index);
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static const PyMethodDef _PyChamplainZoomLevel_methods[] = {
++    { "get_width", (PyCFunction)_wrap_champlain_zoom_level_get_width, METH_NOARGS,
++      NULL },
++    { "get_height", (PyCFunction)_wrap_champlain_zoom_level_get_height, METH_NOARGS,
++      NULL },
++    { "get_zoom_level", (PyCFunction)_wrap_champlain_zoom_level_get_zoom_level, METH_NOARGS,
++      NULL },
++    { "get_actor", (PyCFunction)_wrap_champlain_zoom_level_get_actor, METH_NOARGS,
++      NULL },
++    { "set_width", (PyCFunction)_wrap_champlain_zoom_level_set_width, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_height", (PyCFunction)_wrap_champlain_zoom_level_set_height, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "set_zoom_level", (PyCFunction)_wrap_champlain_zoom_level_set_zoom_level, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "add_tile", (PyCFunction)_wrap_champlain_zoom_level_add_tile, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "remove_tile", (PyCFunction)_wrap_champlain_zoom_level_remove_tile, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "tile_count", (PyCFunction)_wrap_champlain_zoom_level_tile_count, METH_NOARGS,
++      NULL },
++    { "get_nth_tile", (PyCFunction)_wrap_champlain_zoom_level_get_nth_tile, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++PyTypeObject G_GNUC_INTERNAL PyChamplainZoomLevel_Type = {
++    PyObject_HEAD_INIT(NULL)
++    0,                                 /* ob_size */
++    "champlain.ZoomLevel",                   /* tp_name */
++    sizeof(PyGObject),          /* tp_basicsize */
++    0,                                 /* tp_itemsize */
++    /* methods */
++    (destructor)0,        /* tp_dealloc */
++    (printfunc)0,                      /* tp_print */
++    (getattrfunc)0,       /* tp_getattr */
++    (setattrfunc)0,       /* tp_setattr */
++    (cmpfunc)0,           /* tp_compare */
++    (reprfunc)0,             /* tp_repr */
++    (PyNumberMethods*)0,     /* tp_as_number */
++    (PySequenceMethods*)0, /* tp_as_sequence */
++    (PyMappingMethods*)0,   /* tp_as_mapping */
++    (hashfunc)0,             /* tp_hash */
++    (ternaryfunc)0,          /* tp_call */
++    (reprfunc)0,              /* tp_str */
++    (getattrofunc)0,     /* tp_getattro */
++    (setattrofunc)0,     /* tp_setattro */
++    (PyBufferProcs*)0,  /* tp_as_buffer */
++    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                      /* tp_flags */
++    NULL,                        /* Documentation string */
++    (traverseproc)0,     /* tp_traverse */
++    (inquiry)0,             /* tp_clear */
++    (richcmpfunc)0,   /* tp_richcompare */
++    offsetof(PyGObject, weakreflist),             /* tp_weaklistoffset */
++    (getiterfunc)0,          /* tp_iter */
++    (iternextfunc)0,     /* tp_iternext */
++    (struct PyMethodDef*)_PyChamplainZoomLevel_methods, /* tp_methods */
++    (struct PyMemberDef*)0,              /* tp_members */
++    (struct PyGetSetDef*)0,  /* tp_getset */
++    NULL,                              /* tp_base */
++    NULL,                              /* tp_dict */
++    (descrgetfunc)0,    /* tp_descr_get */
++    (descrsetfunc)0,    /* tp_descr_set */
++    offsetof(PyGObject, inst_dict),                 /* tp_dictoffset */
++    (initproc)_wrap_champlain_zoom_level_new,             /* tp_init */
++    (allocfunc)0,           /* tp_alloc */
++    (newfunc)0,               /* tp_new */
++    (freefunc)0,             /* tp_free */
++    (inquiry)0              /* tp_is_gc */
++};
++
++
++
++/* ----------- functions ----------- */
++
++static PyObject *
++_wrap_champlain_cache_dup_default(PyObject *self)
++{
++    ChamplainCache *ret;
++
++    
++    ret = champlain_cache_dup_default();
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static PyObject *
++_wrap_champlain_map_source_factory_dup_default(PyObject *self)
++{
++    ChamplainMapSourceFactory *ret;
++
++    
++    ret = champlain_map_source_factory_dup_default();
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static PyObject *
++_wrap_champlain_network_map_source_new_full(PyObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "id", "name", "license", "license_uri", "min_zoom", "max_zoom", "tile_size", "projection", "uri_format", NULL };
++    char *id, *name, *license, *license_uri, *uri_format;
++    PyObject *py_min_zoom = NULL, *py_max_zoom = NULL, *py_tile_size = NULL, *py_projection = NULL;
++    ChamplainNetworkMapSource *ret;
++    ChamplainMapProjection projection;
++    guint min_zoom = 0, max_zoom = 0, tile_size = 0;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"ssssOOOOs:network_map_source_new_full", kwlist, &id, &name, &license, &license_uri, &py_min_zoom, &py_max_zoom, &py_tile_size, &py_projection, &uri_format))
++        return NULL;
++    if (py_min_zoom) {
++        if (PyLong_Check(py_min_zoom))
++            min_zoom = PyLong_AsUnsignedLong(py_min_zoom);
++        else if (PyInt_Check(py_min_zoom))
++            min_zoom = PyInt_AsLong(py_min_zoom);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'min_zoom' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    if (py_max_zoom) {
++        if (PyLong_Check(py_max_zoom))
++            max_zoom = PyLong_AsUnsignedLong(py_max_zoom);
++        else if (PyInt_Check(py_max_zoom))
++            max_zoom = PyInt_AsLong(py_max_zoom);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'max_zoom' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    if (py_tile_size) {
++        if (PyLong_Check(py_tile_size))
++            tile_size = PyLong_AsUnsignedLong(py_tile_size);
++        else if (PyInt_Check(py_tile_size))
++            tile_size = PyInt_AsLong(py_tile_size);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'tile_size' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    if (pyg_enum_get_value(CHAMPLAIN_TYPE_MAP_PROJECTION, py_projection, (gpointer)&projection))
++        return NULL;
++    
++    ret = champlain_network_map_source_new_full(id, name, license, license_uri, min_zoom, max_zoom, tile_size, projection, uri_format);
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++#line 523 "./pychamplain.override"
++static PyObject *
++_wrap_champlain_marker_new_with_text(PyObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "text", "font", "text_color", "marker_color", NULL };
++    char *text, *font = NULL;
++    ClutterColor *text_color = NULL, *marker_color = NULL;
++    ClutterActor *ret;
++    PyObject *py_text_color = NULL, *py_marker_color = NULL;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s|sOO:marker_new_with_text", 
++            kwlist, &text, &font, &py_text_color, &py_marker_color))
++        return NULL;
++    if (py_text_color!=NULL){
++        if (pyg_boxed_check(py_text_color, CLUTTER_TYPE_COLOR))
++            text_color = pyg_boxed_get(py_text_color, ClutterColor);
++        else {
++            PyErr_SetString(PyExc_TypeError, "text_color should be a ClutterColor");
++            return NULL;
++        }
++    }
++    if (py_marker_color!=NULL){
++        if (pyg_boxed_check(py_marker_color, CLUTTER_TYPE_COLOR))
++            marker_color = pyg_boxed_get(py_marker_color, ClutterColor);
++        else {
++            PyErr_SetString(PyExc_TypeError, "marker_color should be a ClutterColor");
++            return NULL;
++        }
++    }
++    
++    ret = champlain_marker_new_with_text(text, font, text_color, marker_color);
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++#line 4556 "./pychamplain.c"
++
++
++static PyObject *
++_wrap_champlain_marker_new_with_image(PyObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "actor", NULL };
++    PyGObject *actor;
++    ClutterActor *ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O!:marker_new_with_image", kwlist, &PyClutterActor_Type, &actor))
++        return NULL;
++    
++    ret = champlain_marker_new_with_image(CLUTTER_ACTOR(actor->obj));
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static PyObject *
++_wrap_champlain_marker_new_from_file(PyObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "filename", NULL };
++    char *filename;
++    GError *error = NULL;
++    ClutterActor *ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"s:marker_new_from_file", kwlist, &filename))
++        return NULL;
++    
++    ret = champlain_marker_new_from_file(filename, &error);
++    
++    if (pyg_error_check(&error))
++        return NULL;
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static PyObject *
++_wrap_champlain_marker_new_full(PyObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "text", "actor", NULL };
++    char *text;
++    PyGObject *actor;
++    ClutterActor *ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"sO!:marker_new_full", kwlist, &text, &PyClutterActor_Type, &actor))
++        return NULL;
++    
++    ret = champlain_marker_new_full(text, CLUTTER_ACTOR(actor->obj));
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++static PyObject *
++_wrap_champlain_marker_set_highlight_color(PyObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "color", NULL };
++    ClutterColor *color = NULL;
++    PyObject *py_color;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:marker_set_highlight_color", kwlist, &py_color))
++        return NULL;
++    if (pyg_boxed_check(py_color, CLUTTER_TYPE_COLOR))
++        color = pyg_boxed_get(py_color, ClutterColor);
++    else {
++        PyErr_SetString(PyExc_TypeError, "color should be a ClutterColor");
++        return NULL;
++    }
++    
++    champlain_marker_set_highlight_color(color);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_get_highlight_color(PyObject *self)
++{
++    const ClutterColor *ret;
++
++    
++    ret = champlain_marker_get_highlight_color();
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CLUTTER_TYPE_COLOR, (ClutterColor*) ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_marker_set_highlight_text_color(PyObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "color", NULL };
++    ClutterColor *color = NULL;
++    PyObject *py_color;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"O:marker_set_highlight_text_color", kwlist, &py_color))
++        return NULL;
++    if (pyg_boxed_check(py_color, CLUTTER_TYPE_COLOR))
++        color = pyg_boxed_get(py_color, ClutterColor);
++    else {
++        PyErr_SetString(PyExc_TypeError, "color should be a ClutterColor");
++        return NULL;
++    }
++    
++    champlain_marker_set_highlight_text_color(color);
++    
++    Py_INCREF(Py_None);
++    return Py_None;
++}
++
++static PyObject *
++_wrap_champlain_marker_get_highlight_text_color(PyObject *self)
++{
++    const ClutterColor *ret;
++
++    
++    ret = champlain_marker_get_highlight_text_color();
++    
++    /* pyg_boxed_new handles NULL checking */
++    return pyg_boxed_new(CLUTTER_TYPE_COLOR, (ClutterColor*) ret, TRUE, TRUE);
++}
++
++static PyObject *
++_wrap_champlain_tile_new_full(PyObject *self, PyObject *args, PyObject *kwargs)
++{
++    static char *kwlist[] = { "x", "y", "size", "zoom_level", NULL };
++    int x, y, zoom_level;
++    PyObject *py_size = NULL;
++    guint size = 0;
++    ChamplainTile *ret;
++
++    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"iiOi:tile_new_full", kwlist, &x, &y, &py_size, &zoom_level))
++        return NULL;
++    if (py_size) {
++        if (PyLong_Check(py_size))
++            size = PyLong_AsUnsignedLong(py_size);
++        else if (PyInt_Check(py_size))
++            size = PyInt_AsLong(py_size);
++        else
++            PyErr_SetString(PyExc_TypeError, "Parameter 'size' must be an int or a long");
++        if (PyErr_Occurred())
++            return NULL;
++    }
++    
++    ret = champlain_tile_new_full(x, y, size, zoom_level);
++    
++    /* pygobject_new handles NULL checking */
++    return pygobject_new((GObject *)ret);
++}
++
++const PyMethodDef champlain_functions[] = {
++    { "cache_dup_default", (PyCFunction)_wrap_champlain_cache_dup_default, METH_NOARGS,
++      NULL },
++    { "map_source_factory_dup_default", (PyCFunction)_wrap_champlain_map_source_factory_dup_default, METH_NOARGS,
++      NULL },
++    { "network_map_source_new_full", (PyCFunction)_wrap_champlain_network_map_source_new_full, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "marker_new_with_text", (PyCFunction)_wrap_champlain_marker_new_with_text, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "marker_new_with_image", (PyCFunction)_wrap_champlain_marker_new_with_image, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "marker_new_from_file", (PyCFunction)_wrap_champlain_marker_new_from_file, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "marker_new_full", (PyCFunction)_wrap_champlain_marker_new_full, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "marker_set_highlight_color", (PyCFunction)_wrap_champlain_marker_set_highlight_color, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "marker_get_highlight_color", (PyCFunction)_wrap_champlain_marker_get_highlight_color, METH_NOARGS,
++      NULL },
++    { "marker_set_highlight_text_color", (PyCFunction)_wrap_champlain_marker_set_highlight_text_color, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { "marker_get_highlight_text_color", (PyCFunction)_wrap_champlain_marker_get_highlight_text_color, METH_NOARGS,
++      NULL },
++    { "tile_new_full", (PyCFunction)_wrap_champlain_tile_new_full, METH_VARARGS|METH_KEYWORDS,
++      NULL },
++    { NULL, NULL, 0, NULL }
++};
++
++
++/* ----------- enums and flags ----------- */
++
++void
++champlain_add_constants(PyObject *module, const gchar *strip_prefix)
++{
++#ifdef VERSION
++    PyModule_AddStringConstant(module, "__version__", VERSION);
++#endif
++  pyg_enum_add(module, "ScrollMode", strip_prefix, CHAMPLAIN_TYPE_SCROLL_MODE);
++  pyg_enum_add(module, "State", strip_prefix, CHAMPLAIN_TYPE_STATE);
++  pyg_enum_add(module, "Unit", strip_prefix, CHAMPLAIN_TYPE_UNIT);
++  pyg_enum_add(module, "SelectionMode", strip_prefix, CHAMPLAIN_TYPE_SELECTION_MODE);
++  pyg_enum_add(module, "MapProjection", strip_prefix, CHAMPLAIN_TYPE_MAP_PROJECTION);
++
++  if (PyErr_Occurred())
++    PyErr_Print();
++}
++
++/* initialise stuff extension classes */
++void
++champlain_register_classes(PyObject *d)
++{
++    PyObject *module;
++
++    if ((module = PyImport_ImportModule("gobject")) != NULL) {
++        _PyGObject_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GObject");
++        if (_PyGObject_Type == NULL) {
++            PyErr_SetString(PyExc_ImportError,
++                "cannot import name GObject from gobject");
++            return ;
++        }
++        _PyGInitiallyUnowned_Type = (PyTypeObject *)PyObject_GetAttrString(module, "GObject");
++        if (_PyGInitiallyUnowned_Type == NULL) {
++            PyErr_SetString(PyExc_ImportError,
++                "cannot import name GObject from gobject");
++            return ;
++        }
++    } else {
++        PyErr_SetString(PyExc_ImportError,
++            "could not import gobject");
++        return ;
++    }
++    if ((module = PyImport_ImportModule("clutter")) != NULL) {
++        _PyClutterActor_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Actor");
++        if (_PyClutterActor_Type == NULL) {
++            PyErr_SetString(PyExc_ImportError,
++                "cannot import name Actor from clutter");
++            return ;
++        }
++        _PyClutterGroup_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Group");
++        if (_PyClutterGroup_Type == NULL) {
++            PyErr_SetString(PyExc_ImportError,
++                "cannot import name Group from clutter");
++            return ;
++        }
++        _PyClutterColor_Type = (PyTypeObject *)PyObject_GetAttrString(module, "Color");
++        if (_PyClutterColor_Type == NULL) {
++            PyErr_SetString(PyExc_ImportError,
++                "cannot import name Color from clutter");
++            return ;
++        }
++    } else {
++        PyErr_SetString(PyExc_ImportError,
++            "could not import clutter");
++        return ;
++    }
++
++
++#line 4804 "./pychamplain.c"
++    pyg_register_boxed(d, "Point", CHAMPLAIN_TYPE_POINT, &PyChamplainPoint_Type);
++    pyg_register_boxed(d, "MapSourceDesc", CHAMPLAIN_TYPE_MAP_SOURCE_DESC, &PyChamplainMapSourceDesc_Type);
++    pygobject_register_class(d, "ChamplainBaseMarker", CHAMPLAIN_TYPE_BASE_MARKER, &PyChamplainBaseMarker_Type, Py_BuildValue("(O)", &PyClutterGroup_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_BASE_MARKER);
++    pygobject_register_class(d, "ChamplainCache", CHAMPLAIN_TYPE_CACHE, &PyChamplainCache_Type, Py_BuildValue("(O)", &PyGObject_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_CACHE);
++    pygobject_register_class(d, "ChamplainLayer", CHAMPLAIN_TYPE_LAYER, &PyChamplainLayer_Type, Py_BuildValue("(O)", &PyClutterGroup_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_LAYER);
++    pygobject_register_class(d, "ChamplainMapSource", CHAMPLAIN_TYPE_MAP_SOURCE, &PyChamplainMapSource_Type, Py_BuildValue("(O)", &PyGInitiallyUnowned_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_MAP_SOURCE);
++    pygobject_register_class(d, "ChamplainMapSourceFactory", CHAMPLAIN_TYPE_MAP_SOURCE_FACTORY, &PyChamplainMapSourceFactory_Type, Py_BuildValue("(O)", &PyGObject_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_MAP_SOURCE_FACTORY);
++    pygobject_register_class(d, "ChamplainMarker", CHAMPLAIN_TYPE_MARKER, &PyChamplainMarker_Type, Py_BuildValue("(O)", &PyChamplainBaseMarker_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_MARKER);
++    pygobject_register_class(d, "ChamplainNetworkMapSource", CHAMPLAIN_TYPE_NETWORK_MAP_SOURCE, &PyChamplainNetworkMapSource_Type, Py_BuildValue("(O)", &PyChamplainMapSource_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_NETWORK_MAP_SOURCE);
++    pygobject_register_class(d, "ChamplainPolygon", CHAMPLAIN_TYPE_POLYGON, &PyChamplainPolygon_Type, Py_BuildValue("(O)", &PyGInitiallyUnowned_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_POLYGON);
++    pygobject_register_class(d, "ChamplainSelectionLayer", CHAMPLAIN_TYPE_SELECTION_LAYER, &PyChamplainSelectionLayer_Type, Py_BuildValue("(O)", &PyChamplainLayer_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_SELECTION_LAYER);
++    pygobject_register_class(d, "ChamplainTile", CHAMPLAIN_TYPE_TILE, &PyChamplainTile_Type, Py_BuildValue("(O)", &PyGObject_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_TILE);
++    pygobject_register_class(d, "ChamplainView", CHAMPLAIN_TYPE_VIEW, &PyChamplainView_Type, Py_BuildValue("(O)", &PyClutterGroup_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_VIEW);
++    pygobject_register_class(d, "ChamplainZoomLevel", CHAMPLAIN_TYPE_ZOOM_LEVEL, &PyChamplainZoomLevel_Type, Py_BuildValue("(O)", &PyGObject_Type));
++    pyg_set_object_has_new_constructor(CHAMPLAIN_TYPE_ZOOM_LEVEL);
++}

Added: packages/unstable/libchamplain/debian/patches/series
URL: http://svn.debian.org/wsvn/pkg-gnome/packages/unstable/libchamplain/debian/patches/series?rev=24729&op=file
==============================================================================
--- packages/unstable/libchamplain/debian/patches/series (added)
+++ packages/unstable/libchamplain/debian/patches/series [utf-8] Sun Jul 11 01:30:33 2010
@@ -1,0 +1,1 @@
+01fix_python_bindings.patch




More information about the pkg-gnome-commits mailing list