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