--- /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 + + + +#line 3 "./pychamplain.override" +#include +#include +#include +#include +#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); +}