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, 99 insertions, 126 deletions

diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
index 14add743a37..55c8b64d13c 100644
--- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
+++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp
@@ -12,9 +12,9 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------TVertex methods ----------------------------*/
 
-static char TVertex___doc__[] =
+PyDoc_STRVAR(TVertex_doc,
 "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`TVertex`\n"
 "\n"
 "Class to define a T vertex, i.e. an intersection between two edges.\n"
@@ -32,172 +32,145 @@ static char TVertex___doc__[] =
 "   Copy constructor.\n"
 "\n"
 "   :arg iBrother: A TVertex object.\n"
-"   :type iBrother: :class:`TVertex`\n";
+"   :type iBrother: :class:`TVertex`");
 
-static int TVertex___init__(BPy_TVertex *self, PyObject *args, PyObject *kwds)
+static int TVertex_init(BPy_TVertex *self, PyObject *args, PyObject *kwds)
 {
-    if( !PyArg_ParseTuple(args, "") )
-        return -1;
+	if (!PyArg_ParseTuple(args, ""))
+		return -1;
 	self->tv = new TVertex();
 	self->py_vv.vv = self->tv;
 	self->py_vv.py_if0D.if0D = self->tv;
 	self->py_vv.py_if0D.borrowed = 0;
-
 	return 0;
 }
 
-static char TVertex_frontSVertex___doc__[] =
-".. method:: frontSVertex()\n"
+PyDoc_STRVAR(TVertex_get_svertex_doc,
+".. method:: get_svertex(iFEdge)\n"
 "\n"
-"   Returns the SVertex that is closer to the viewpoint.\n"
+"   Returns the SVertex (among the 2) belonging to the given FEdge.\n"
 "\n"
-"   :return: The SVertex that is closer to the viewpoint.\n"
-"   :rtype: :class:`SVertex`\n";
+"   :arg iFEdge: An FEdge object.\n"
+"   :type iFEdge: :class:`FEdge`\n"
+"   :return: The SVertex belonging to the given FEdge.\n"
+"   :rtype: :class:`SVertex`");
 
-static PyObject * TVertex_frontSVertex( BPy_TVertex *self ) {
-	SVertex *v = self->tv->frontSVertex();
-	if( v ){
-		return BPy_SVertex_from_SVertex( *v );
-	}
+static PyObject * TVertex_get_svertex( BPy_TVertex *self, PyObject *args)
+{
+	PyObject *py_fe;
 
+	if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe))
+		return NULL;
+	SVertex *sv = self->tv->getSVertex(((BPy_FEdge *)py_fe)->fe);
+	if (sv)
+		return BPy_SVertex_from_SVertex(*sv);
 	Py_RETURN_NONE;
 }
 
-static char TVertex_backSVertex___doc__[] =
-".. method:: backSVertex()\n"
+PyDoc_STRVAR(TVertex_get_mate_doc,
+".. method:: get_mate(iEdgeA)\n"
 "\n"
-"   Returns the SVertex that is further away from the viewpoint.\n"
+"   Returns the mate edge of the ViewEdge given as argument.  If the\n"
+"   ViewEdge is frontEdgeA, frontEdgeB is returned.  If the ViewEdge is\n"
+"   frontEdgeB, frontEdgeA is returned.  Same for back edges.\n"
 "\n"
-"   :return: The SVertex that is further away from the viewpoint.\n"
-"   :rtype: :class:`SVertex`\n";
+"   :arg iEdgeA: A ViewEdge object.\n"
+"   :type iEdgeA: :class:`ViewEdge`\n"
+"   :return: The mate edge of the given ViewEdge.\n"
+"   :rtype: :class:`ViewEdge`");
 
-static PyObject * TVertex_backSVertex( BPy_TVertex *self ) {
-	SVertex *v = self->tv->backSVertex();
-	if( v ){
-		return BPy_SVertex_from_SVertex( *v );
-	}
+static PyObject * TVertex_get_mate( BPy_TVertex *self, PyObject *args)
+{
+	PyObject *py_ve;
 
+	if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve))
+		return NULL;
+	ViewEdge *ve = self->tv->mate(((BPy_ViewEdge *)py_ve)->ve);
+	if (ve)
+		return BPy_ViewEdge_from_ViewEdge(*ve);
 	Py_RETURN_NONE;
 }
 
-static char TVertex_setFrontSVertex___doc__[] =
-".. method:: setFrontSVertex(iFrontSVertex)\n"
-"\n"
-"   Sets the SVertex that is closer to the viewpoint.\n"
-"\n"
-"   :arg iFrontSVertex: An SVertex object.\n"
-"   :type iFrontSVertex: :class:`SVertex`\n";
-
-static PyObject * TVertex_setFrontSVertex( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_sv;
+static PyMethodDef BPy_TVertex_methods[] = {
+	{"get_svertex", (PyCFunction)TVertex_get_svertex, METH_VARARGS, TVertex_get_svertex_doc},
+	{"get_mate", (PyCFunction)TVertex_get_mate, METH_VARARGS, TVertex_get_mate_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-	if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) ))
-		return NULL;
+/*----------------------TVertex get/setters ----------------------------*/
 
-	self->tv->setFrontSVertex( ((BPy_SVertex *) py_sv)->sv );
+PyDoc_STRVAR(TVertex_front_svertex_doc,
+"The SVertex that is closer to the viewpoint.\n"
+"\n"
+":type: :class:`SVertex`");
 
+static PyObject *TVertex_front_svertex_get(BPy_TVertex *self, void *UNUSED(closure))
+{
+	SVertex *v = self->tv->frontSVertex();
+	if (v)
+		return BPy_SVertex_from_SVertex(*v);
 	Py_RETURN_NONE;
 }
 
-static char TVertex_setBackSVertex___doc__[] =
-".. method:: setBackSVertex(iBackSVertex)\n"
-"\n"
-"   Sets the SVertex that is further away from the viewpoint.\n"
-"\n"
-"   :arg iBackSVertex: An SVertex object.\n"
-"   :type iBackSVertex: :class:`SVertex`\n";
-
-static PyObject * TVertex_setBackSVertex( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_sv;
-
-	if(!( PyArg_ParseTuple(args, "O", &SVertex_Type, &py_sv) ))
-		return NULL;
-
-	self->tv->setBackSVertex( ((BPy_SVertex *) py_sv)->sv );
-
-	Py_RETURN_NONE;
+static int TVertex_front_svertex_set(BPy_TVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SVertex_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+		return -1;
+	}
+	self->tv->setFrontSVertex(((BPy_SVertex *)value)->sv);
+	return 0;
 }
 
-static char TVertex_setId___doc__[] =
-".. method:: setId(iId)\n"
-"\n"
-"   Sets the Id.\n"
+PyDoc_STRVAR(TVertex_back_svertex_doc,
+"The SVertex that is further away from the viewpoint.\n"
 "\n"
-"   :arg iId: An Id object.\n"
-"   :type iId: :class:`Id`\n";
-
-static PyObject * TVertex_setId( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_id;
-
-	if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) ))
-		return NULL;
-
-	if( ((BPy_Id *) py_id)->id )
-		self->tv->setId(*( ((BPy_Id *) py_id)->id ));
+":type: :class:`SVertex`");
 
+static PyObject *TVertex_back_svertex_get(BPy_TVertex *self, void *UNUSED(closure))
+{
+	SVertex *v = self->tv->backSVertex();
+	if (v)
+		return BPy_SVertex_from_SVertex(*v);
 	Py_RETURN_NONE;
 }
 
-static char TVertex_getSVertex___doc__[] =
-".. method:: getSVertex(iFEdge)\n"
-"\n"
-"   Returns the SVertex (among the 2) belonging to the given FEdge.\n"
-"\n"
-"   :arg iFEdge: An FEdge object.\n"
-"   :type iFEdge: :class:`FEdge`\n"
-"   :return: The SVertex belonging to the given FEdge.\n"
-"   :rtype: :class:`SVertex`\n";
-
-static PyObject * TVertex_getSVertex( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_fe;
-
-	if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) ))
-		return NULL;
-
-	SVertex *sv = self->tv->getSVertex( ((BPy_FEdge *) py_fe)->fe );
-	if( sv ){
-		return BPy_SVertex_from_SVertex( *sv );
+static int TVertex_back_svertex_set(BPy_TVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SVertex_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SVertex");
+		return -1;
 	}
-
-	Py_RETURN_NONE;
+	self->tv->setBackSVertex(((BPy_SVertex *)value)->sv);
+	return 0;
 }
 
-static char TVertex_mate___doc__[] =
-".. method:: mate(iEdgeA)\n"
-"\n"
-"   Returns the mate edge of the ViewEdge given as argument.  If the\n"
-"   ViewEdge is frontEdgeA, frontEdgeB is returned.  If the ViewEdge is\n"
-"   frontEdgeB, frontEdgeA is returned.  Same for back edges.\n"
+PyDoc_STRVAR(TVertex_id_doc,
+"The Id of this TVertex.\n"
 "\n"
-"   :arg iEdgeA: A ViewEdge object.\n"
-"   :type iEdgeA: :class:`ViewEdge`\n"
-"   :return: The mate edge of the given ViewEdge.\n"
-"   :rtype: :class:`ViewEdge`\n";
+":type: :class:`Id`");
 
-static PyObject * TVertex_mate( BPy_TVertex *self, PyObject *args) {
-	PyObject *py_ve;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
-		return NULL;
+static PyObject *TVertex_id_get(BPy_TVertex *self, void *UNUSED(closure))
+{
+	Id id(self->tv->getId());
+	return BPy_Id_from_Id(id); // return a copy
+}
 
-	ViewEdge *ve = self->tv->mate( ((BPy_ViewEdge *) py_ve)->ve );
-	if( ve ){
-		return BPy_ViewEdge_from_ViewEdge( *ve );
+static int TVertex_id_set(BPy_TVertex *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_Id_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an Id");
+		return -1;
 	}
-
-	Py_RETURN_NONE;
+	self->tv->setId(*(((BPy_Id *)value)->id));
+	return 0;
 }
 
-/*----------------------TVertex instance definitions ----------------------------*/
-static PyMethodDef BPy_TVertex_methods[] = {	
-	{"frontSVertex", ( PyCFunction ) TVertex_frontSVertex, METH_NOARGS, TVertex_frontSVertex___doc__},
-	{"backSVertex", ( PyCFunction ) TVertex_backSVertex, METH_NOARGS, TVertex_backSVertex___doc__},
-	{"setFrontSVertex", ( PyCFunction ) TVertex_setFrontSVertex, METH_VARARGS, TVertex_setFrontSVertex___doc__},
-	{"setBackSVertex", ( PyCFunction ) TVertex_setBackSVertex, METH_VARARGS, TVertex_setBackSVertex___doc__},
-	{"setId", ( PyCFunction ) TVertex_setId, METH_VARARGS, TVertex_setId___doc__},
-	{"getSVertex", ( PyCFunction ) TVertex_getSVertex, METH_VARARGS, TVertex_getSVertex___doc__},
-	{"mate", ( PyCFunction ) TVertex_mate, METH_VARARGS, TVertex_mate___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_TVertex_getseters[] = {
+	{(char *)"front_svertex", (getter)TVertex_front_svertex_get, (setter)TVertex_front_svertex_set, (char *)TVertex_front_svertex_doc, NULL},
+	{(char *)"back_svertex", (getter)TVertex_back_svertex_get, (setter)TVertex_back_svertex_set, (char *)TVertex_back_svertex_doc, NULL},
+	{(char *)"id", (getter)TVertex_id_get, (setter)TVertex_id_set, (char *)TVertex_id_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_TVertex type definition ------------------------------*/
@@ -222,7 +195,7 @@ PyTypeObject TVertex_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	TVertex___doc__,                /* tp_doc */
+	TVertex_doc,                    /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -231,13 +204,13 @@ PyTypeObject TVertex_Type = {
 	0,                              /* tp_iternext */
 	BPy_TVertex_methods,            /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_TVertex_getseters,          /* tp_getset */
 	&ViewVertex_Type,               /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)TVertex___init__,     /* tp_init */
+	(initproc)TVertex_init,         /* tp_init */
 	0,                              /* tp_alloc */
 	0,                              /* tp_new */
 };