Freestyle Python API improvements - part 3.

Major API updates were made to address code review comments.
This revision mostly focuses on Python wrappers of C++ 0D and 1D elements (i.e.,
Interface0D and Interface1D, as well as their subclasses).

* Most getter/setter methods were reimplemented as attributes using PyGetSetDef.
Vector attributes are now implemented based on mathutils callbacks.  Boolean
attributes now only accept boolean values.

* The __getitem__ method was removed and the Sequence protocol was used instead.

* The naming of methods and attributes was fixed to follow the naming conventions
of the Blender Python API (i.e., lower case + underscores for methods and attributes,
and CamelCase for classes).  Some naming inconsistency within the Freestyle Python
API was also addressed.

* The Freestyle API had a number of method names including prefix/suffix "A" and
"B", and their meanings were inconsistent (i.e., referring to different things
depending on the classes).  The names with these two letters were replaced with
more straightforward names.  Also some attribute names were changed so as to indicate
the type of the value (e.g., FEdge.next_fedge instead of FEdge.next_edge) in line
with other names explicitly indicating what the value is (e.g., SVertex.viewvertex).

* In addition, some code clean-up was done in both C++ and Python.

Notes:

In summary, the following irregular naming changes were made through this revision
(those resulting from regular changes of naming conventions are not listed):

- CurvePoint: {A,B} --> {first,second}_svertex
- FEdge: vertex{A,B} --> {first,second}_svertex
- FEdge: {next,previous}Edge --> {next,previous}_fedge
- FEdgeSharp: normal{A,B} --> normal_{right,left}
- FEdgeSharp: {a,b}FaceMark --> face_mark_{right,left}
- FEdgeSharp: {a,b}Material --> material_{right,left}
- FEdgeSharp: {a,b}MaterialIndex --> material_index_{right,left}
- FrsCurve: empty --> is_empty
- FrsCurve: nSegments --> segments_size
- TVertex: mate() --> get_mate()
- ViewEdge: fedge{A,B} --> {first,last}_fedge
- ViewEdge: setaShape, aShape --> occlude
- ViewEdge: {A,B} --> {first,last}_viewvertex
- ViewMap: getScene3dBBox --> scene_bbox

1 files changed, 184 insertions, 302 deletions

diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp
index e35ea82ace2..8e1cb42f37c 100644
--- a/source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp
+++ b/source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp
@@ -14,9 +14,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
-	
-static char ViewEdge___doc__[] =
+/*----------------------ViewEdge methods ----------------------------*/
+
+PyDoc_STRVAR(ViewEdge_doc,
 "Class hierarchy: :class:`Interface1D` > :class:`ViewEdge`\n"
 "\n"
 "Class defining a ViewEdge.  A ViewEdge in an edge of the image graph.\n"
@@ -32,385 +32,267 @@ static char ViewEdge___doc__[] =
 "   Copy constructor.\n"
 "\n"
 "   :arg iBrother: A ViewEdge object.\n"
-"   :type iBrother: :class:`ViewEdge`\n";
+"   :type iBrother: :class:`ViewEdge`");
 
-static int ViewEdge___init__(BPy_ViewEdge *self, PyObject *args, PyObject *kwds)
+static int ViewEdge_init(BPy_ViewEdge *self, PyObject *args, PyObject *kwds)
 {
-    if ( !PyArg_ParseTuple(args, "") )
-        return -1;
+	if (!PyArg_ParseTuple(args, ""))
+		return -1;
 	self->ve = new ViewEdge();
 	self->py_if1D.if1D = self->ve;
 	self->py_if1D.borrowed = 0;
-
 	return 0;
 }
 
-static char ViewEdge_A___doc__[] =
-".. method:: A()\n"
-"\n"
-"   Returns the first ViewVertex.\n"
+PyDoc_STRVAR(ViewEdge_update_fedges_doc,
+".. method:: update_fedges()\n"
 "\n"
-"   :return: The first ViewVertex.\n"
-"   :rtype: :class:`ViewVertex`\n";
+"   Sets Viewedge to this for all embedded fedges.\n");
 
-static PyObject * ViewEdge_A( BPy_ViewEdge *self ) {	
-	ViewVertex *v = self->ve->A();
-	if( v ){
-		return Any_BPy_ViewVertex_from_ViewVertex( *v );
-	}
-		
+static PyObject * ViewEdge_update_fedges(BPy_ViewEdge *self)
+{
+	self->ve->UpdateFEdges();
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_B___doc__[] =
-".. method:: B()\n"
-"\n"
-"   Returns the second ViewVertex.\n"
-"\n"
-"   :return: The second ViewVertex.\n"
-"   :rtype: :class:`ViewVertex`\n";
+static PyMethodDef BPy_ViewEdge_methods[] = {
+	{"update_fedges", (PyCFunction)ViewEdge_update_fedges, METH_NOARGS, ViewEdge_update_fedges_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-static PyObject * ViewEdge_B( BPy_ViewEdge *self ) {	
-	ViewVertex *v = self->ve->B();
-	if( v ){
-		return Any_BPy_ViewVertex_from_ViewVertex( *v );
-	}
-		
-	Py_RETURN_NONE;
-}
+/*----------------------ViewEdge get/setters ----------------------------*/
 
-static char ViewEdge_fedgeA___doc__[] =
-".. method:: fedgeA()\n"
+PyDoc_STRVAR(ViewEdge_first_viewvertex_doc,
+"The first ViewVertex.\n"
 "\n"
-"   Returns the first FEdge that constitutes this ViewEdge.\n"
-"\n"
-"   :return: The first FEdge constituting this ViewEdge.\n"
-"   :rtype: :class:`FEdge`\n";
+":type: :class:`ViewVertex`");
 
-static PyObject * ViewEdge_fedgeA( BPy_ViewEdge *self ) {	
-	FEdge *A = self->ve->fedgeA();
-	if( A ){
-		return Any_BPy_FEdge_from_FEdge( *A );
-	}
-		
+static PyObject *ViewEdge_first_viewvertex_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	ViewVertex *v = self->ve->A();
+	if (v)
+		return Any_BPy_ViewVertex_from_ViewVertex(*v);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_fedgeB___doc__[] =
-".. method:: fedgeB()\n"
-"\n"
-"   Returns the last FEdge that constitutes this ViewEdge.\n"
-"\n"
-"   :return: The last FEdge constituting this ViewEdge.\n"
-"   :rtype: :class:`FEdge`\n";
-
-static PyObject * ViewEdge_fedgeB( BPy_ViewEdge *self ) {	
-	FEdge *B = self->ve->fedgeB();
-	if( B ){
-		return Any_BPy_FEdge_from_FEdge( *B );
-	}
-		
-	Py_RETURN_NONE;
+static int ViewEdge_first_viewvertex_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_ViewVertex_Check(value))
+		return -1;
+	self->ve->setA(((BPy_ViewVertex *)value)->vv);
+	return 0;
 }
 
-static char ViewEdge_viewShape___doc__[] =
-".. method:: viewShape()\n"
-"\n"
-"   Returns the ViewShape to which this ViewEdge belongs to.\n"
+PyDoc_STRVAR(ViewEdge_last_viewvertex_doc,
+"The second ViewVertex.\n"
 "\n"
-"   :return: The ViewShape to which this ViewEdge belongs to.\n"
-"   :rtype: :class:`ViewShape`\n";
+":type: :class:`ViewVertex`");
 
-static PyObject * ViewEdge_viewShape( BPy_ViewEdge *self ) {	
-	ViewShape *vs = self->ve->viewShape();
-	if( vs ){
-		return BPy_ViewShape_from_ViewShape( *vs );
-	}
-		
+static PyObject *ViewEdge_last_viewvertex_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	ViewVertex *v = self->ve->B();
+	if (v)
+		return Any_BPy_ViewVertex_from_ViewVertex(*v);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_aShape___doc__[] =
-".. method:: aShape()\n"
-"\n"
-"   Returns the shape that is occluded by the ViewShape to which this\n"
-"   ViewEdge belongs to.  If no object is occluded, None is returned.\n"
-"\n"
-"   :return: The occluded ViewShape.\n"
-"   :rtype: :class:`ViewShape`\n";
-
-static PyObject * ViewEdge_aShape( BPy_ViewEdge *self ) {	
-	ViewShape *vs = self->ve->aShape();
-	if( vs ){
-		return BPy_ViewShape_from_ViewShape( *vs );
-	}
-		
-	Py_RETURN_NONE;
+static int ViewEdge_last_viewvertex_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_ViewVertex_Check(value))
+		return -1;
+	self->ve->setB(((BPy_ViewVertex *)value)->vv);
+	return 0;
 }
 
-static char ViewEdge_isClosed___doc__[] =
-".. method:: isClosed()\n"
+PyDoc_STRVAR(ViewEdge_first_fedge_doc,
+"The first FEdge that constitutes this ViewEdge.\n"
 "\n"
-"   Tells whether this ViewEdge forms a closed loop or not.\n"
-"\n"
-"   :return: True if this ViewEdge forms a closed loop.\n"
-"   :rtype: bool\n";
+":type: :class:`FEdge`");
 
-static PyObject * ViewEdge_isClosed( BPy_ViewEdge *self ) {
-	return PyBool_from_bool( self->ve->isClosed() );	
+static PyObject *ViewEdge_first_fedge_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	FEdge *fe = self->ve->fedgeA();
+	if (fe)
+		return Any_BPy_FEdge_from_FEdge(*fe);
+	Py_RETURN_NONE;
 }
 
-static char ViewEdge_getChainingTimeStamp___doc__[] =
-".. method:: getChainingTimeStamp()\n"
-"\n"
-"   Returns the time stamp of this ViewEdge.\n"
-"\n"
-"   :return: The time stamp.\n"
-"   :rtype: int\n";
-
-static PyObject * ViewEdge_getChainingTimeStamp( BPy_ViewEdge *self ) {
-	return PyLong_FromLong( self->ve->getChainingTimeStamp() );
+static int ViewEdge_first_fedge_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_FEdge_Check(value))
+		return -1;
+	self->ve->setFEdgeA(((BPy_FEdge *)value)->fe);
+	return 0;
 }
 
-static char ViewEdge_setChainingTimeStamp___doc__[] =
-".. method:: setChainingTimeStamp(ts)\n"
+PyDoc_STRVAR(ViewEdge_last_fedge_doc,
+"The last FEdge that constitutes this ViewEdge.\n"
 "\n"
-"   Sets the time stamp value.\n"
-"\n"
-"   :arg ts: The time stamp.\n"
-"   :type ts: int\n";
-
-static PyObject * ViewEdge_setChainingTimeStamp( BPy_ViewEdge *self, PyObject *args) {
-	int timestamp = 0 ;
-
-	if( !PyArg_ParseTuple(args, "i", &timestamp) )
-		return NULL;
-	
-	self->ve->setChainingTimeStamp( timestamp );
+":type: :class:`FEdge`");
 
+static PyObject *ViewEdge_last_fedge_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	FEdge *fe = self->ve->fedgeB();
+	if (fe)
+		return Any_BPy_FEdge_from_FEdge(*fe);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_setA___doc__[] =
-".. method:: setA(iA)\n"
-"\n"
-"   Sets the first ViewVertex of the ViewEdge.\n"
-"\n"
-"   :arg iA: The first ViewVertex of the ViewEdge.\n"
-"   :type iA: :class:`ViewVertex`\n";
-
-static PyObject *ViewEdge_setA( BPy_ViewEdge *self , PyObject *args) {
-	PyObject *py_vv;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewVertex_Type, &py_vv) ))
-		return NULL;
-
-	self->ve->setA( ((BPy_ViewVertex *) py_vv)->vv );
-
-	Py_RETURN_NONE;
+static int ViewEdge_last_fedge_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_FEdge_Check(value))
+		return -1;
+	self->ve->setFEdgeB(((BPy_FEdge *)value)->fe);
+	return 0;
 }
 
-static char ViewEdge_setB___doc__[] =
-".. method:: setB(iB)\n"
-"\n"
-"   Sets the last ViewVertex of the ViewEdge.\n"
+PyDoc_STRVAR(ViewEdge_viewshape_doc,
+"The ViewShape to which this ViewEdge belongs to.\n"
 "\n"
-"   :arg iB: The last ViewVertex of the ViewEdge.\n"
-"   :type iB: :class:`ViewVertex`\n";
-
-static PyObject *ViewEdge_setB( BPy_ViewEdge *self , PyObject *args) {
-	PyObject *py_vv;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewVertex_Type, &py_vv) ))
-		return NULL;
-
-	self->ve->setB( ((BPy_ViewVertex *) py_vv)->vv );
+":type: :class:`ViewShape`");
 
+static PyObject *ViewEdge_viewshape_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{	
+	ViewShape *vs = self->ve->viewShape();
+	if (vs)
+		return BPy_ViewShape_from_ViewShape(*vs);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_setNature___doc__[] =
-".. method:: setNature(iNature)\n"
-"\n"
-"   Sets the nature of the ViewEdge.\n"
-"\n"
-"   :arg iNature: The nature of the ViewEdge.\n"
-"   :type iNature: :class:`Nature`\n";
-
-static PyObject * ViewEdge_setNature( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_n;
-
-	if(!( PyArg_ParseTuple(args, "O!", &Nature_Type, &py_n) ))
-		return NULL;
-	
-	PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i );
-	self->ve->setNature( PyLong_AsLong(i) );
-
-	Py_RETURN_NONE;
+static int ViewEdge_viewshape_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_ViewShape_Check(value))
+		return -1;
+	self->ve->setShape(((BPy_ViewShape *)value)->vs);
+	return 0;
 }
 
-static char ViewEdge_setFEdgeA___doc__[] =
-".. method:: setFEdgeA(iFEdge)\n"
-"\n"
-"   Sets the first FEdge of the ViewEdge.\n"
+PyDoc_STRVAR(ViewEdge_occludee_doc,
+"The shape that is occluded by the ViewShape to which this ViewEdge\n"
+"belongs to.  If no object is occluded, this property is set to None.\n"
 "\n"
-"   :arg iFEdge: The first FEdge of the ViewEdge.\n"
-"   :type iFEdge: :class:`FEdge`\n";
-
-static PyObject * ViewEdge_setFEdgeA( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_fe;
-
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
-		return NULL;
-
-	self->ve->setFEdgeA( ((BPy_FEdge *) py_fe)->fe );
+":type: :class:`ViewShape`");
 
+static PyObject *ViewEdge_occludee_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	ViewShape *vs = self->ve->aShape();
+	if (vs)
+		return BPy_ViewShape_from_ViewShape(*vs);
 	Py_RETURN_NONE;
 }
 
-static char ViewEdge_setFEdgeB___doc__[] =
-".. method:: setFEdgeB(iFEdge)\n"
-"\n"
-"   Sets the last FEdge of the ViewEdge.\n"
-"\n"
-"   :arg iFEdge: The last FEdge of the ViewEdge.\n"
-"   :type iFEdge: :class:`FEdge`\n";
-
-static PyObject * ViewEdge_setFEdgeB( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_fe;
-
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
-		return NULL;
-
-	self->ve->setFEdgeB( ((BPy_FEdge *) py_fe)->fe );
-
-	Py_RETURN_NONE;
+static int ViewEdge_occludee_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if(!BPy_ViewShape_Check(value))
+		return -1;
+	self->ve->setaShape(((BPy_ViewShape *)value)->vs);
+	return 0;
 }
 
-static char ViewEdge_setShape___doc__[] =
-".. method:: setShape(iVShape)\n"
+PyDoc_STRVAR(ViewEdge_is_closed_doc,
+"True if this ViewEdge forms a closed loop.\n"
 "\n"
-"   Sets the ViewShape to which this ViewEdge belongs to.\n"
-"\n"
-"   :arg iVShape: The ViewShape to which this ViewEdge belongs to.\n"
-"   :type iVShape: :class:`ViewShape`\n";
-
-static PyObject * ViewEdge_setShape( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_vs;
+":type: bool");
 
-	if(!( PyArg_ParseTuple(args, "O", &ViewShape_Type, &py_vs) ))
-		return NULL;
-
-	self->ve->setShape( ((BPy_ViewShape *) py_vs)->vs );
-
-	Py_RETURN_NONE;
+static PyObject *ViewEdge_is_closed_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	return PyBool_from_bool(self->ve->isClosed());
 }
 
-static char ViewEdge_setId___doc__[] =
-".. method:: setId(id)\n"
+PyDoc_STRVAR(ViewEdge_id_doc,
+"The Id of this ViewEdge.\n"
 "\n"
-"   Sets the ViewEdge id.\n"
-"\n"
-"   :arg id: An Id object.\n"
-"   :type id: :class:`Id`\n";
-
-static PyObject * ViewEdge_setId( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_id;
+":type: :class:`Id`");
 
-	if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) ))
-		return NULL;
-
-	Id id(*( ((BPy_Id *) py_id)->id ));
-	self->ve->setId( id );
+static PyObject *ViewEdge_id_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	Id id(self->ve->getId());
+	return BPy_Id_from_Id(id); // return a copy
+}
 
-	Py_RETURN_NONE;
+static int ViewEdge_id_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Id_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an Id");
+		return -1;
+	}
+	self->ve->setId(*(((BPy_Id *)value)->id));
+	return 0;
 }
 
-static char ViewEdge_UpdateFEdges___doc__[] =
-".. method:: UpdateFEdges()\n"
+PyDoc_STRVAR(ViewEdge_nature_doc,
+"The nature of this ViewEdge.\n"
 "\n"
-"   Sets Viewedge to this for all embedded fedges.\n";
+":type: :class:`Nature`");
 
-static PyObject * ViewEdge_UpdateFEdges( BPy_ViewEdge *self ) {
-	self->ve->UpdateFEdges();
+static PyObject *ViewEdge_nature_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	return BPy_Nature_from_Nature(self->ve->getNature());
+}
 
-	Py_RETURN_NONE;
+static int ViewEdge_nature_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Nature_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a Nature");
+		return -1;
+	}
+	self->ve->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i));
+	return 0;
 }
 
-static char ViewEdge_setaShape___doc__[] =
-".. method:: setaShape(iShape)\n"
+PyDoc_STRVAR(ViewEdge_qi_doc,
+"The quantitative invisibility.\n"
 "\n"
-"   Sets the occluded ViewShape.\n"
-"\n"
-"   :arg iShape: A ViewShape object.\n"
-"   :type iShape: :class:`ViewShape`\n";
-
-static PyObject * ViewEdge_setaShape( BPy_ViewEdge *self, PyObject *args ) {
-	PyObject *py_vs;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewShape_Type, &py_vs) ))
-		return NULL;
-
-	ViewShape *vs = ((BPy_ViewShape *) py_vs)->vs;
-	self->ve->setaShape( vs );
+":type: int");
 
-	Py_RETURN_NONE;
+static PyObject *ViewEdge_qi_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->ve->qi());
 }
 
-static char ViewEdge_setQI___doc__[] =
-".. method:: setQI(qi)\n"
-"\n"
-"   Sets the quantitative invisibility value of the ViewEdge.\n"
-"\n"
-"   :arg qi: The quantitative invisibility.\n"
-"   :type qi: int\n";
-
-static PyObject * ViewEdge_setQI( BPy_ViewEdge *self, PyObject *args ) {
+static int ViewEdge_qi_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
 	int qi;
 
-	if(!( PyArg_ParseTuple(args, "i", &qi) ))
-		return NULL;
+	if((qi = PyLong_AsLong(value)) == -1 && PyErr_Occurred())
+		return -1;
+	self->ve->setQI(qi);
+	return 0;
+}
 
-	self->ve->setQI( qi );
+PyDoc_STRVAR(ViewEdge_chaining_time_stamp_doc,
+"The time stamp of this ViewEdge.\n"
+"\n"
+":type: int");
 
-	Py_RETURN_NONE;
+static PyObject *ViewEdge_chaining_time_stamp_get(BPy_ViewEdge *self, void *UNUSED(closure))
+{
+	return PyLong_FromLong(self->ve->getChainingTimeStamp());
 }
 
-static char ViewEdge_qi___doc__[] =
-".. method:: getChainingTimeStamp()\n"
-"\n"
-"   Returns the quantitative invisibility value of the ViewEdge.\n"
-"\n"
-"   :return: The quantitative invisibility.\n"
-"   :rtype: int\n";
+static int ViewEdge_chaining_time_stamp_set(BPy_ViewEdge *self, PyObject *value, void *UNUSED(closure))
+{
+	int timestamp;
 
-static PyObject * ViewEdge_qi( BPy_ViewEdge *self ) {
-	return PyLong_FromLong( self->ve->qi() );
+	if ((timestamp = PyLong_AsLong(value)) == -1 && PyErr_Occurred())
+		return -1;
+	self->ve->setChainingTimeStamp(timestamp);
+	return 0;
 }
 
-/*----------------------ViewEdge instance definitions ----------------------------*/
-static PyMethodDef BPy_ViewEdge_methods[] = {	
-	{"A", ( PyCFunction ) ViewEdge_A, METH_NOARGS, ViewEdge_A___doc__},
-	{"B", ( PyCFunction ) ViewEdge_B, METH_NOARGS, ViewEdge_B___doc__},
-	{"fedgeA", ( PyCFunction ) ViewEdge_fedgeA, METH_NOARGS, ViewEdge_fedgeA___doc__},
-	{"fedgeB", ( PyCFunction ) ViewEdge_fedgeB, METH_NOARGS, ViewEdge_fedgeB___doc__},
-	{"viewShape", ( PyCFunction ) ViewEdge_viewShape, METH_NOARGS, ViewEdge_viewShape___doc__},
-	{"aShape", ( PyCFunction ) ViewEdge_aShape, METH_NOARGS, ViewEdge_aShape___doc__},
-	{"isClosed", ( PyCFunction ) ViewEdge_isClosed, METH_NOARGS, ViewEdge_isClosed___doc__},
-	{"getChainingTimeStamp", ( PyCFunction ) ViewEdge_getChainingTimeStamp, METH_NOARGS, ViewEdge_getChainingTimeStamp___doc__},
-	{"setChainingTimeStamp", ( PyCFunction ) ViewEdge_setChainingTimeStamp, METH_VARARGS, ViewEdge_setChainingTimeStamp___doc__},
-	{"setA", ( PyCFunction ) ViewEdge_setA, METH_VARARGS, ViewEdge_setA___doc__},
-	{"setB", ( PyCFunction ) ViewEdge_setB, METH_VARARGS, ViewEdge_setB___doc__},
-	{"setNature", ( PyCFunction ) ViewEdge_setNature, METH_VARARGS, ViewEdge_setNature___doc__},
-	{"setFEdgeA", ( PyCFunction ) ViewEdge_setFEdgeA, METH_VARARGS, ViewEdge_setFEdgeA___doc__},
-	{"setFEdgeB", ( PyCFunction ) ViewEdge_setFEdgeB, METH_VARARGS, ViewEdge_setFEdgeB___doc__},
-	{"setShape", ( PyCFunction ) ViewEdge_setShape, METH_VARARGS, ViewEdge_setShape___doc__},
-	{"setId", ( PyCFunction ) ViewEdge_setId, METH_VARARGS, ViewEdge_setId___doc__},
-	{"UpdateFEdges", ( PyCFunction ) ViewEdge_UpdateFEdges, METH_NOARGS, ViewEdge_UpdateFEdges___doc__},
-	{"setaShape", ( PyCFunction ) ViewEdge_setaShape, METH_VARARGS, ViewEdge_setaShape___doc__},
-	{"setQI", ( PyCFunction ) ViewEdge_setQI, METH_VARARGS, ViewEdge_setQI___doc__},
-	{"qi", ( PyCFunction ) ViewEdge_qi, METH_NOARGS, ViewEdge_qi___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_ViewEdge_getseters[] = {
+	{(char *)"first_viewvertex", (getter)ViewEdge_first_viewvertex_get, (setter)ViewEdge_first_viewvertex_set, (char *)ViewEdge_first_viewvertex_doc, NULL},
+	{(char *)"last_viewvertex", (getter)ViewEdge_last_viewvertex_get, (setter)ViewEdge_last_viewvertex_set, (char *)ViewEdge_last_viewvertex_doc, NULL},
+	{(char *)"first_fedge", (getter)ViewEdge_first_fedge_get, (setter)ViewEdge_first_fedge_set, (char *)ViewEdge_first_fedge_doc, NULL},
+	{(char *)"last_fedge", (getter)ViewEdge_last_fedge_get, (setter)ViewEdge_last_fedge_set, (char *)ViewEdge_last_fedge_doc, NULL},
+	{(char *)"viewshape", (getter)ViewEdge_viewshape_get, (setter)ViewEdge_viewshape_set, (char *)ViewEdge_viewshape_doc, NULL},
+	{(char *)"occludee", (getter)ViewEdge_occludee_get, (setter)ViewEdge_occludee_set, (char *)ViewEdge_occludee_doc, NULL},
+	{(char *)"is_closed", (getter)ViewEdge_is_closed_get, (setter)NULL, (char *)ViewEdge_is_closed_doc, NULL},
+	{(char *)"id", (getter)ViewEdge_id_get, (setter)ViewEdge_id_set, (char *)ViewEdge_id_doc, NULL},
+	{(char *)"nature", (getter)ViewEdge_nature_get, (setter)ViewEdge_nature_set, (char *)ViewEdge_nature_doc, NULL},
+	{(char *)"qi", (getter)ViewEdge_qi_get, (setter)ViewEdge_qi_set, (char *)ViewEdge_qi_doc, NULL},
+	{(char *)"chaining_time_stamp", (getter)ViewEdge_chaining_time_stamp_get, (setter)ViewEdge_chaining_time_stamp_set, (char *)ViewEdge_chaining_time_stamp_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_ViewEdge type definition ------------------------------*/
@@ -436,7 +318,7 @@ PyTypeObject ViewEdge_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	ViewEdge___doc__,               /* tp_doc */
+	ViewEdge_doc,                   /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -445,13 +327,13 @@ PyTypeObject ViewEdge_Type = {
 	0,                              /* tp_iternext */
 	BPy_ViewEdge_methods,           /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_ViewEdge_getseters,         /* tp_getset */
 	&Interface1D_Type,              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)ViewEdge___init__,    /* tp_init */
+	(initproc)ViewEdge_init,        /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };