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, 154 insertions, 193 deletions

diff --git a/source/blender/freestyle/intern/python/BPy_ViewShape.cpp b/source/blender/freestyle/intern/python/BPy_ViewShape.cpp
index eebfa88773c..95e17251194 100644
--- a/source/blender/freestyle/intern/python/BPy_ViewShape.cpp
+++ b/source/blender/freestyle/intern/python/BPy_ViewShape.cpp
@@ -12,22 +12,23 @@ extern "C" {
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 //-------------------MODULE INITIALIZATION--------------------------------
-int ViewShape_Init( PyObject *module )
+
+int ViewShape_Init(PyObject *module)
 {
-	if( module == NULL )
+	if (module == NULL)
 		return -1;
 
-	if( PyType_Ready( &ViewShape_Type ) < 0 )
+	if (PyType_Ready(&ViewShape_Type) < 0)
 		return -1;
-
-	Py_INCREF( &ViewShape_Type );
+	Py_INCREF(&ViewShape_Type);
 	PyModule_AddObject(module, "ViewShape", (PyObject *)&ViewShape_Type);
+
 	return 0;
 }
 
-//------------------------INSTANCE METHODS ----------------------------------
+/*----------------------ViewShape methods ----------------------------*/
 
-static char ViewShape___doc__[] =
+PyDoc_STRVAR(ViewShape_doc,
 "Class gathering the elements of the ViewMap (i.e., :class:`ViewVertex`\n"
 "and :class:`ViewEdge`) that are issued from the same input shape.\n"
 "\n"
@@ -47,23 +48,23 @@ static char ViewShape___doc__[] =
 "   Builds a ViewShape from an SShape.\n"
 "\n"
 "   :arg iSShape: An SShape object.\n"
-"   :type iSShape: :class:`SShape`\n";
+"   :type iSShape: :class:`SShape`");
 
-static int ViewShape___init__(BPy_ViewShape *self, PyObject *args, PyObject *kwds)
+static int ViewShape_init(BPy_ViewShape *self, PyObject *args, PyObject *kwds)
 {
 	PyObject *obj;
 
-    if (! PyArg_ParseTuple(args, "|O", &obj) )
-        return -1;
+	if (!PyArg_ParseTuple(args, "|O", &obj))
+		return -1;
 
-	if( !obj ) {
+	if (!obj) {
 		self->vs = new ViewShape();
-	
-	} else if( BPy_SShape_Check(obj) ) {
-		self->vs = new ViewShape( ((BPy_SShape *) obj)->ss );
-	
-	} else if( BPy_ViewShape_Check(obj) ) {
-		self->vs = new ViewShape(*( ((BPy_ViewShape *) obj)->vs ));
+
+	} else if (BPy_SShape_Check(obj)) {
+		self->vs = new ViewShape(((BPy_SShape *)obj)->ss);
+
+	} else if (BPy_ViewShape_Check(obj)) {
+		self->vs = new ViewShape(*(((BPy_ViewShape *)obj)->vs));
 
 	} else {
 		PyErr_SetString(PyExc_TypeError, "invalid argument");
@@ -71,236 +72,196 @@ static int ViewShape___init__(BPy_ViewShape *self, PyObject *args, PyObject *kwd
 	}
 	self->borrowed = 0;
 	
-    return 0;
+	return 0;
 }
 
-static void ViewShape___dealloc__(BPy_ViewShape *self)
+static void ViewShape_dealloc(BPy_ViewShape *self)
 {
-	if( self->vs && !self->borrowed )
+	if (self->vs && !self->borrowed)
 		delete self->vs;
-    Py_TYPE(self)->tp_free((PyObject*)self);
+	Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-static PyObject * ViewShape___repr__(BPy_ViewShape *self)
+static PyObject * ViewShape_repr(BPy_ViewShape *self)
 {
-    return PyUnicode_FromFormat("ViewShape - address: %p", self->vs );
+	return PyUnicode_FromFormat("ViewShape - address: %p", self->vs );
 }
 
-static char ViewShape_sshape___doc__[] =
-".. method:: sshape()\n"
+PyDoc_STRVAR(ViewShape_add_edge_doc,
+".. method:: add_edge(iEdge)\n"
 "\n"
-"   Returns the SShape on top of which this ViewShape is built.\n"
+"   Adds a ViewEdge to the list of ViewEdge objects.\n"
 "\n"
-"   :return: The SShape on top of which this ViewShape is built.\n"
-"   :rtype: :class:`SShape`\n";
+"   :arg iEdge: A ViewEdge object.\n"
+"   :type iEdge: :class:`ViewEdge`\n");
 
-static PyObject * ViewShape_sshape( BPy_ViewShape *self ) {
-	return BPy_SShape_from_SShape( *(self->vs->sshape()) );
+static PyObject * ViewShape_add_edge(BPy_ViewShape *self , PyObject *args)
+{
+	PyObject *py_ve = 0;
+
+	if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve))
+		return NULL;
+	self->vs->AddEdge(((BPy_ViewEdge *)py_ve)->ve);
+	Py_RETURN_NONE;
 }
 
-static char ViewShape_vertices___doc__[] =
-".. method:: vertices()\n"
+PyDoc_STRVAR(ViewShape_add_vertex_doc,
+".. method:: add_vertex(iVertex)\n"
 "\n"
-"   Returns the list of ViewVertex objects contained in this ViewShape.\n"
+"   Adds a ViewVertex to the list of the ViewVertex objects.\n"
 "\n"
-"   :return: The list of ViewVertex objects.\n"
-"   :rtype: List of :class:`ViewVertex` objects\n";
+"   :arg iVertex: A ViewVertex object.\n"
+"   :type iVertex: :class:`ViewVertex`");
 
-static PyObject * ViewShape_vertices( BPy_ViewShape *self ) {
-	PyObject *py_vertices = PyList_New(0);
+static PyObject * ViewShape_add_vertex(BPy_ViewShape *self , PyObject *args)
+{
+	PyObject *py_vv = 0;
 
-	vector< ViewVertex * > vertices = self->vs->vertices();
-	vector< ViewVertex * >::iterator it;
-	
-	for( it = vertices.begin(); it != vertices.end(); it++ ) {
-		PyList_Append( py_vertices, Any_BPy_ViewVertex_from_ViewVertex(*( *it )) );
-	}
-	
-	return py_vertices;
+	if (!PyArg_ParseTuple(args, "O!", &ViewVertex_Type, &py_vv))
+		return NULL;
+	self->vs->AddVertex(((BPy_ViewVertex *)py_vv)->vv);
+	Py_RETURN_NONE;
 }
 
-static char ViewShape_edges___doc__[] =
-".. method:: edges()\n"
-"\n"
-"   Returns the list of ViewEdge objects contained in this ViewShape.\n"
-"\n"
-"   :return: The list of ViewEdge objects.\n"
-"   :rtype: List of :class:`ViewEdge` objects\n";
+// virtual ViewShape *duplicate()
 
-static PyObject * ViewShape_edges( BPy_ViewShape *self ) {
-	PyObject *py_edges = PyList_New(0);
+static PyMethodDef BPy_ViewShape_methods[] = {
+	{"add_edge", (PyCFunction)ViewShape_add_edge, METH_VARARGS, ViewShape_add_edge_doc},
+	{"add_vertex", (PyCFunction)ViewShape_add_vertex, METH_VARARGS, ViewShape_add_vertex_doc},
+	{NULL, NULL, 0, NULL}
+};
 
-	vector< ViewEdge * > edges = self->vs->edges();
-	vector< ViewEdge * >::iterator it;
-	
-	for( it = edges.begin(); it != edges.end(); it++ ) {
-		PyList_Append( py_edges, BPy_ViewEdge_from_ViewEdge(*( *it )) );
-	}
-	
-	return py_edges;
-}
+/*----------------------ViewShape get/setters ----------------------------*/
 
-static char ViewShape_getId___doc__[] =
-".. method:: getId()\n"
+PyDoc_STRVAR(ViewShape_sshape_doc,
+"The SShape on top of which this ViewShape is built.\n"
 "\n"
-"   Returns the ViewShape id.\n"
-"\n"
-"   :return: An Id object.\n"
-"   :rtype: :class:`Id`\n";
+":type: :class:`SShape`");
 
-static PyObject * ViewShape_getId( BPy_ViewShape *self ) {
-	Id id( self->vs->getId() );
-	return BPy_Id_from_Id( id );
+static PyObject *ViewShape_sshape_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	return BPy_SShape_from_SShape(*(self->vs->sshape()));
 }
 
-static char ViewShape_getName___doc__[] =
-".. method:: getName()\n"
-"\n"
-"   Returns the name of the ViewShape.\n"
-"\n"
-"   :return: The name string.\n"
-"   :rtype: str\n";
-
-static PyObject * ViewShape_getName( BPy_ViewShape *self ) {
-	return PyUnicode_FromString( self->vs->getName().c_str() );
+static int ViewShape_sshape_set(BPy_ViewShape *self, PyObject *value, void *UNUSED(closure))
+{
+	if (!BPy_SShape_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be an SShape");
+		return -1;
+	}
+	self->vs->setSShape(((BPy_SShape *)value)->ss);
+	return 0;
 }
 
-static char ViewShape_setSShape___doc__[] =
-".. method:: setSShape(iSShape)\n"
-"\n"
-"   Sets the SShape on top of which the ViewShape is built.\n"
+PyDoc_STRVAR(ViewShape_vertices_doc,
+"The list of ViewVertex objects contained in this ViewShape.\n"
 "\n"
-"   :arg iSShape: An SShape object.\n"
-"   :type iSShape: :class:`SShape`\n";
-
-static PyObject * ViewShape_setSShape( BPy_ViewShape *self , PyObject *args) {
-	PyObject *py_ss = 0;
+":type: List of :class:`ViewVertex` objects");
 
-	if(!( PyArg_ParseTuple(args, "O!", &SShape_Type, &py_ss) ))
-		return NULL;
-	
-	self->vs->setSShape( ((BPy_SShape *) py_ss)->ss );
+static PyObject *ViewShape_vertices_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	PyObject *py_vertices = PyList_New(0);
 
-	Py_RETURN_NONE;
+	vector< ViewVertex * > vertices = self->vs->vertices();
+	vector< ViewVertex * >::iterator it;
+	for (it = vertices.begin(); it != vertices.end(); it++) {
+		PyList_Append( py_vertices, Any_BPy_ViewVertex_from_ViewVertex(*(*it)));
+	}
+	return py_vertices;
 }
 
-static char ViewShape_setVertices___doc__[] =
-".. method:: setVertices(iVertices)\n"
-"\n"
-"   Sets the list of ViewVertex objects contained in this ViewShape.\n"
-"\n"
-"   :arg iVertices: The list of ViewVertex objects.\n"
-"   :type iVertices: List of :class:`ViewVertex` objects\n";
-
-static PyObject * ViewShape_setVertices( BPy_ViewShape *self , PyObject *args) {
+static int ViewShape_vertices_set(BPy_ViewShape *self, PyObject *value, void *UNUSED(closure))
+{
 	PyObject *list = 0;
-	PyObject *tmp;
-	
-	if(!( PyArg_ParseTuple(args, "O!", &PyList_Type, &list) ))
-		return NULL;
-	
+	PyObject *item;
 	vector< ViewVertex *> v;
 	
-	for( int i=0; i < PyList_Size(list); i++ ) {
-		tmp = PyList_GetItem(list, i);
-		if( BPy_ViewVertex_Check(tmp) )
-			v.push_back( ((BPy_ViewVertex *) tmp)->vv );
-		else {
-			PyErr_SetString(PyExc_TypeError, "argument must be list of ViewVertex objects");
-			return NULL;
+	if (!PyList_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a list of ViewVertex objects");
+		return -1;
+	}
+	for (int i = 0; i < PyList_Size(list); i++) {
+		item = PyList_GetItem(list, i);
+		if (BPy_ViewVertex_Check(item)) {
+			v.push_back(((BPy_ViewVertex *)item)->vv);
+		} else {
+			PyErr_SetString(PyExc_TypeError, "value must be a list of ViewVertex objects");
+			return -1;
 		}
 	}
-		
-	self->vs->setVertices( v );
-
-	Py_RETURN_NONE;
+	self->vs->setVertices(v);
+	return 0;
 }
 
-static char ViewShape_setEdges___doc__[] =
-".. method:: setEdges(iEdges)\n"
-"\n"
-"   Sets the list of ViewEdge objects contained in this ViewShape.\n"
+PyDoc_STRVAR(ViewShape_edges_doc,
+"The list of ViewEdge objects contained in this ViewShape.\n"
 "\n"
-"   :arg iEdges: The list of ViewEdge objects.\n"
-"   :type iEdges: List of :class:`ViewEdge` objects.\n";
+":type: List of :class:`ViewEdge` objects");
 
-static PyObject * ViewShape_setEdges( BPy_ViewShape *self , PyObject *args) {
-	PyObject *list = 0;
-	PyObject *tmp;
+static PyObject *ViewShape_edges_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	PyObject *py_edges = PyList_New(0);
 
-	if(!( PyArg_ParseTuple(args, "O!", &PyList_Type, &list) ))
-		return NULL;
+	vector< ViewEdge * > edges = self->vs->edges();
+	vector< ViewEdge * >::iterator it;
 
+	for (it = edges.begin(); it != edges.end(); it++) {
+		PyList_Append(py_edges, BPy_ViewEdge_from_ViewEdge(*(*it)));
+	}
+	return py_edges;
+}
+
+static int ViewShape_edges_set(BPy_ViewShape *self, PyObject *value, void *UNUSED(closure))
+{
+	PyObject *list = 0;
+	PyObject *item;
 	vector<ViewEdge *> v;
 
-	for( int i=0; i < PyList_Size(list); i++ ) {
-		tmp = PyList_GetItem(list, i);
-		if( BPy_ViewEdge_Check(tmp) )
-			v.push_back( ((BPy_ViewEdge *) tmp)->ve );
-		else {
+	if (!PyList_Check(value)) {
+		PyErr_SetString(PyExc_TypeError, "value must be a list of ViewEdge objects");
+		return -1;
+	}
+	for (int i = 0; i < PyList_Size(list); i++) {
+		item = PyList_GetItem(list, i);
+		if (BPy_ViewEdge_Check(item)) {
+			v.push_back(((BPy_ViewEdge *)item)->ve);
+		} else {
 			PyErr_SetString(PyExc_TypeError, "argument must be list of ViewEdge objects");
-			return NULL;
+			return -1;
 		}
 	}
-
-	self->vs->setEdges( v );
-
-	Py_RETURN_NONE;
+	self->vs->setEdges(v);
+	return 0;
 }
 
-static char ViewShape_AddEdge___doc__[] =
-".. method:: AddEdge(iEdge)\n"
-"\n"
-"   Adds a ViewEdge to the list of ViewEdge objects.\n"
+PyDoc_STRVAR(ViewShape_name_doc,
+"The name of the ViewShape.\n"
 "\n"
-"   :arg iEdge: A ViewEdge object.\n"
-"   :type iEdge: :class:`ViewEdge`\n";
-
-static PyObject * ViewShape_AddEdge( BPy_ViewShape *self , PyObject *args) {
-	PyObject *py_ve = 0;
+":type: str");
 
-	if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) ))
-		return NULL;
-	
-	self->vs->AddEdge( ((BPy_ViewEdge *) py_ve)->ve );
-
-	Py_RETURN_NONE;
+static PyObject *ViewShape_name_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	return PyUnicode_FromString(self->vs->getName().c_str());
 }
 
-static char ViewShape_AddVertex___doc__[] =
-".. method:: AddVertex(iVertex)\n"
-"\n"
-"   Adds a ViewVertex to the list of the ViewVertex objects.\n"
+PyDoc_STRVAR(ViewShape_id_doc,
+"The Id of this ViewShape.\n"
 "\n"
-"   :arg iVertex: A ViewVertex object.\n"
-"   :type iVertex: :class:`ViewVertex`\n";
-
-static PyObject * ViewShape_AddVertex( BPy_ViewShape *self , PyObject *args) {
-	PyObject *py_vv = 0;
-
-	if(!( PyArg_ParseTuple(args, "O!", &ViewVertex_Type, &py_vv) ))
-		return NULL;
-	
-	self->vs->AddVertex( ((BPy_ViewVertex *) py_vv)->vv );
+":type: :class:`Id`");
 
-	Py_RETURN_NONE;
+static PyObject *ViewShape_id_get(BPy_ViewShape *self, void *UNUSED(closure))
+{
+	Id id(self->vs->getId());
+	return BPy_Id_from_Id(id); // return a copy
 }
 
-// virtual ViewShape * 	duplicate ()
-
-/*---------------------- BPy_ViewShape instance definitions ----------------------------*/
-static PyMethodDef BPy_ViewShape_methods[] = {
-	{"sshape", ( PyCFunction ) ViewShape_sshape, METH_NOARGS, ViewShape_sshape___doc__},
-	{"vertices", ( PyCFunction ) ViewShape_vertices, METH_NOARGS, ViewShape_vertices___doc__},
-	{"edges", ( PyCFunction ) ViewShape_edges, METH_NOARGS, ViewShape_edges___doc__},
-	{"getId", ( PyCFunction ) ViewShape_getId, METH_NOARGS, ViewShape_getId___doc__},
-	{"getName", ( PyCFunction ) ViewShape_getName, METH_NOARGS, ViewShape_getName___doc__},
-	{"setSShape", ( PyCFunction ) ViewShape_setSShape, METH_VARARGS, ViewShape_setSShape___doc__},
-	{"setVertices", ( PyCFunction ) ViewShape_setVertices, METH_VARARGS, ViewShape_setVertices___doc__},
-	{"setEdges", ( PyCFunction ) ViewShape_setEdges, METH_VARARGS, ViewShape_setEdges___doc__},
-	{"AddEdge", ( PyCFunction ) ViewShape_AddEdge, METH_VARARGS, ViewShape_AddEdge___doc__},
-	{"AddVertex", ( PyCFunction ) ViewShape_AddVertex, METH_VARARGS, ViewShape_AddVertex___doc__},
-	{NULL, NULL, 0, NULL}
+static PyGetSetDef BPy_ViewShape_getseters[] = {
+	{(char *)"sshape", (getter)ViewShape_sshape_get, (setter)ViewShape_sshape_set, (char *)ViewShape_sshape_doc, NULL},
+	{(char *)"vertices", (getter)ViewShape_vertices_get, (setter)ViewShape_vertices_set, (char *)ViewShape_vertices_doc, NULL},
+	{(char *)"edges", (getter)ViewShape_edges_get, (setter)ViewShape_edges_set, (char *)ViewShape_edges_doc, NULL},
+	{(char *)"name", (getter)ViewShape_name_get, (setter)NULL, (char *)ViewShape_name_doc, NULL},
+	{(char *)"id", (getter)ViewShape_id_get, (setter)NULL, (char *)ViewShape_id_doc, NULL},
+	{NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
 };
 
 /*-----------------------BPy_ViewShape type definition ------------------------------*/
@@ -310,12 +271,12 @@ PyTypeObject ViewShape_Type = {
 	"ViewShape",                    /* tp_name */
 	sizeof(BPy_ViewShape),          /* tp_basicsize */
 	0,                              /* tp_itemsize */
-	(destructor)ViewShape___dealloc__, /* tp_dealloc */
+	(destructor)ViewShape_dealloc,  /* tp_dealloc */
 	0,                              /* tp_print */
 	0,                              /* tp_getattr */
 	0,                              /* tp_setattr */
 	0,                              /* tp_reserved */
-	(reprfunc)ViewShape___repr__,   /* tp_repr */
+	(reprfunc)ViewShape_repr,       /* tp_repr */
 	0,                              /* tp_as_number */
 	0,                              /* tp_as_sequence */
 	0,                              /* tp_as_mapping */
@@ -326,7 +287,7 @@ PyTypeObject ViewShape_Type = {
 	0,                              /* tp_setattro */
 	0,                              /* tp_as_buffer */
 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	ViewShape___doc__,              /* tp_doc */
+	ViewShape_doc,              /* tp_doc */
 	0,                              /* tp_traverse */
 	0,                              /* tp_clear */
 	0,                              /* tp_richcompare */
@@ -335,13 +296,13 @@ PyTypeObject ViewShape_Type = {
 	0,                              /* tp_iternext */
 	BPy_ViewShape_methods,          /* tp_methods */
 	0,                              /* tp_members */
-	0,                              /* tp_getset */
+	BPy_ViewShape_getseters,        /* tp_getset */
 	0,                              /* tp_base */
 	0,                              /* tp_dict */
 	0,                              /* tp_descr_get */
 	0,                              /* tp_descr_set */
 	0,                              /* tp_dictoffset */
-	(initproc)ViewShape___init__,   /* tp_init */
+	(initproc)ViewShape_init,       /* tp_init */
 	0,                              /* tp_alloc */
 	PyType_GenericNew,              /* tp_new */
 };