Major documentation updates. The original Freestyle API reference

(http://freestyle.sourceforge.net/doc/html/index.html) has been
incorporated into the Blender/Freestyle Python API implementation
in the form of Sphinx-based embedded docstrings.  Some C++-specific
descriptions of classes and functions were revised so that they are
suitable for Python programmers.  Missing docstrings were filled,
and sparse descriptions were extended.  By means of the new
documentation system for Blender, an up-to-date Freestyle Python
API reference will be part of the Blender 2.5 documentation.

1 files changed, 372 insertions, 129 deletions

diff --git a/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp b/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp
index 30fb7a5c2e3..875edaea2d5 100644
--- a/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp
+++ b/source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp
@@ -8,107 +8,6 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-/*---------------  Python API function prototypes for StrokeAttribute instance  -----------*/
-static int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds);
-static void StrokeAttribute___dealloc__(BPy_StrokeAttribute *self);
-static PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute *self);
-
-static PyObject * StrokeAttribute_getColorR( BPy_StrokeAttribute *self );
-static PyObject * StrokeAttribute_getColorG( BPy_StrokeAttribute *self );
-static PyObject * StrokeAttribute_getColorB( BPy_StrokeAttribute *self );
-static PyObject * StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self );
-static PyObject * StrokeAttribute_getAlpha( BPy_StrokeAttribute *self );
-static PyObject * StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self );
-static PyObject * StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self );
-static PyObject * StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self );
-static PyObject * StrokeAttribute_isVisible( BPy_StrokeAttribute *self );
-static PyObject * StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args );
-static PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args );
-
-
-/*----------------------StrokeAttribute instance definitions ----------------------------*/
-static PyMethodDef BPy_StrokeAttribute_methods[] = {
-	{"getColorR", ( PyCFunction ) StrokeAttribute_getColorR, METH_NOARGS, "Returns the R color component. "},
-	{"getColorG", ( PyCFunction ) StrokeAttribute_getColorG, METH_NOARGS, "Returns the G color component. "},
-	{"getColorB", ( PyCFunction ) StrokeAttribute_getColorB, METH_NOARGS, "Returns the B color component. "},
-	{"getColorRGB", ( PyCFunction ) StrokeAttribute_getColorRGB, METH_NOARGS, "Returns the RGB color components."},
-	{"getAlpha", ( PyCFunction ) StrokeAttribute_getAlpha, METH_NOARGS, "Returns the alpha color component."},
-	{"getThicknessR", ( PyCFunction ) StrokeAttribute_getThicknessR, METH_NOARGS, "Returns the thickness on the right of the vertex when following the stroke. "},
-	{"getThicknessL", ( PyCFunction ) StrokeAttribute_getThicknessL, METH_NOARGS, "Returns the thickness on the left of the vertex when following the stroke."},
-	{"getThicknessRL", ( PyCFunction ) StrokeAttribute_getThicknessRL, METH_NOARGS, "Returns the thickness on the right and on the left of the vertex when following the stroke. "},
-	{"isVisible", ( PyCFunction ) StrokeAttribute_isVisible, METH_NOARGS, "Returns true if the strokevertex is visible, false otherwise"},
-	{"getAttributeReal", ( PyCFunction ) StrokeAttribute_getAttributeReal, METH_VARARGS, "(name) Returns an attribute of type real specified by name."},
-	{"getAttributeVec2f", ( PyCFunction ) StrokeAttribute_getAttributeVec2f, METH_VARARGS, "(name) Returns an attribute of type Vec2f specified by name."},
-	{"getAttributeVec3f", ( PyCFunction ) StrokeAttribute_getAttributeVec3f, METH_VARARGS, "(name) Returns an attribute of type Vec3f specified by name."},
-	{"isAttributeAvailableReal", ( PyCFunction ) StrokeAttribute_isAttributeAvailableReal, METH_VARARGS, "(name) Checks whether the real attribute specified by name is available"},
-	{"isAttributeAvailableVec2f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec2f, METH_VARARGS, "(name) Checks whether the Vec2f attribute specified by name is available"},
-	{"isAttributeAvailableVec3f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec3f, METH_VARARGS, "(name) Checks whether the Vec3f attribute specified by name is available"},
-	{"setColor", ( PyCFunction ) StrokeAttribute_setColor, METH_VARARGS, "(float a)Sets the attribute's alpha value. "},
-	{"setAlpha", ( PyCFunction ) StrokeAttribute_setAlpha, METH_VARARGS, "(float a) Sets the attribute's alpha value."},
-	{"setThickness", ( PyCFunction ) StrokeAttribute_setThickness, METH_VARARGS, ""},
-	{"setVisible", ( PyCFunction ) StrokeAttribute_setVisible, METH_VARARGS, ""},
-	{"setAttributeReal", ( PyCFunction ) StrokeAttribute_setAttributeReal, METH_VARARGS, "(name, float att) Adds a user defined attribute of type real. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
-	{"setAttributeVec2f", ( PyCFunction ) StrokeAttribute_setAttributeVec2f, METH_VARARGS, "(name, float att) Adds a user defined attribute of type Vec2f. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
-	{"setAttributeVec3f", ( PyCFunction ) StrokeAttribute_setAttributeVec3f, METH_VARARGS, "(name, float att) Adds a user defined attribute of type Vec4f. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
-	{NULL, NULL, 0, NULL}
-};
-
-
-
-/*-----------------------BPy_StrokeAttribute type definition ------------------------------*/
-
-PyTypeObject StrokeAttribute_Type = {
-	PyVarObject_HEAD_INIT(NULL, 0)
-	"StrokeAttribute",              /* tp_name */
-	sizeof(BPy_StrokeAttribute),    /* tp_basicsize */
-	0,                              /* tp_itemsize */
-	(destructor)StrokeAttribute___dealloc__, /* tp_dealloc */
-	0,                              /* tp_print */
-	0,                              /* tp_getattr */
-	0,                              /* tp_setattr */
-	0,                              /* tp_reserved */
-	(reprfunc)StrokeAttribute___repr__, /* tp_repr */
-	0,                              /* tp_as_number */
-	0,                              /* tp_as_sequence */
-	0,                              /* tp_as_mapping */
-	0,                              /* tp_hash  */
-	0,                              /* tp_call */
-	0,                              /* tp_str */
-	0,                              /* tp_getattro */
-	0,                              /* tp_setattro */
-	0,                              /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	"StrokeAttribute objects",      /* tp_doc */
-	0,                              /* tp_traverse */
-	0,                              /* tp_clear */
-	0,                              /* tp_richcompare */
-	0,                              /* tp_weaklistoffset */
-	0,                              /* tp_iter */
-	0,                              /* tp_iternext */
-	BPy_StrokeAttribute_methods,    /* tp_methods */
-	0,                              /* tp_members */
-	0,                              /* tp_getset */
-	0,                              /* tp_base */
-	0,                              /* tp_dict */
-	0,                              /* tp_descr_get */
-	0,                              /* tp_descr_set */
-	0,                              /* tp_dictoffset */
-	(initproc)StrokeAttribute___init__, /* tp_init */
-	0,                              /* tp_alloc */
-	PyType_GenericNew,              /* tp_new */
-};
-
 //-------------------MODULE INITIALIZATION--------------------------------
 int StrokeAttribute_Init( PyObject *module )
 {
@@ -124,7 +23,52 @@ int StrokeAttribute_Init( PyObject *module )
 
 //------------------------INSTANCE METHODS ----------------------------------
 
-int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
+static char StrokeAttribute___doc__[] =
+"Class to define a set of attributes associated with a :class:`StrokeVertex`.\n"
+"The attribute set stores the color, alpha and thickness values for a Stroke\n"
+"Vertex.\n"
+"\n"
+".. method:: __init__()\n"
+"\n"
+"   Default constructor.\n"
+"\n"
+".. method:: __init__(iBrother)\n"
+"\n"
+"   Copy constructor.\n"
+"\n"
+"   :arg iBrother: A StrokeAttribute object.\n"
+"   :type iBrother: :class:`StrokeAttribute`\n"
+"\n"
+".. method:: __init__(iRColor, iGColor, iBColor, iAlpha, iRThickness, iLThickness)\n"
+"\n"
+"   Builds a stroke vertex attribute from a set of parameters.\n"
+"\n"
+"   :arg iRColor: Red component of a stroke color.\n"
+"   :type iRColor: float\n"
+"   :arg iGColor: Green component of a stroke color.\n"
+"   :type iGColor: float\n"
+"   :arg iBColor: Blue component of a stroke color.\n"
+"   :type iBColor: float\n"
+"   :arg iAlpha: Alpha component of a stroke color.\n"
+"   :type iAlpha: float\n"
+"   :arg iRThickness: Stroke thickness on the right.\n"
+"   :type iRThickness: float\n"
+"   :arg iLThickness: Stroke thickness on the left.\n"
+"   :type iLThickness: float\n"
+"\n"
+".. method:: __init__(a1, a2, t)\n"
+"\n"
+"   Interpolation constructor. Builds a StrokeAttribute from two\n"
+"   StrokeAttribute objects and an interpolation parameter.\n"
+"\n"
+"   :arg a1: The first StrokeAttribute object.\n"
+"   :type a1: :class:`StrokeAttribute`\n"
+"   :arg a2: The second StrokeAttribute object.\n"
+"   :type a2: :class:`StrokeAttribute`\n"
+"   :arg t: The interpolation parameter.\n"
+"   :type t: float\n";
+
+static int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
 {
 
 	PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0, *obj4 = 0, *obj5 = 0 , *obj6 = 0;
@@ -164,14 +108,14 @@ int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject
 
 }
 
-void StrokeAttribute___dealloc__(BPy_StrokeAttribute* self)
+static void StrokeAttribute___dealloc__(BPy_StrokeAttribute* self)
 {
 	if( self->sa && !self->borrowed )
 		delete self->sa;
     Py_TYPE(self)->tp_free((PyObject*)self);
 }
 
-PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute* self)
+static PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute* self)
 {
 	stringstream repr("StrokeAttribute:");
 	repr << " r: " << self->sa->getColorR()
@@ -185,44 +129,132 @@ PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute* self)
 }
 
 
-PyObject *StrokeAttribute_getColorR( BPy_StrokeAttribute *self ) {
+static char StrokeAttribute_getColorR___doc__[] =
+".. method:: getColorR()\n"
+"\n"
+"   Returns the red component of the stroke color.\n"
+"\n"
+"   :return: Red component of the stroke color.\n"
+"   :rtype: float\n";
+
+static PyObject *StrokeAttribute_getColorR( BPy_StrokeAttribute *self ) {
 	return PyFloat_FromDouble( self->sa->getColorR() );	
 }
 
-PyObject *StrokeAttribute_getColorG( BPy_StrokeAttribute *self ) {
+static char StrokeAttribute_getColorG___doc__[] =
+".. method:: getColorG()\n"
+"\n"
+"   Returns the green component of the stroke color.\n"
+"\n"
+"   :return: Green component of the stroke color.\n"
+"   :rtype: float\n";
+
+static PyObject *StrokeAttribute_getColorG( BPy_StrokeAttribute *self ) {
 	return PyFloat_FromDouble( self->sa->getColorG() );	
 }
 
-PyObject *StrokeAttribute_getColorB( BPy_StrokeAttribute *self ) {
+static char StrokeAttribute_getColorB___doc__[] =
+".. method:: getColorB()\n"
+"\n"
+"   Returns the blue component of the stroke color.\n"
+"\n"
+"   :return: Blue component of the stroke color.\n"
+"   :rtype: float\n";
+
+static PyObject *StrokeAttribute_getColorB( BPy_StrokeAttribute *self ) {
 	return PyFloat_FromDouble( self->sa->getColorB() );	
 }
 
-PyObject *StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self ) {
+static char StrokeAttribute_getColorRGB___doc__[] =
+".. method:: getColorRGB()\n"
+"\n"
+"   Returns the RGB components of the stroke color.\n"
+"\n"
+"   :return: RGB components of the stroke color.\n"
+"   :rtype: :class:`Mathutils.Vector`\n";
+
+static PyObject *StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self ) {
 	Vec3f v( self->sa->getColorRGB() );
 	return Vector_from_Vec3f( v );	
 }
 
-PyObject *StrokeAttribute_getAlpha( BPy_StrokeAttribute *self ) {
+static char StrokeAttribute_getAlpha___doc__[] =
+".. method:: getAlpha()\n"
+"\n"
+"   Returns the alpha component of the stroke color.\n"
+"\n"
+"   :return: Alpha component of the stroke color.\n"
+"   :rtype: float\n";
+
+static PyObject *StrokeAttribute_getAlpha( BPy_StrokeAttribute *self ) {
 	return PyFloat_FromDouble( self->sa->getAlpha() );	
 }
 
-PyObject *StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self ) {
+static char StrokeAttribute_getThicknessR___doc__[] =
+".. method:: getThicknessR()\n"
+"\n"
+"   Returns the thickness on the right of the vertex when following\n"
+"   the stroke.\n"
+"\n"
+"   :return: The thickness on the right of the vertex.\n"
+"   :rtype: float\n";
+
+static PyObject *StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self ) {
 	return PyFloat_FromDouble( self->sa->getThicknessR() );	
 }
-PyObject *StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self ) {
+
+static char StrokeAttribute_getThicknessL___doc__[] =
+".. method:: getThicknessL()\n"
+"\n"
+"   Returns the thickness on the left of the vertex when following\n"
+"   the stroke.\n"
+"\n"
+"   :return: The thickness on the left of the vertex.\n"
+"   :rtype: float\n";
+
+static PyObject *StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self ) {
 	return PyFloat_FromDouble( self->sa->getThicknessL() );	
 }
-PyObject *StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self ) {
+
+static char StrokeAttribute_getThicknessRL___doc__[] =
+".. method:: getThicknessRL()\n"
+"\n"
+"   Returns the thickness on the right and on the left of the vertex\n"
+"   when following the stroke.\n"
+"\n"
+"   :return: A two-dimensional vector.  The first value is the\n"
+"      thickness on the right of the vertex when following the stroke,\n"
+"      and the second one is the thickness on the left.\n"
+"   :rtype: :class:`Mathutils.Vector`\n";
+
+static PyObject *StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self ) {
 	Vec2f v( self->sa->getThicknessRL() );
 	return Vector_from_Vec2f( v );
 }
 
-PyObject *StrokeAttribute_isVisible( BPy_StrokeAttribute *self ) {
+static char StrokeAttribute_isVisible___doc__[] =
+".. method:: isVisible()\n"
+"\n"
+"   Returns true if the StrokeVertex is visible, false otherwise.\n"
+"\n"
+"   :return: True if the StrokeVertex is visible, false otherwise.\n"
+"   :rtype: bool\n";
+
+static PyObject *StrokeAttribute_isVisible( BPy_StrokeAttribute *self ) {
 	return PyBool_from_bool( self->sa->isVisible() );	
 }
 
-
-PyObject *StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_getAttributeReal___doc__[] =
+".. method:: getAttributeReal(iName)\n"
+"\n"
+"   Returns an attribute of float type.\n"
+"\n"
+"   :arg iName: The name of the attribute.\n"
+"   :type iName: string\n"
+"   :return: The attribute value.\n"
+"   :rtype: float\n";
+
+static PyObject *StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
 	char *attr;
 
 	if(!( PyArg_ParseTuple(args, "s", &attr) ))
@@ -232,7 +264,17 @@ PyObject *StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject
 	return PyFloat_FromDouble( a );
 }
 
-PyObject *StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_getAttributeVec2f___doc__[] =
+".. method:: getAttributeVec2f(iName)\n"
+"\n"
+"   Returns an attribute of two-dimensional vector type.\n"
+"\n"
+"   :arg iName: The name of the attribute.\n"
+"   :type iName: string\n"
+"   :return: The attribute value.\n"
+"   :rtype: :class:`Mathutils.Vector`\n";
+
+static PyObject *StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
 	char *attr;
 
 	if(!( PyArg_ParseTuple(args, "s", &attr) ))
@@ -242,8 +284,17 @@ PyObject *StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject
 	return Vector_from_Vec2f( a );
 }
 
-
-PyObject *StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_getAttributeVec3f___doc__[] =
+".. method:: getAttributeVec3f(iName)\n"
+"\n"
+"   Returns an attribute of three-dimensional vector type.\n"
+"\n"
+"   :arg iName: The name of the attribute.\n"
+"   :type iName: string\n"
+"   :return: The attribute value.\n"
+"   :rtype: :class:`Mathutils.Vector`\n";
+
+static PyObject *StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
 	char *attr;
 
 	if(!( PyArg_ParseTuple(args, "s", &attr) ))
@@ -253,7 +304,17 @@ PyObject *StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject
 	return Vector_from_Vec3f( a );
 }
 
-PyObject *StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_isAttributeAvailableReal___doc__[] =
+".. method:: isAttributeAvailableReal(iName)\n"
+"\n"
+"   Checks whether the attribute iName of float type is available.\n"
+"\n"
+"   :arg iName: The name of the attribute.\n"
+"   :type iName: string\n"
+"   :return: True if the attribute is availbale.\n"
+"   :rtype: bool\n";
+
+static PyObject *StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args ) {
 	char *attr;
 
 	if(!( PyArg_ParseTuple(args, "s", &attr) ))
@@ -262,7 +323,18 @@ PyObject *StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, P
 	return PyBool_from_bool( self->sa->isAttributeAvailableReal( attr ) );
 }
 
-PyObject *StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_isAttributeAvailableVec2f___doc__[] =
+".. method:: isAttributeAvailableVec2f(iName)\n"
+"\n"
+"   Checks whether the attribute iName of two-dimensional vector type\n"
+"   is available.\n"
+"\n"
+"   :arg iName: The name of the attribute.\n"
+"   :type iName: string\n"
+"   :return: True if the attribute is availbale.\n"
+"   :rtype: bool\n";
+
+static PyObject *StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
 	char *attr;
 
 	if(!( PyArg_ParseTuple(args, "s", &attr) ))
@@ -271,7 +343,18 @@ PyObject *StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self,
 	return PyBool_from_bool( self->sa->isAttributeAvailableVec2f( attr ) );
 }
 
-PyObject *StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_isAttributeAvailableVec3f___doc__[] =
+".. method:: isAttributeAvailableVec3f(iName)\n"
+"\n"
+"   Checks whether the attribute iName of three-dimensional vector\n"
+"   type is available.\n"
+"\n"
+"   :arg iName: The name of the attribute.\n"
+"   :type iName: string\n"
+"   :return: True if the attribute is availbale.\n"
+"   :rtype: bool\n";
+
+static PyObject *StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
 	char *attr;
 
 	if(!( PyArg_ParseTuple(args, "s", &attr) ))
@@ -281,7 +364,26 @@ PyObject *StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self,
 }
 
 
-PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_setColor___doc__[] =
+".. method:: setColor(r, g, b)\n"
+"\n"
+"   Sets the stroke color.\n"
+"\n"
+"   :arg r: Red component of the stroke color.\n"
+"   :type r: float\n"
+"   :arg g: Green component of the stroke color.\n"
+"   :type g: float\n"
+"   :arg b: Blue component of the stroke color.\n"
+"   :type b: float\n"
+"\n"
+".. method:: setColor(iRGB)\n"
+"\n"
+"   Sets the stroke color.\n"
+"\n"
+"   :arg iRGB: The new RGB values.\n"
+"   :type iRGB: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n";
+
+static PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args ) {
 	PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0 ;
 
 	if(!( PyArg_ParseTuple(args, "O|OO", &obj1, &obj2, &obj3) ))
@@ -311,7 +413,15 @@ PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args )
 	Py_RETURN_NONE;
 }
 
-PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args ){
+static char StrokeAttribute_setAlpha___doc__[] =
+".. method:: setAlpha(alpha)\n"
+"\n"
+"   Sets the alpha component of the stroke color.\n"
+"\n"
+"   :arg alpha: The new alpha value.\n"
+"   :type alpha: float\n";
+
+static PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args ){
 	float f = 0;
 
 	if(!( PyArg_ParseTuple(args, "f", &f) ))
@@ -321,7 +431,27 @@ PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args )
 	Py_RETURN_NONE;
 }
 
-PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args )  {
+static char StrokeAttribute_setThickness___doc__[] =
+".. method:: setThickness(tr, tl)\n"
+"\n"
+"   Sets the stroke thickness.\n"
+"\n"
+"   :arg tr: The thickness on the right of the vertex when following\n"
+"      the stroke.\n"
+"   :type tr: float\n"
+"   :arg tl: The thickness on the left of the vertex when following\n"
+"      the stroke.\n"
+"   :type tl: float\n"
+"\n"
+".. method:: setThickness(tRL)\n"
+"\n"
+"   Sets the stroke thickness.\n"
+"\n"
+"   :arg tRL: The thickness on the right and on the left of the vertex\n"
+"      when following the stroke.\n"
+"   :type tRL: :class:`Mathutils.Vector`, list or tuple of 2 real numbers\n";
+
+static PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args )  {
 	PyObject *obj1 = 0, *obj2 = 0;
 
 	if(!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) ))
@@ -350,7 +480,15 @@ PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *ar
 	Py_RETURN_NONE;
 }
 
-PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_setVisible___doc__[] =
+".. method:: setVisible(iVisible)\n"
+"\n"
+"   Sets the visibility flag.  True means the StrokeVertex is visible.\n"
+"\n"
+"   :arg iVisible: True if the StrokeVertex is visible.\n"
+"   :type iVisible: bool\n";
+
+static PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args ) {
 	PyObject *py_b;
 
 	if(!( PyArg_ParseTuple(args, "O", &py_b) ))
@@ -361,8 +499,19 @@ PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args
 	Py_RETURN_NONE;
 }
 
-
-PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_setAttributeReal___doc__[] =
+".. method:: setAttributeReal(iName, att)\n"
+"\n"
+"   Adds a user-defined attribute of float type.  If there is no\n"
+"   attribute of the given name, it is added.  Otherwise, the new value\n"
+"   replaces the old one.\n"
+"\n"
+"   :arg iName: The name of the attribute.\n"
+"   :type iName: string\n"
+"   :arg att: The attribute value.\n"
+"   :type att: float\n";
+
+static PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
 	char *s = 0;
 	double d = 0;
 
@@ -373,7 +522,19 @@ PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject
 	Py_RETURN_NONE;
 }
 
-PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_setAttributeVec2f___doc__[] =
+".. method:: setAttributeVec2f(iName, att)\n"
+"\n"
+"   Adds a user-defined attribute of two-dimensional vector type.  If\n"
+"   there is no attribute of the given name, it is added.  Otherwise,\n"
+"   the new value replaces the old one.\n"
+"\n"
+"   :arg iName: The name of the attribute.\n"
+"   :type iName: string\n"
+"   :arg att: The attribute value.\n"
+"   :type att: :class:`Mathutils.Vector`, list or tuple of 2 real numbers\n";
+
+static PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
 	char *s;
 	PyObject *obj = 0;
 
@@ -390,7 +551,19 @@ PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObjec
 	Py_RETURN_NONE;
 }
 
-PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
+static char StrokeAttribute_setAttributeVec3f___doc__[] =
+".. method:: setAttributeVec3f(iName, att)\n"
+"\n"
+"   Adds a user-defined attribute of three-dimensional vector type.\n"
+"   If there is no attribute of the given name, it is added.\n"
+"   Otherwise, the new value replaces the old one.\n"
+"\n"
+"   :arg iName: The name of the attribute.\n"
+"   :type iName: string\n"
+"   :arg att: The attribute value.\n"
+"   :type att: :class:`Mathutils.Vector`, list or tuple of 3 real numbers\n";
+
+static PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
 	char *s;
 	PyObject *obj = 0;
 
@@ -407,6 +580,76 @@ PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObjec
 	Py_RETURN_NONE;
 }
 
+/*----------------------StrokeAttribute instance definitions ----------------------------*/
+static PyMethodDef BPy_StrokeAttribute_methods[] = {
+	{"getColorR", ( PyCFunction ) StrokeAttribute_getColorR, METH_NOARGS, StrokeAttribute_getColorR___doc__},
+	{"getColorG", ( PyCFunction ) StrokeAttribute_getColorG, METH_NOARGS, StrokeAttribute_getColorG___doc__},
+	{"getColorB", ( PyCFunction ) StrokeAttribute_getColorB, METH_NOARGS, StrokeAttribute_getColorB___doc__},
+	{"getColorRGB", ( PyCFunction ) StrokeAttribute_getColorRGB, METH_NOARGS, StrokeAttribute_getColorRGB___doc__},
+	{"getAlpha", ( PyCFunction ) StrokeAttribute_getAlpha, METH_NOARGS, StrokeAttribute_getAlpha___doc__},
+	{"getThicknessR", ( PyCFunction ) StrokeAttribute_getThicknessR, METH_NOARGS, StrokeAttribute_getThicknessR___doc__},
+	{"getThicknessL", ( PyCFunction ) StrokeAttribute_getThicknessL, METH_NOARGS, StrokeAttribute_getThicknessL___doc__},
+	{"getThicknessRL", ( PyCFunction ) StrokeAttribute_getThicknessRL, METH_NOARGS, StrokeAttribute_getThicknessRL___doc__},
+	{"isVisible", ( PyCFunction ) StrokeAttribute_isVisible, METH_NOARGS, StrokeAttribute_isVisible___doc__},
+	{"getAttributeReal", ( PyCFunction ) StrokeAttribute_getAttributeReal, METH_VARARGS, StrokeAttribute_getAttributeReal___doc__},
+	{"getAttributeVec2f", ( PyCFunction ) StrokeAttribute_getAttributeVec2f, METH_VARARGS, StrokeAttribute_getAttributeVec2f___doc__},
+	{"getAttributeVec3f", ( PyCFunction ) StrokeAttribute_getAttributeVec3f, METH_VARARGS, StrokeAttribute_getAttributeVec3f___doc__},
+	{"isAttributeAvailableReal", ( PyCFunction ) StrokeAttribute_isAttributeAvailableReal, METH_VARARGS, StrokeAttribute_isAttributeAvailableReal___doc__},
+	{"isAttributeAvailableVec2f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec2f, METH_VARARGS, StrokeAttribute_isAttributeAvailableVec2f___doc__},
+	{"isAttributeAvailableVec3f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec3f, METH_VARARGS, StrokeAttribute_isAttributeAvailableVec3f___doc__},
+	{"setColor", ( PyCFunction ) StrokeAttribute_setColor, METH_VARARGS, StrokeAttribute_setColor___doc__},
+	{"setAlpha", ( PyCFunction ) StrokeAttribute_setAlpha, METH_VARARGS, StrokeAttribute_setAlpha___doc__},
+	{"setThickness", ( PyCFunction ) StrokeAttribute_setThickness, METH_VARARGS, StrokeAttribute_setThickness___doc__},
+	{"setVisible", ( PyCFunction ) StrokeAttribute_setVisible, METH_VARARGS, StrokeAttribute_setVisible___doc__},
+	{"setAttributeReal", ( PyCFunction ) StrokeAttribute_setAttributeReal, METH_VARARGS, StrokeAttribute_setAttributeReal___doc__},
+	{"setAttributeVec2f", ( PyCFunction ) StrokeAttribute_setAttributeVec2f, METH_VARARGS, StrokeAttribute_setAttributeVec2f___doc__},
+	{"setAttributeVec3f", ( PyCFunction ) StrokeAttribute_setAttributeVec3f, METH_VARARGS, StrokeAttribute_setAttributeVec3f___doc__},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_StrokeAttribute type definition ------------------------------*/
+
+PyTypeObject StrokeAttribute_Type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"StrokeAttribute",              /* tp_name */
+	sizeof(BPy_StrokeAttribute),    /* tp_basicsize */
+	0,                              /* tp_itemsize */
+	(destructor)StrokeAttribute___dealloc__, /* tp_dealloc */
+	0,                              /* tp_print */
+	0,                              /* tp_getattr */
+	0,                              /* tp_setattr */
+	0,                              /* tp_reserved */
+	(reprfunc)StrokeAttribute___repr__, /* tp_repr */
+	0,                              /* tp_as_number */
+	0,                              /* tp_as_sequence */
+	0,                              /* tp_as_mapping */
+	0,                              /* tp_hash  */
+	0,                              /* tp_call */
+	0,                              /* tp_str */
+	0,                              /* tp_getattro */
+	0,                              /* tp_setattro */
+	0,                              /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+	StrokeAttribute___doc__,        /* tp_doc */
+	0,                              /* tp_traverse */
+	0,                              /* tp_clear */
+	0,                              /* tp_richcompare */
+	0,                              /* tp_weaklistoffset */
+	0,                              /* tp_iter */
+	0,                              /* tp_iternext */
+	BPy_StrokeAttribute_methods,    /* tp_methods */
+	0,                              /* tp_members */
+	0,                              /* tp_getset */
+	0,                              /* tp_base */
+	0,                              /* tp_dict */
+	0,                              /* tp_descr_get */
+	0,                              /* tp_descr_set */
+	0,                              /* tp_dictoffset */
+	(initproc)StrokeAttribute___init__, /* tp_init */
+	0,                              /* tp_alloc */
+	PyType_GenericNew,              /* tp_new */
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef __cplusplus