diff options
Diffstat (limited to 'source/blender/freestyle/intern')
20 files changed, 2270 insertions, 2583 deletions
diff --git a/source/blender/freestyle/intern/python/BPy_Id.cpp b/source/blender/freestyle/intern/python/BPy_Id.cpp index 8f8336f6c17..54942abb58d 100644 --- a/source/blender/freestyle/intern/python/BPy_Id.cpp +++ b/source/blender/freestyle/intern/python/BPy_Id.cpp @@ -76,68 +76,6 @@ static PyObject * Id___repr__(BPy_Id* self) return PyUnicode_FromFormat("[ first: %i, second: %i ](BPy_Id)", self->id->getFirst(), self->id->getSecond() ); } -static char Id_getFirst___doc__[] = -".. method:: getFirst()\n" -"\n" -" Returns the first Id number.\n" -"\n" -" :return: The first Id number.\n" -" :rtype: int\n"; - -static PyObject *Id_getFirst( BPy_Id *self ) { - return PyLong_FromLong( self->id->getFirst() ); -} - -static char Id_getSecond___doc__[] = -".. method:: getSecond()\n" -"\n" -" Returns the second Id number.\n" -"\n" -" :return: The second Id number.\n" -" :rtype: int\n"; - -static PyObject *Id_getSecond( BPy_Id *self) { - return PyLong_FromLong( self->id->getSecond() ); -} - -static char Id_setFirst___doc__[] = -".. method:: setFirst(iFirst)\n" -"\n" -" Sets the first number constituting the Id.\n" -"\n" -" :arg iFirst: The first number constituting the Id.\n" -" :type iFirst: int\n"; - -static PyObject *Id_setFirst( BPy_Id *self , PyObject *args) { - unsigned int i; - - if( !PyArg_ParseTuple(args, "i", &i) ) - return NULL; - - self->id->setFirst( i ); - - Py_RETURN_NONE; -} - -static char Id_setSecond___doc__[] = -".. method:: setSecond(iSecond)\n" -"\n" -" Sets the second number constituting the Id.\n" -"\n" -" :arg iSecond: The second number constituting the Id.\n" -" :type iSecond: int\n"; - -static PyObject *Id_setSecond( BPy_Id *self , PyObject *args) { - unsigned int i; - - if( !PyArg_ParseTuple(args, "i", &i) ) - return NULL; - - self->id->setSecond( i ); - - Py_RETURN_NONE; -} - static PyObject * Id_RichCompare(BPy_Id *o1, BPy_Id *o2, int opid) { switch(opid){ case Py_LT: @@ -165,13 +103,61 @@ static PyObject * Id_RichCompare(BPy_Id *o1, BPy_Id *o2, int opid) { /*----------------------Id instance definitions ----------------------------*/ static PyMethodDef BPy_Id_methods[] = { - {"getFirst", ( PyCFunction ) Id_getFirst, METH_NOARGS, Id_getFirst___doc__}, - {"getSecond", ( PyCFunction ) Id_getSecond, METH_NOARGS, Id_getSecond___doc__}, - {"setFirst", ( PyCFunction ) Id_setFirst, METH_VARARGS, Id_setFirst___doc__}, - {"setSecond", ( PyCFunction ) Id_setSecond, METH_VARARGS, Id_setSecond___doc__}, {NULL, NULL, 0, NULL} }; +/*----------------------Id get/setters ----------------------------*/ + +PyDoc_STRVAR(Id_first_doc, +"The first number constituting the Id.\n" +"\n" +":type: int" +); + +static PyObject *Id_first_get(BPy_Id *self, void *UNUSED(closure)) +{ + return PyLong_FromLong(self->id->getFirst()); +} + +static int Id_first_set(BPy_Id *self, PyObject *value, void *UNUSED(closure)) +{ + int scalar; + if ((scalar = PyLong_AsLong(value)) == -1 && PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "value must be an integer"); + return -1; + } + self->id->setFirst(scalar); + return 0; +} + +PyDoc_STRVAR(Id_second_doc, +"The second number constituting the Id.\n" +"\n" +":type: int" +); + +static PyObject *Id_second_get(BPy_Id *self, void *UNUSED(closure)) +{ + return PyLong_FromLong(self->id->getSecond()); +} + +static int Id_second_set(BPy_Id *self, PyObject *value, void *UNUSED(closure)) +{ + int scalar; + if ((scalar = PyLong_AsLong(value)) == -1 && PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "value must be an integer"); + return -1; + } + self->id->setSecond(scalar); + return 0; +} + +static PyGetSetDef BPy_Id_getseters[] = { + {(char *)"first", (getter)Id_first_get, (setter)Id_first_set, (char *)Id_first_doc, NULL}, + {(char *)"second", (getter)Id_second_get, (setter)Id_second_set, (char *)Id_second_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ +}; + /*-----------------------BPy_Id type definition ------------------------------*/ PyTypeObject Id_Type = { @@ -204,7 +190,7 @@ PyTypeObject Id_Type = { 0, /* tp_iternext */ BPy_Id_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_Id_getseters, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ diff --git a/source/blender/freestyle/intern/python/BPy_Interface0D.cpp b/source/blender/freestyle/intern/python/BPy_Interface0D.cpp index be8b87cd1bc..3aedea2e034 100644 --- a/source/blender/freestyle/intern/python/BPy_Interface0D.cpp +++ b/source/blender/freestyle/intern/python/BPy_Interface0D.cpp @@ -17,284 +17,225 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// //-------------------MODULE INITIALIZATION-------------------------------- -int Interface0D_Init( PyObject *module ) +int Interface0D_Init(PyObject *module) { - if( module == NULL ) + if (module == NULL) return -1; - if( PyType_Ready( &Interface0D_Type ) < 0 ) + if (PyType_Ready(&Interface0D_Type) < 0) return -1; - Py_INCREF( &Interface0D_Type ); + Py_INCREF(&Interface0D_Type); PyModule_AddObject(module, "Interface0D", (PyObject *)&Interface0D_Type); - if( PyType_Ready( &CurvePoint_Type ) < 0 ) + if (PyType_Ready(&CurvePoint_Type) < 0) return -1; - Py_INCREF( &CurvePoint_Type ); + Py_INCREF(&CurvePoint_Type); PyModule_AddObject(module, "CurvePoint", (PyObject *)&CurvePoint_Type); - if( PyType_Ready( &SVertex_Type ) < 0 ) + if (PyType_Ready(&SVertex_Type) < 0) return -1; - Py_INCREF( &SVertex_Type ); + Py_INCREF(&SVertex_Type); PyModule_AddObject(module, "SVertex", (PyObject *)&SVertex_Type); - if( PyType_Ready( &ViewVertex_Type ) < 0 ) + if (PyType_Ready(&ViewVertex_Type) < 0) return -1; - Py_INCREF( &ViewVertex_Type ); + Py_INCREF(&ViewVertex_Type); PyModule_AddObject(module, "ViewVertex", (PyObject *)&ViewVertex_Type); - if( PyType_Ready( &StrokeVertex_Type ) < 0 ) + if (PyType_Ready(&StrokeVertex_Type) < 0) return -1; - Py_INCREF( &StrokeVertex_Type ); + Py_INCREF(&StrokeVertex_Type); PyModule_AddObject(module, "StrokeVertex", (PyObject *)&StrokeVertex_Type); - if( PyType_Ready( &NonTVertex_Type ) < 0 ) + if (PyType_Ready(&NonTVertex_Type) < 0) return -1; - Py_INCREF( &NonTVertex_Type ); + Py_INCREF(&NonTVertex_Type); PyModule_AddObject(module, "NonTVertex", (PyObject *)&NonTVertex_Type); - if( PyType_Ready( &TVertex_Type ) < 0 ) + if (PyType_Ready(&TVertex_Type) < 0) return -1; - Py_INCREF( &TVertex_Type ); + Py_INCREF(&TVertex_Type); PyModule_AddObject(module, "TVertex", (PyObject *)&TVertex_Type); + SVertex_mathutils_register_callback(); StrokeVertex_mathutils_register_callback(); return 0; } -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------Interface1D methods ----------------------------*/ -static char Interface0D___doc__[] = +PyDoc_STRVAR(Interface0D_doc, "Base class for any 0D element.\n" "\n" ".. method:: __init__()\n" "\n" -" Default constructor.\n"; +" Default constructor."); -static int Interface0D___init__(BPy_Interface0D *self, PyObject *args, PyObject *kwds) +static int Interface0D_init(BPy_Interface0D *self, PyObject *args, PyObject *kwds) { - if ( !PyArg_ParseTuple(args, "") ) - return -1; + if (!PyArg_ParseTuple(args, "")) + return -1; self->if0D = new Interface0D(); self->borrowed = 0; return 0; } -static void Interface0D___dealloc__(BPy_Interface0D* self) +static void Interface0D_dealloc(BPy_Interface0D* self) { - if( self->if0D && !self->borrowed ) + if (self->if0D && !self->borrowed) delete self->if0D; - Py_TYPE(self)->tp_free((PyObject*)self); + Py_TYPE(self)->tp_free((PyObject*)self); } -static PyObject * Interface0D___repr__(BPy_Interface0D* self) +static PyObject * Interface0D_repr(BPy_Interface0D* self) { - return PyUnicode_FromFormat("type: %s - address: %p", self->if0D->getExactTypeName().c_str(), self->if0D ); + return PyUnicode_FromFormat("type: %s - address: %p", self->if0D->getExactTypeName().c_str(), self->if0D); } -static char Interface0D_getExactTypeName___doc__[] = -".. method:: getExactTypeName()\n" +PyDoc_STRVAR(Interface0D_get_fedge_doc, +".. method:: get_fedge(inter)\n" "\n" -" Returns the name of the 0D element.\n" +" Returns the FEdge that lies between this 0D element and the 0D\n" +" element given as the argument.\n" "\n" -" :return: Name of the interface.\n" -" :rtype: str\n"; - -static PyObject *Interface0D_getExactTypeName( BPy_Interface0D *self ) { - return PyUnicode_FromString( self->if0D->getExactTypeName().c_str() ); -} +" :arg inter: A 0D element.\n" +" :type inter: :class:`Interface0D`\n" +" :return: The FEdge lying between the two 0D elements.\n" +" :rtype: :class:`FEdge`"); -static char Interface0D_getX___doc__[] = -".. method:: getX()\n" -"\n" -" Returns the X coordinate of the 3D point of the 0D element.\n" -"\n" -" :return: The X coordinate of the 3D point.\n" -" :rtype: float\n"; +static PyObject *Interface0D_get_fedge(BPy_Interface0D *self, PyObject *args) +{ + PyObject *py_if0D; -static PyObject *Interface0D_getX( BPy_Interface0D *self ) { - double x = self->if0D->getX(); - if (PyErr_Occurred()) + if (!PyArg_ParseTuple(args, "O!", &Interface0D_Type, &py_if0D)) return NULL; - return PyFloat_FromDouble( x ); -} - -static char Interface0D_getY___doc__[] = -".. method:: getY()\n" -"\n" -" Returns the Y coordinate of the 3D point of the 0D element.\n" -"\n" -" :return: The Y coordinate of the 3D point.\n" -" :rtype: float\n"; - -static PyObject *Interface0D_getY( BPy_Interface0D *self ) { - double y = self->if0D->getY(); + FEdge *fe = self->if0D->getFEdge(*(((BPy_Interface0D *)py_if0D)->if0D)); if (PyErr_Occurred()) return NULL; - return PyFloat_FromDouble( y ); + if (fe) + return Any_BPy_FEdge_from_FEdge(*fe); + Py_RETURN_NONE; } -static char Interface0D_getZ___doc__[] = -".. method:: getZ()\n" -"\n" -" Returns the Z coordinate of the 3D point of the 0D element.\n" -"\n" -" :return: The Z coordinate of the 3D point.\n" -" :rtype: float\n"; +static PyMethodDef BPy_Interface0D_methods[] = { + {"get_fedge", (PyCFunction)Interface0D_get_fedge, METH_VARARGS, Interface0D_get_fedge_doc}, + {NULL, NULL, 0, NULL} +}; -static PyObject *Interface0D_getZ( BPy_Interface0D *self ) { - double z = self->if0D->getZ(); - if (PyErr_Occurred()) - return NULL; - return PyFloat_FromDouble( z ); -} +/*----------------------Interface1D get/setters ----------------------------*/ -static char Interface0D_getPoint3D___doc__[] = -".. method:: getPoint3D()\n" +PyDoc_STRVAR(Interface0D_exact_type_name_doc, +"The string of the the name of this 0D element.\n" "\n" -" Returns the location of the 0D element in the 3D space.\n" -"\n" -" :return: The 3D point of the 0D element.\n" -" :rtype: :class:`mathutils.Vector`\n"; +":type: str"); -static PyObject *Interface0D_getPoint3D( BPy_Interface0D *self ) { - Vec3f v( self->if0D->getPoint3D() ); - if (PyErr_Occurred()) - return NULL; - return Vector_from_Vec3f( v ); +static PyObject *Interface0D_exact_type_name_get(BPy_Interface0D *self, void *UNUSED(closure)) +{ + return PyUnicode_FromString(self->if0D->getExactTypeName().c_str()); } -static char Interface0D_getProjectedX___doc__[] = -".. method:: getProjectedX()\n" -"\n" -" Returns the X coordinate of the 2D point of the 0D element.\n" +PyDoc_STRVAR(Interface0D_point_3d_doc, +"The 3D point of this 0D element.\n" "\n" -" :return: The X coordinate of the 2D point.\n" -" :rtype: float\n"; +":type: mathutils.Vector"); -static PyObject *Interface0D_getProjectedX( BPy_Interface0D *self ) { - double x = self->if0D->getProjectedX(); +static PyObject *Interface0D_point_3d_get(BPy_Interface0D *self, void *UNUSED(closure)) +{ + Vec3f p(self->if0D->getPoint3D()); if (PyErr_Occurred()) return NULL; - return PyFloat_FromDouble( x ); + return Vector_from_Vec3f(p); } -static char Interface0D_getProjectedY___doc__[] = -".. method:: getProjectedY()\n" -"\n" -" Returns the Y coordinate of the 2D point of the 0D element.\n" +PyDoc_STRVAR(Interface0D_projected_x_doc, +"The X coordinate of the projected 3D point of this 0D element.\n" "\n" -" :return: The Y coordinate of the 2D point.\n" -" :rtype: float\n"; +":type: float"); -static PyObject *Interface0D_getProjectedY( BPy_Interface0D *self ) { - double y = self->if0D->getProjectedY(); +static PyObject *Interface0D_projected_x_get(BPy_Interface0D *self, void *UNUSED(closure)) +{ + real x = self->if0D->getProjectedX(); if (PyErr_Occurred()) return NULL; - return PyFloat_FromDouble( y ); + return PyFloat_FromDouble(x); } -static char Interface0D_getProjectedZ___doc__[] = -".. method:: getProjectedZ()\n" -"\n" -" Returns the Z coordinate of the 2D point of the 0D element.\n" +PyDoc_STRVAR(Interface0D_projected_y_doc, +"The Y coordinate of the projected 3D point of this 0D element.\n" "\n" -" :return: The Z coordinate of the 2D point.\n" -" :rtype: float\n"; +":type: float"); -static PyObject *Interface0D_getProjectedZ( BPy_Interface0D *self ) { - double z = self->if0D->getProjectedZ(); +static PyObject *Interface0D_projected_y_get(BPy_Interface0D *self, void *UNUSED(closure)) +{ + real y = self->if0D->getProjectedY(); if (PyErr_Occurred()) return NULL; - return PyFloat_FromDouble( z ); + return PyFloat_FromDouble(y); } -static char Interface0D_getPoint2D___doc__[] = -".. method:: getPoint2D()\n" -"\n" -" Returns the location of the 0D element in the 2D space.\n" +PyDoc_STRVAR(Interface0D_projected_z_doc, +"The Z coordinate of the projected 3D point of this 0D element.\n" "\n" -" :return: The 2D point of the 0D element.\n" -" :rtype: :class:`mathutils.Vector`\n"; +":type: float"); -static PyObject *Interface0D_getPoint2D( BPy_Interface0D *self ) { - Vec2f v( self->if0D->getPoint2D() ); +static PyObject *Interface0D_projected_z_get(BPy_Interface0D *self, void *UNUSED(closure)) +{ + real z = self->if0D->getProjectedZ(); if (PyErr_Occurred()) return NULL; - return Vector_from_Vec2f( v ); + return PyFloat_FromDouble(z); } -static char Interface0D_getFEdge___doc__[] = -".. method:: getFEdge(inter)\n" -"\n" -" Returns the FEdge that lies between this 0D element and the 0D\n" -" element given as the argument.\n" +PyDoc_STRVAR(Interface0D_point_2d_doc, +"The 2D point of this 0D element.\n" "\n" -" :arg inter: A 0D element.\n" -" :type inter: :class:`Interface0D`\n" -" :return: The FEdge lying between the two 0D elements.\n" -" :rtype: :class:`FEdge`\n"; +":type: mathutils.Vector"); -static PyObject *Interface0D_getFEdge( BPy_Interface0D *self, PyObject *args ) { - PyObject *py_if0D; - - if(!( PyArg_ParseTuple(args, "O!", &Interface0D_Type, &py_if0D) )) - return NULL; - - FEdge *fe = self->if0D->getFEdge(*( ((BPy_Interface0D *) py_if0D)->if0D )); +static PyObject *Interface0D_point_2d_get(BPy_Interface0D *self, void *UNUSED(closure)) +{ + Vec2f p(self->if0D->getPoint2D()); if (PyErr_Occurred()) return NULL; - if( fe ) - return Any_BPy_FEdge_from_FEdge( *fe ); - - Py_RETURN_NONE; + return Vector_from_Vec2f(p); } -static char Interface0D_getId___doc__[] = -".. method:: getId()\n" +PyDoc_STRVAR(Interface0D_id_doc, +"The Id of this 0D element.\n" "\n" -" Returns the identifier of the 0D element.\n" -"\n" -" :return: The identifier of the 0D element.\n" -" :rtype: :class:`Id`\n"; +":type: :class:`Id`"); -static PyObject *Interface0D_getId( BPy_Interface0D *self ) { - Id id( self->if0D->getId() ); +static PyObject *Interface0D_id_get(BPy_Interface0D *self, void *UNUSED(closure)) +{ + Id id(self->if0D->getId()); if (PyErr_Occurred()) return NULL; - return BPy_Id_from_Id( id ); + return BPy_Id_from_Id(id); // return a copy } -static char Interface0D_getNature___doc__[] = -".. method:: getNature()\n" +PyDoc_STRVAR(Interface0D_nature_doc, +"The nature of this 0D element.\n" "\n" -" Returns the nature of the 0D element.\n" -"\n" -" :return: The nature of the 0D element.\n" -" :rtype: :class:`Nature`\n"; +":type: :class:`Nature`"); -static PyObject *Interface0D_getNature( BPy_Interface0D *self ) { +static PyObject *Interface0D_nature_get(BPy_Interface0D *self, void *UNUSED(closure)) +{ Nature::VertexNature nature = self->if0D->getNature(); if (PyErr_Occurred()) return NULL; - return BPy_Nature_from_Nature( nature ); + return BPy_Nature_from_Nature(nature); } -/*----------------------Interface0D instance definitions ----------------------------*/ -static PyMethodDef BPy_Interface0D_methods[] = { - {"getExactTypeName", ( PyCFunction ) Interface0D_getExactTypeName, METH_NOARGS, Interface0D_getExactTypeName___doc__}, - {"getX", ( PyCFunction ) Interface0D_getX, METH_NOARGS, Interface0D_getX___doc__}, - {"getY", ( PyCFunction ) Interface0D_getY, METH_NOARGS, Interface0D_getY___doc__}, - {"getZ", ( PyCFunction ) Interface0D_getZ, METH_NOARGS, Interface0D_getZ___doc__}, - {"getPoint3D", ( PyCFunction ) Interface0D_getPoint3D, METH_NOARGS, Interface0D_getPoint3D___doc__}, - {"getProjectedX", ( PyCFunction ) Interface0D_getProjectedX, METH_NOARGS, Interface0D_getProjectedX___doc__}, - {"getProjectedY", ( PyCFunction ) Interface0D_getProjectedY, METH_NOARGS, Interface0D_getProjectedY___doc__}, - {"getProjectedZ", ( PyCFunction ) Interface0D_getProjectedZ, METH_NOARGS, Interface0D_getProjectedZ___doc__}, - {"getPoint2D", ( PyCFunction ) Interface0D_getPoint2D, METH_NOARGS, Interface0D_getPoint2D___doc__}, - {"getFEdge", ( PyCFunction ) Interface0D_getFEdge, METH_VARARGS, Interface0D_getFEdge___doc__}, - {"getId", ( PyCFunction ) Interface0D_getId, METH_NOARGS, Interface0D_getId___doc__}, - {"getNature", ( PyCFunction ) Interface0D_getNature, METH_NOARGS, Interface0D_getNature___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_Interface0D_getseters[] = { + {(char *)"exact_type_name", (getter)Interface0D_exact_type_name_get, (setter)NULL, (char *)Interface0D_exact_type_name_doc, NULL}, + {(char *)"point_3d", (getter)Interface0D_point_3d_get, (setter)NULL, (char *)Interface0D_point_3d_doc, NULL}, + {(char *)"projected_x", (getter)Interface0D_projected_x_get, (setter)NULL, (char *)Interface0D_projected_x_doc, NULL}, + {(char *)"projected_y", (getter)Interface0D_projected_y_get, (setter)NULL, (char *)Interface0D_projected_y_doc, NULL}, + {(char *)"projected_z", (getter)Interface0D_projected_z_get, (setter)NULL, (char *)Interface0D_projected_z_doc, NULL}, + {(char *)"point_2d", (getter)Interface0D_point_2d_get, (setter)NULL, (char *)Interface0D_point_2d_doc, NULL}, + {(char *)"id", (getter)Interface0D_id_get, (setter)NULL, (char *)Interface0D_id_doc, NULL}, + {(char *)"nature", (getter)Interface0D_nature_get, (setter)NULL, (char *)Interface0D_nature_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_Interface0D type definition ------------------------------*/ @@ -304,12 +245,12 @@ PyTypeObject Interface0D_Type = { "Interface0D", /* tp_name */ sizeof(BPy_Interface0D), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)Interface0D___dealloc__, /* tp_dealloc */ + (destructor)Interface0D_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_reserved */ - (reprfunc)Interface0D___repr__, /* tp_repr */ + (reprfunc)Interface0D_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ @@ -320,7 +261,7 @@ PyTypeObject Interface0D_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - Interface0D___doc__, /* tp_doc */ + Interface0D_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -329,23 +270,15 @@ PyTypeObject Interface0D_Type = { 0, /* tp_iternext */ BPy_Interface0D_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_Interface0D_getseters, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)Interface0D___init__, /* tp_init */ + (initproc)Interface0D_init, /* tp_init */ 0, /* tp_alloc */ PyType_GenericNew, /* tp_new */ - 0, /* tp_free */ - 0, /* tp_is_gc */ - 0, /* tp_bases */ - 0, /* tp_mro */ - 0, /* tp_cache */ - 0, /* tp_subclasses */ - 0, /* tp_weaklist */ - 0 /* tp_del */ }; /////////////////////////////////////////////////////////////////////////////////////////// @@ -353,4 +286,3 @@ PyTypeObject Interface0D_Type = { #ifdef __cplusplus } #endif - diff --git a/source/blender/freestyle/intern/python/BPy_Interface1D.cpp b/source/blender/freestyle/intern/python/BPy_Interface1D.cpp index 7b4bdddf70c..f6046b4cad3 100644 --- a/source/blender/freestyle/intern/python/BPy_Interface1D.cpp +++ b/source/blender/freestyle/intern/python/BPy_Interface1D.cpp @@ -18,211 +18,126 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// //-------------------MODULE INITIALIZATION-------------------------------- -int Interface1D_Init( PyObject *module ) +int Interface1D_Init(PyObject *module) { - if( module == NULL ) + if (module == NULL) return -1; - if( PyType_Ready( &Interface1D_Type ) < 0 ) + if (PyType_Ready(&Interface1D_Type) < 0) return -1; - Py_INCREF( &Interface1D_Type ); + Py_INCREF(&Interface1D_Type); PyModule_AddObject(module, "Interface1D", (PyObject *)&Interface1D_Type); - - if( PyType_Ready( &FrsCurve_Type ) < 0 ) + + if (PyType_Ready(&FrsCurve_Type) < 0) return -1; - Py_INCREF( &FrsCurve_Type ); + Py_INCREF(&FrsCurve_Type); PyModule_AddObject(module, "Curve", (PyObject *)&FrsCurve_Type); - if( PyType_Ready( &Chain_Type ) < 0 ) + if (PyType_Ready(&Chain_Type) < 0) return -1; - Py_INCREF( &Chain_Type ); + Py_INCREF(&Chain_Type); PyModule_AddObject(module, "Chain", (PyObject *)&Chain_Type); - - if( PyType_Ready( &FEdge_Type ) < 0 ) + + if (PyType_Ready(&FEdge_Type) < 0) return -1; - Py_INCREF( &FEdge_Type ); + Py_INCREF(&FEdge_Type); PyModule_AddObject(module, "FEdge", (PyObject *)&FEdge_Type); - if( PyType_Ready( &FEdgeSharp_Type ) < 0 ) + if (PyType_Ready(&FEdgeSharp_Type) < 0) return -1; - Py_INCREF( &FEdgeSharp_Type ); + Py_INCREF(&FEdgeSharp_Type); PyModule_AddObject(module, "FEdgeSharp", (PyObject *)&FEdgeSharp_Type); - - if( PyType_Ready( &FEdgeSmooth_Type ) < 0 ) + + if (PyType_Ready(&FEdgeSmooth_Type) < 0) return -1; - Py_INCREF( &FEdgeSmooth_Type ); + Py_INCREF(&FEdgeSmooth_Type); PyModule_AddObject(module, "FEdgeSmooth", (PyObject *)&FEdgeSmooth_Type); - if( PyType_Ready( &Stroke_Type ) < 0 ) + if (PyType_Ready(&Stroke_Type) < 0) return -1; - Py_INCREF( &Stroke_Type ); + Py_INCREF(&Stroke_Type); PyModule_AddObject(module, "Stroke", (PyObject *)&Stroke_Type); - PyDict_SetItemString( Stroke_Type.tp_dict, "DRY_MEDIUM", BPy_MediumType_DRY_MEDIUM ); - PyDict_SetItemString( Stroke_Type.tp_dict, "HUMID_MEDIUM", BPy_MediumType_HUMID_MEDIUM ); - PyDict_SetItemString( Stroke_Type.tp_dict, "OPAQUE_MEDIUM", BPy_MediumType_OPAQUE_MEDIUM ); + PyDict_SetItemString(Stroke_Type.tp_dict, "DRY_MEDIUM", BPy_MediumType_DRY_MEDIUM); + PyDict_SetItemString(Stroke_Type.tp_dict, "HUMID_MEDIUM", BPy_MediumType_HUMID_MEDIUM); + PyDict_SetItemString(Stroke_Type.tp_dict, "OPAQUE_MEDIUM", BPy_MediumType_OPAQUE_MEDIUM); - if( PyType_Ready( &ViewEdge_Type ) < 0 ) + if (PyType_Ready(&ViewEdge_Type) < 0) return -1; - Py_INCREF( &ViewEdge_Type ); + Py_INCREF(&ViewEdge_Type); PyModule_AddObject(module, "ViewEdge", (PyObject *)&ViewEdge_Type); + FEdgeSharp_mathutils_register_callback(); + FEdgeSmooth_mathutils_register_callback(); + return 0; } -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------Interface1D methods ----------------------------*/ -static char Interface1D___doc__[] = +PyDoc_STRVAR(Interface1D_doc, "Base class for any 1D element.\n" "\n" ".. method:: __init__()\n" "\n" -" Default constructor.\n"; +" Default constructor."); -static int Interface1D___init__(BPy_Interface1D *self, PyObject *args, PyObject *kwds) +static int Interface1D_init(BPy_Interface1D *self, PyObject *args, PyObject *kwds) { - if ( !PyArg_ParseTuple(args, "") ) - return -1; + if (!PyArg_ParseTuple(args, "")) + return -1; self->if1D = new Interface1D(); self->borrowed = 0; return 0; } -static void Interface1D___dealloc__(BPy_Interface1D* self) +static void Interface1D_dealloc(BPy_Interface1D* self) { - if( self->if1D && !self->borrowed ) + if (self->if1D && !self->borrowed) delete self->if1D; - Py_TYPE(self)->tp_free((PyObject*)self); + Py_TYPE(self)->tp_free((PyObject*)self); } -static PyObject * Interface1D___repr__(BPy_Interface1D* self) +static PyObject * Interface1D_repr(BPy_Interface1D* self) { - return PyUnicode_FromFormat("type: %s - address: %p", self->if1D->getExactTypeName().c_str(), self->if1D ); -} - -static char Interface1D_getExactTypeName___doc__[] = -".. method:: getExactTypeName()\n" -"\n" -" Returns the string of the name of the 1D element.\n" -"\n" -" :return: The name of the 1D element.\n" -" :rtype: str\n"; - -static PyObject *Interface1D_getExactTypeName( BPy_Interface1D *self ) { - return PyUnicode_FromString( self->if1D->getExactTypeName().c_str() ); -} - -#if 0 -static PyObject *Interface1D_getVertices( BPy_Interface1D *self ) { - return PyList_New(0); -} - -static PyObject *Interface1D_getPoints( BPy_Interface1D *self ) { - return PyList_New(0); -} -#endif - -static char Interface1D_getLength2D___doc__[] = -".. method:: getLength2D()\n" -"\n" -" Returns the 2D length of the 1D element.\n" -"\n" -" :return: The 2D length of the 1D element.\n" -" :rtype: float\n"; - -static PyObject *Interface1D_getLength2D( BPy_Interface1D *self ) { - return PyFloat_FromDouble( (double) self->if1D->getLength2D() ); -} - -static char Interface1D_getId___doc__[] = -".. method:: getId()\n" -"\n" -" Returns the Id of the 1D element .\n" -"\n" -" :return: The Id of the 1D element .\n" -" :rtype: :class:`Id`\n"; - -static PyObject *Interface1D_getId( BPy_Interface1D *self ) { - Id id( self->if1D->getId() ); - return BPy_Id_from_Id( id ); -} - -static char Interface1D_getNature___doc__[] = -".. method:: getNature()\n" -"\n" -" Returns the nature of the 1D element.\n" -"\n" -" :return: The nature of the 1D element.\n" -" :rtype: :class:`Nature`\n"; - -static PyObject *Interface1D_getNature( BPy_Interface1D *self ) { - return BPy_Nature_from_Nature( self->if1D->getNature() ); -} - -static char Interface1D_getTimeStamp___doc__[] = -".. method:: getTimeStamp()\n" -"\n" -" Returns the time stamp of the 1D element. Mainly used for selection.\n" -"\n" -" :return: The time stamp of the 1D element.\n" -" :rtype: int\n"; - -static PyObject *Interface1D_getTimeStamp( BPy_Interface1D *self ) { - return PyLong_FromLong( self->if1D->getTimeStamp() ); + return PyUnicode_FromFormat("type: %s - address: %p", self->if1D->getExactTypeName().c_str(), self->if1D); } -static char Interface1D_setTimeStamp___doc__[] = -".. method:: setTimeStamp(iTimeStamp)\n" -"\n" -" Sets the time stamp for the 1D element.\n" -"\n" -" :arg iTimeStamp: A time stamp.\n" -" :type iTimeStamp: int\n"; - -static PyObject *Interface1D_setTimeStamp( BPy_Interface1D *self, PyObject *args) { - int timestamp = 0 ; - - if( !PyArg_ParseTuple(args, "i", ×tamp) ) - return NULL; - - self->if1D->setTimeStamp( timestamp ); - - Py_RETURN_NONE; -} - -static char Interface1D_verticesBegin___doc__[] = -".. method:: verticesBegin()\n" +PyDoc_STRVAR(Interface1D_vertices_begin_doc, +".. method:: vertices_begin()\n" "\n" " Returns an iterator over the Interface1D vertices, pointing to the\n" " first vertex.\n" "\n" " :return: An Interface0DIterator pointing to the first vertex.\n" -" :rtype: :class:`Interface0DIterator`\n"; +" :rtype: :class:`Interface0DIterator`"); -static PyObject * Interface1D_verticesBegin( BPy_Interface1D *self ) { - Interface0DIterator if0D_it( self->if1D->verticesBegin() ); - return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it, 0 ); +static PyObject * Interface1D_vertices_begin(BPy_Interface1D *self) +{ + Interface0DIterator if0D_it(self->if1D->verticesBegin()); + return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 0); } -static char Interface1D_verticesEnd___doc__[] = -".. method:: verticesEnd()\n" +PyDoc_STRVAR(Interface1D_vertices_end_doc, +".. method:: vertices_end()\n" "\n" " Returns an iterator over the Interface1D vertices, pointing after\n" " the last vertex.\n" "\n" " :return: An Interface0DIterator pointing after the last vertex.\n" -" :rtype: :class:`Interface0DIterator`\n"; +" :rtype: :class:`Interface0DIterator`"); -static PyObject * Interface1D_verticesEnd( BPy_Interface1D *self ) { - Interface0DIterator if0D_it( self->if1D->verticesEnd() ); - return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it, 1 ); +static PyObject * Interface1D_vertices_end(BPy_Interface1D *self) +{ + Interface0DIterator if0D_it(self->if1D->verticesEnd()); + return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 1); } -static char Interface1D_pointsBegin___doc__[] = -".. method:: pointsBegin(t=0.0)\n" +PyDoc_STRVAR(Interface1D_points_begin_doc, +".. method:: points_begin(t=0.0)\n" "\n" " Returns an iterator over the Interface1D points, pointing to the\n" -" first point. The difference with verticesBegin() is that here we can\n" +" first point. The difference with vertices_begin() is that here we can\n" " iterate over points of the 1D element at a any given sampling.\n" " Indeed, for each iteration, a virtual point is created.\n" "\n" @@ -230,23 +145,23 @@ static char Interface1D_pointsBegin___doc__[] = " this 1D element.\n" " :type t: float\n" " :return: An Interface0DIterator pointing to the first point.\n" -" :rtype: :class:`Interface0DIterator`\n"; +" :rtype: :class:`Interface0DIterator`"); -static PyObject * Interface1D_pointsBegin( BPy_Interface1D *self, PyObject *args ) { +static PyObject * Interface1D_points_begin(BPy_Interface1D *self, PyObject *args) +{ float f = 0; - if(!( PyArg_ParseTuple(args, "|f", &f) )) + if(!(PyArg_ParseTuple(args, "|f", &f))) return NULL; - - Interface0DIterator if0D_it( self->if1D->pointsBegin(f) ); - return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it, 0 ); + Interface0DIterator if0D_it(self->if1D->pointsBegin(f)); + return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 0); } -static char Interface1D_pointsEnd___doc__[] = -".. method:: pointsEnd(t=0.0)\n" +PyDoc_STRVAR(Interface1D_points_end_doc, +".. method:: points_end(t=0.0)\n" "\n" " Returns an iterator over the Interface1D points, pointing after the\n" -" last point. The difference with verticesEnd() is that here we can\n" +" last point. The difference with vertices_end() is that here we can\n" " iterate over points of the 1D element at a given sampling. Indeed,\n" " for each iteration, a virtual point is created.\n" "\n" @@ -254,37 +169,108 @@ static char Interface1D_pointsEnd___doc__[] = " this 1D element.\n" " :type t: float\n" " :return: An Interface0DIterator pointing after the last point.\n" -" :rtype: :class:`Interface0DIterator`\n"; +" :rtype: :class:`Interface0DIterator`"); -static PyObject * Interface1D_pointsEnd( BPy_Interface1D *self, PyObject *args ) { +static PyObject * Interface1D_points_end(BPy_Interface1D *self, PyObject *args) +{ float f = 0; - if(!( PyArg_ParseTuple(args, "|f", &f) )) + if (!PyArg_ParseTuple(args, "|f", &f)) return NULL; - - Interface0DIterator if0D_it( self->if1D->pointsEnd(f) ); - return BPy_Interface0DIterator_from_Interface0DIterator( if0D_it, 1 ); + Interface0DIterator if0D_it(self->if1D->pointsEnd(f)); + return BPy_Interface0DIterator_from_Interface0DIterator(if0D_it, 1); } -/*----------------------Interface1D instance definitions ----------------------------*/ static PyMethodDef BPy_Interface1D_methods[] = { - {"getExactTypeName", ( PyCFunction ) Interface1D_getExactTypeName, METH_NOARGS, Interface1D_getExactTypeName___doc__}, -#if 0 - {"getVertices", ( PyCFunction ) Interface1D_getVertices, METH_NOARGS, "Returns the vertices"}, - {"getPoints", ( PyCFunction ) Interface1D_getPoints, METH_NOARGS, "Returns the points. The difference with getVertices() is that here we can iterate over points of the 1D element at any given sampling. At each call, a virtual point is created."}, -#endif - {"getLength2D", ( PyCFunction ) Interface1D_getLength2D, METH_NOARGS, Interface1D_getLength2D___doc__}, - {"getId", ( PyCFunction ) Interface1D_getId, METH_NOARGS, Interface1D_getId___doc__}, - {"getNature", ( PyCFunction ) Interface1D_getNature, METH_NOARGS, Interface1D_getNature___doc__}, - {"getTimeStamp", ( PyCFunction ) Interface1D_getTimeStamp, METH_NOARGS, Interface1D_getTimeStamp___doc__}, - {"setTimeStamp", ( PyCFunction ) Interface1D_setTimeStamp, METH_VARARGS, Interface1D_setTimeStamp___doc__}, - {"verticesBegin", ( PyCFunction ) Interface1D_verticesBegin, METH_NOARGS, Interface1D_verticesBegin___doc__}, - {"verticesEnd", ( PyCFunction ) Interface1D_verticesEnd, METH_NOARGS, Interface1D_verticesEnd___doc__}, - {"pointsBegin", ( PyCFunction ) Interface1D_pointsBegin, METH_VARARGS, Interface1D_pointsBegin___doc__}, - {"pointsEnd", ( PyCFunction ) Interface1D_pointsEnd, METH_VARARGS, Interface1D_pointsEnd___doc__}, + {"vertices_begin", (PyCFunction)Interface1D_vertices_begin, METH_NOARGS, Interface1D_vertices_begin_doc}, + {"vertices_end", (PyCFunction)Interface1D_vertices_end, METH_NOARGS, Interface1D_vertices_end_doc}, + {"points_begin", (PyCFunction)Interface1D_points_begin, METH_VARARGS, Interface1D_points_begin_doc}, + {"points_end", (PyCFunction)Interface1D_points_end, METH_VARARGS, Interface1D_points_end_doc}, {NULL, NULL, 0, NULL} }; +/*----------------------Interface1D get/setters ----------------------------*/ + +PyDoc_STRVAR(Interface1D_exact_type_name_doc, +"The string of the name of the 1D element.\n" +"\n" +":type: str"); + +static PyObject *Interface1D_exact_type_name_get(BPy_Interface1D *self, void *UNUSED(closure)) +{ + return PyUnicode_FromString(self->if1D->getExactTypeName().c_str()); +} + +PyDoc_STRVAR(Interface1D_id_doc, +"The Id of this Interface1D.\n" +"\n" +":type: :class:`Id`"); + +static PyObject *Interface1D_id_get(BPy_Interface1D *self, void *UNUSED(closure)) +{ + Id id(self->if1D->getId()); + if (PyErr_Occurred()) + return NULL; + return BPy_Id_from_Id(id); // return a copy +} + +PyDoc_STRVAR(Interface1D_nature_doc, +"The nature of this Interface1D.\n" +"\n" +":type: :class:`Nature`"); + +static PyObject *Interface1D_nature_get(BPy_Interface1D *self, void *UNUSED(closure)) +{ + Nature::VertexNature nature = self->if1D->getNature(); + if (PyErr_Occurred()) + return NULL; + return BPy_Nature_from_Nature(nature); +} + +PyDoc_STRVAR(Interface1D_length_2d_doc, +"The 2D length of this Interface1D.\n" +"\n" +":type: float"); + +static PyObject *Interface1D_length_2d_get(BPy_Interface1D *self, void *UNUSED(closure)) +{ + real length = self->if1D->getLength2D(); + if (PyErr_Occurred()) + return NULL; + return PyFloat_FromDouble((double)length); +} + +PyDoc_STRVAR(Interface1D_time_stamp_doc, +"The time stamp of the 1D element, mainly used for selection.\n" +"\n" +":type: int"); + +static PyObject *Interface1D_time_stamp_get(BPy_Interface1D *self, void *UNUSED(closure)) +{ + return PyLong_FromLong(self->if1D->getTimeStamp()); +} + +static int Interface1D_time_stamp_set(BPy_Interface1D *self, PyObject *value, void *UNUSED(closure)) +{ + int timestamp; + + if ((timestamp = PyLong_AsLong(value)) == -1 && PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "value must be a number"); + return -1; + } + self->if1D->setTimeStamp(timestamp); + return 0; +} + +static PyGetSetDef BPy_Interface1D_getseters[] = { + {(char *)"exact_type_name", (getter)Interface1D_exact_type_name_get, (setter)NULL, (char *)Interface1D_exact_type_name_doc, NULL}, + {(char *)"id", (getter)Interface1D_id_get, (setter)NULL, (char *)Interface1D_id_doc, NULL}, + {(char *)"nature", (getter)Interface1D_nature_get, (setter)NULL, (char *)Interface1D_nature_doc, NULL}, + {(char *)"length_2d", (getter)Interface1D_length_2d_get, (setter)NULL, (char *)Interface1D_length_2d_doc, NULL}, + {(char *)"time_stamp", (getter)Interface1D_time_stamp_get, (setter)Interface1D_time_stamp_set, (char *)Interface1D_time_stamp_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ +}; + /*-----------------------BPy_Interface1D type definition ------------------------------*/ PyTypeObject Interface1D_Type = { @@ -292,12 +278,12 @@ PyTypeObject Interface1D_Type = { "Interface1D", /* tp_name */ sizeof(BPy_Interface1D), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)Interface1D___dealloc__, /* tp_dealloc */ + (destructor)Interface1D_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_reserved */ - (reprfunc)Interface1D___repr__, /* tp_repr */ + (reprfunc)Interface1D_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ @@ -308,7 +294,7 @@ PyTypeObject Interface1D_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - Interface1D___doc__, /* tp_doc */ + Interface1D_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -317,13 +303,13 @@ PyTypeObject Interface1D_Type = { 0, /* tp_iternext */ BPy_Interface1D_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_Interface1D_getseters, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)Interface1D___init__, /* tp_init */ + (initproc)Interface1D_init, /* tp_init */ 0, /* tp_alloc */ PyType_GenericNew, /* tp_new */ }; @@ -333,5 +319,3 @@ PyTypeObject Interface1D_Type = { #ifdef __cplusplus } #endif - - diff --git a/source/blender/freestyle/intern/python/BPy_SShape.cpp b/source/blender/freestyle/intern/python/BPy_SShape.cpp index 65951182f10..763e88e2ce1 100644 --- a/source/blender/freestyle/intern/python/BPy_SShape.cpp +++ b/source/blender/freestyle/intern/python/BPy_SShape.cpp @@ -13,22 +13,22 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// //-------------------MODULE INITIALIZATION-------------------------------- -int SShape_Init( PyObject *module ) +int SShape_Init(PyObject *module) { - if( module == NULL ) + if (module == NULL) return -1; - if( PyType_Ready( &SShape_Type ) < 0 ) + if (PyType_Ready(&SShape_Type) < 0) return -1; - Py_INCREF( &SShape_Type ); PyModule_AddObject(module, "SShape", (PyObject *)&SShape_Type); + return 0; } -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------SShape methods ----------------------------*/ -static char SShape___doc__[] = +PyDoc_STRVAR(SShape_doc, "Class to define a feature shape. It is the gathering of feature\n" "elements from an identified input shape.\n" "\n" @@ -41,243 +41,206 @@ static char SShape___doc__[] = " Copy constructor.\n" "\n" " :arg iBrother: An SShape object.\n" -" :type iBrother: :class:`SShape`\n"; +" :type iBrother: :class:`SShape`"); -static int SShape___init__(BPy_SShape *self, PyObject *args, PyObject *kwds) +static int SShape_init(BPy_SShape *self, PyObject *args, PyObject *kwds) { PyObject *obj = NULL; - if (! PyArg_ParseTuple(args, "|O!", &SShape_Type, &obj) ) - return -1; + if (!PyArg_ParseTuple(args, "|O!", &SShape_Type, &obj)) + return -1; - if( !obj ) { + if (!obj) { self->ss = new SShape(); - } else { - self->ss = new SShape(*( ((BPy_SShape *) obj)->ss )); + self->ss = new SShape(*(((BPy_SShape *)obj)->ss)); } self->borrowed = 0; - return 0; + return 0; } -static void SShape___dealloc__(BPy_SShape *self) +static void SShape_dealloc(BPy_SShape *self) { - if( self->ss && !self->borrowed ) + if (self->ss && !self->borrowed) delete self->ss; - Py_TYPE(self)->tp_free((PyObject*)self); + Py_TYPE(self)->tp_free((PyObject*)self); } -static PyObject * SShape___repr__(BPy_SShape *self) +static PyObject * SShape_repr(BPy_SShape *self) { - return PyUnicode_FromFormat("SShape - address: %p", self->ss ); + return PyUnicode_FromFormat("SShape - address: %p", self->ss); } -static char SShape_AddEdge___doc__[] = -".. method:: AddEdge(iEdge)\n" +static char SShape_add_edge_doc[] = +".. method:: add_edge(iEdge)\n" "\n" " Adds an FEdge to the list of FEdges.\n" "\n" " :arg iEdge: An FEdge object.\n" " :type iEdge: :class:`FEdge`\n"; -static PyObject * SShape_AddEdge( BPy_SShape *self , PyObject *args) { +static PyObject * SShape_add_edge(BPy_SShape *self , PyObject *args) +{ PyObject *py_fe = 0; - if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) )) + if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe)) return NULL; - - self->ss->AddEdge( ((BPy_FEdge *) py_fe)->fe ); - + self->ss->AddEdge(((BPy_FEdge *)py_fe)->fe); Py_RETURN_NONE; } -static char SShape_AddNewVertex___doc__[] = -".. method:: AddNewVertex(iv)\n" +PyDoc_STRVAR(SShape_add_vertex_doc, +".. method:: add_vertex(iv)\n" "\n" " Adds an SVertex to the list of SVertex of this Shape. The SShape\n" " attribute of the SVertex is also set to this SShape.\n" "\n" " :arg iv: An SVertex object.\n" -" :type iv: :class:`SVertex`\n"; +" :type iv: :class:`SVertex`"); -static PyObject * SShape_AddNewVertex( BPy_SShape *self , PyObject *args) { +static PyObject * SShape_add_vertex(BPy_SShape *self , PyObject *args) +{ PyObject *py_sv = 0; - if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) )) + if (!PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv)) return NULL; - - self->ss->AddNewVertex( ((BPy_SVertex *) py_sv)->sv ); - + self->ss->AddNewVertex(((BPy_SVertex *)py_sv)->sv); Py_RETURN_NONE; } -static char SShape_setBBox___doc__[] = -".. method:: setBBox(iBBox)\n" -"\n" -" Sets the bounding box of the SShape.\n" +PyDoc_STRVAR(SShape_compute_bbox_doc, +".. method:: compute_bbox()\n" "\n" -" :arg iBBox: The bounding box of the SShape.\n" -" :type iBBox: :class:`BBox`\n"; - -static PyObject * SShape_setBBox( BPy_SShape *self , PyObject *args) { - PyObject *py_bb = 0; - - if(!( PyArg_ParseTuple(args, "O!", &BBox_Type, &py_bb) )) - return NULL; - - self->ss->setBBox(*( ((BPy_BBox*) py_bb)->bb )); +" Compute the bbox of the SShape."); +static PyObject * SShape_compute_bbox(BPy_SShape *self) +{ + self->ss->ComputeBBox(); Py_RETURN_NONE; } -static char SShape_ComputeBBox___doc__[] = -".. method:: ComputeBBox()\n" +// const Material & material (unsigned i) const +// const vector< Material > & materials () const +// void SetMaterials (const vector< Material > &iMaterials) + +static PyMethodDef BPy_SShape_methods[] = { + {"add_edge", (PyCFunction)SShape_add_edge, METH_VARARGS, SShape_add_edge_doc}, + {"add_vertex", (PyCFunction)SShape_add_vertex, METH_VARARGS, SShape_add_vertex_doc}, + {"compute_bbox", (PyCFunction)SShape_compute_bbox, METH_NOARGS, SShape_compute_bbox_doc}, + {NULL, NULL, 0, NULL} +}; + +/*----------------------SShape get/setters ----------------------------*/ + +PyDoc_STRVAR(SShape_id_doc, +"The Id of this SShape.\n" "\n" -" Compute the bbox of the SShape.\n"; +":type: :class:`Id`"); -static PyObject * SShape_ComputeBBox( BPy_SShape *self ) { - self->ss->ComputeBBox(); +static PyObject *SShape_id_get(BPy_SShape *self, void *UNUSED(closure)) +{ + Id id(self->ss->getId()); + return BPy_Id_from_Id(id); // return a copy +} - Py_RETURN_NONE; +static int SShape_id_set(BPy_SShape *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_Id_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an Id"); + return -1; + } + self->ss->setId(*(((BPy_Id *)value)->id)); + return 0; } -static char SShape_bbox___doc__[] = -".. method:: bbox()\n" +PyDoc_STRVAR(SShape_name_doc, +"The name of the SShape.\n" "\n" -" Returns the bounding box of the SShape.\n" -"\n" -" :return: the bounding box of the SShape.\n" -" :rtype: :class:`BBox`\n"; +":type: str"); -static PyObject * SShape_bbox( BPy_SShape *self ) { - BBox<Vec3r> bb( self->ss->bbox() ); - return BPy_BBox_from_BBox( bb ); +static PyObject *SShape_name_get(BPy_SShape *self, void *UNUSED(closure)) +{ + return PyUnicode_FromString(self->ss->getName().c_str()); } -static char SShape_getVertexList___doc__[] = -".. method:: getVertexList()\n" +static int SShape_name_set(BPy_SShape *self, PyObject *value, void *UNUSED(closure)) +{ + if (!PyUnicode_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be a string"); + return -1; + } + const string name = _PyUnicode_AsString(value); + self->ss->setName(name); + return 0; +} + +PyDoc_STRVAR(SShape_bbox_doc, +"The bounding box of the SShape.\n" "\n" -" Returns the list of vertices of the SShape.\n" +":type: :class:`BBox`"); + +static PyObject *SShape_bbox_get(BPy_SShape *self, void *UNUSED(closure)) +{ + BBox<Vec3r> bb(self->ss->bbox()); + return BPy_BBox_from_BBox(bb); // return a copy +} + +static int SShape_bbox_set(BPy_SShape *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_BBox_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be a BBox"); + return -1; + } + self->ss->setBBox(*(((BPy_BBox*)value)->bb)); + return 0; +} + +PyDoc_STRVAR(SShape_vertices_doc, +"The list of vertices constituting this SShape.\n" "\n" -" :return: The list of vertices objects.\n" -" :rtype: List of :class:`SVertex` objects\n"; +":type: List of :class:`SVertex` objects"); -static PyObject * SShape_getVertexList( BPy_SShape *self ) { +static PyObject *SShape_vertices_get(BPy_SShape *self, void *UNUSED(closure)) +{ PyObject *py_vertices = PyList_New(0); vector< SVertex * > vertices = self->ss->getVertexList(); vector< SVertex * >::iterator it; - for( it = vertices.begin(); it != vertices.end(); it++ ) { - PyList_Append( py_vertices, BPy_SVertex_from_SVertex(*( *it )) ); + for (it = vertices.begin(); it != vertices.end(); it++) { + PyList_Append(py_vertices, BPy_SVertex_from_SVertex(*(*it))); } return py_vertices; } -static char SShape_getEdgeList___doc__[] = -".. method:: getEdgeList()\n" -"\n" -" Returns the list of edges of the SShape.\n" +PyDoc_STRVAR(SShape_edges_doc, +"The list of edges constituting this SShape.\n" "\n" -" :return: The list of edges of the SShape.\n" -" :rtype: List of :class:`FEdge` objects\n"; +":type: List of :class:`FEdge` objects"); -static PyObject * SShape_getEdgeList( BPy_SShape *self ) { +static PyObject *SShape_edges_get(BPy_SShape *self, void *UNUSED(closure)) +{ PyObject *py_edges = PyList_New(0); vector< FEdge * > edges = self->ss->getEdgeList(); vector< FEdge * >::iterator it; - for( it = edges.begin(); it != edges.end(); it++ ) { - PyList_Append( py_edges, Any_BPy_FEdge_from_FEdge(*( *it )) ); + for (it = edges.begin(); it != edges.end(); it++) { + PyList_Append(py_edges, Any_BPy_FEdge_from_FEdge(*(*it))); } return py_edges; } -static char SShape_getId___doc__[] = -".. method:: getId()\n" -"\n" -" Returns the Id of the SShape.\n" -"\n" -" :return: The Id of the SShape.\n" -" :rtype: :class:`Id`\n"; - -static PyObject * SShape_getId( BPy_SShape *self ) { - Id id( self->ss->getId() ); - return BPy_Id_from_Id( id ); -} - -static char SShape_setId___doc__[] = -".. method:: setId(id)\n" -"\n" -" Sets the Id of the SShape.\n" -"\n" -" :arg id: The Id of the SShape.\n" -" :type id: :class:`Id`\n"; - -static PyObject * SShape_setId( BPy_SShape *self , PyObject *args) { - PyObject *py_id; - - if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) )) - return NULL; - - self->ss->setId(*( ((BPy_Id *) py_id)->id )); - - Py_RETURN_NONE; -} - -static char SShape_getName___doc__[] = -".. method:: getName()\n" -"\n" -" Returns the name of the SShape.\n" -"\n" -" :return: The name string.\n" -" :rtype: str\n"; - -static PyObject * SShape_getName( BPy_SShape *self ) { - return PyUnicode_FromString( self->ss->getName().c_str() ); -} - -static char SShape_setName___doc__[] = -".. method:: setName(name)\n" -"\n" -" Sets the name of the SShape.\n" -"\n" -" :arg name: A name string.\n" -" :type name: str\n"; - -static PyObject * SShape_setName( BPy_SShape *self , PyObject *args) { - char *s; - - if(!( PyArg_ParseTuple(args, "s", &s) )) - return NULL; - - self->ss->setName(s); - - Py_RETURN_NONE; -} - -// const Material & material (unsigned i) const -// const vector< Material > & materials () const -// void SetMaterials (const vector< Material > &iMaterials) - -/*----------------------SShape instance definitions ----------------------------*/ -static PyMethodDef BPy_SShape_methods[] = { - {"AddEdge", ( PyCFunction ) SShape_AddEdge, METH_VARARGS, SShape_AddEdge___doc__}, - {"AddNewVertex", ( PyCFunction ) SShape_AddNewVertex, METH_VARARGS, SShape_AddNewVertex___doc__}, - {"setBBox", ( PyCFunction ) SShape_setBBox, METH_VARARGS, SShape_setBBox___doc__}, - {"ComputeBBox", ( PyCFunction ) SShape_ComputeBBox, METH_NOARGS, SShape_ComputeBBox___doc__}, - {"bbox", ( PyCFunction ) SShape_bbox, METH_NOARGS, SShape_bbox___doc__}, - {"getVertexList", ( PyCFunction ) SShape_getVertexList, METH_NOARGS, SShape_getVertexList___doc__}, - {"getEdgeList", ( PyCFunction ) SShape_getEdgeList, METH_NOARGS, SShape_getEdgeList___doc__}, - {"getId", ( PyCFunction ) SShape_getId, METH_NOARGS, SShape_getId___doc__}, - {"setId", ( PyCFunction ) SShape_setId, METH_VARARGS, SShape_setId___doc__}, - {"getName", ( PyCFunction ) SShape_getName, METH_NOARGS, SShape_getName___doc__}, - {"setName", ( PyCFunction ) SShape_setName, METH_VARARGS, SShape_setName___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_SShape_getseters[] = { + {(char *)"id", (getter)SShape_id_get, (setter)SShape_id_set, (char *)SShape_id_doc, NULL}, + {(char *)"name", (getter)SShape_name_get, (setter)SShape_name_set, (char *)SShape_name_doc, NULL}, + {(char *)"bbox", (getter)SShape_bbox_get, (setter)SShape_bbox_set, (char *)SShape_bbox_doc, NULL}, + {(char *)"edges", (getter)SShape_edges_get, (setter)NULL, (char *)SShape_edges_doc, NULL}, + {(char *)"vertices", (getter)SShape_vertices_get, (setter)NULL, (char *)SShape_vertices_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_SShape type definition ------------------------------*/ @@ -287,12 +250,12 @@ PyTypeObject SShape_Type = { "SShape", /* tp_name */ sizeof(BPy_SShape), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)SShape___dealloc__, /* tp_dealloc */ + (destructor)SShape_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_reserved */ - (reprfunc)SShape___repr__, /* tp_repr */ + (reprfunc)SShape_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ @@ -303,7 +266,7 @@ PyTypeObject SShape_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - SShape___doc__, /* tp_doc */ + SShape_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -312,13 +275,13 @@ PyTypeObject SShape_Type = { 0, /* tp_iternext */ BPy_SShape_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_SShape_getseters, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)SShape___init__, /* tp_init */ + (initproc)SShape_init, /* tp_init */ 0, /* tp_alloc */ PyType_GenericNew, /* tp_new */ }; diff --git a/source/blender/freestyle/intern/python/BPy_ViewMap.cpp b/source/blender/freestyle/intern/python/BPy_ViewMap.cpp index c9667103e5a..985e6408e1b 100644 --- a/source/blender/freestyle/intern/python/BPy_ViewMap.cpp +++ b/source/blender/freestyle/intern/python/BPy_ViewMap.cpp @@ -12,48 +12,48 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// //-------------------MODULE INITIALIZATION-------------------------------- -int ViewMap_Init( PyObject *module ) +int ViewMap_Init(PyObject *module) { - if( module == NULL ) + if (module == NULL) return -1; - if( PyType_Ready( &ViewMap_Type ) < 0 ) + if (PyType_Ready( &ViewMap_Type ) < 0) return -1; - - Py_INCREF( &ViewMap_Type ); + Py_INCREF(&ViewMap_Type); PyModule_AddObject(module, "ViewMap", (PyObject *)&ViewMap_Type); + return 0; } -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------ViewMap methods----------------------------*/ -static char ViewMap___doc__[] = +PyDoc_STRVAR(ViewMap_doc, "Class defining the ViewMap.\n" "\n" ".. method:: __init__()\n" "\n" -" Default constructor.\n"; +" Default constructor."); -static int ViewMap___init__(BPy_ViewMap *self, PyObject *args, PyObject *kwds) +static int ViewMap_init(BPy_ViewMap *self, PyObject *args, PyObject *kwds) { self->vm = new ViewMap(); - return 0; + return 0; } -static void ViewMap___dealloc__(BPy_ViewMap *self) +static void ViewMap_dealloc(BPy_ViewMap *self) { - if( self->vm ) + if (self->vm) delete self->vm; - Py_TYPE(self)->tp_free((PyObject*)self); + Py_TYPE(self)->tp_free((PyObject*)self); } -static PyObject * ViewMap___repr__(BPy_ViewMap *self) +static PyObject * ViewMap_repr(BPy_ViewMap *self) { - return PyUnicode_FromFormat("ViewMap - address: %p", self->vm ); + return PyUnicode_FromFormat("ViewMap - address: %p", self->vm); } -static char ViewMap_getClosestViewEdge___doc__[] = -".. method:: getClosestViewEdge(x, y)\n" +PyDoc_STRVAR(ViewMap_get_closest_viewedge_doc, +".. method:: get_closest_viewedge(x, y)\n" "\n" " Gets the ViewEdge nearest to the 2D point specified as arguments.\n" "\n" @@ -62,23 +62,22 @@ static char ViewMap_getClosestViewEdge___doc__[] = " :arg y: Y coordinate of a 2D point.\n" " :type y: float\n" " :return: The ViewEdge nearest to the specified 2D point.\n" -" :rtype: :class:`ViewEdge`\n"; +" :rtype: :class:`ViewEdge`"); -static PyObject * ViewMap_getClosestViewEdge( BPy_ViewMap *self , PyObject *args) { +static PyObject * ViewMap_get_closest_viewedge(BPy_ViewMap *self , PyObject *args) +{ double x, y; - if(!( PyArg_ParseTuple(args, "dd", &x, &y) )) + if (!PyArg_ParseTuple(args, "dd", &x, &y)) return NULL; - - ViewEdge *ve = const_cast<ViewEdge *>( self->vm->getClosestViewEdge(x,y) ); - if( ve ) + ViewEdge *ve = const_cast<ViewEdge *>(self->vm->getClosestViewEdge(x,y)); + if (ve) return BPy_ViewEdge_from_ViewEdge(*ve); - Py_RETURN_NONE; } -static char ViewMap_getClosestFEdge___doc__[] = -".. method:: getClosestFEdge(x, y)\n" +PyDoc_STRVAR(ViewMap_get_closest_fedge_doc, +".. method:: get_closest_fedge(x, y)\n" "\n" " Gets the FEdge nearest to the 2D point specified as arguments.\n" "\n" @@ -87,62 +86,53 @@ static char ViewMap_getClosestFEdge___doc__[] = " :arg y: Y coordinate of a 2D point.\n" " :type y: float\n" " :return: The FEdge nearest to the specified 2D point.\n" -" :rtype: :class:`FEdge`\n"; +" :rtype: :class:`FEdge`"); -static PyObject * ViewMap_getClosestFEdge( BPy_ViewMap *self , PyObject *args) { +static PyObject * ViewMap_get_closest_fedge(BPy_ViewMap *self , PyObject *args) +{ double x, y; - if(!( PyArg_ParseTuple(args, "dd", &x, &y) )) + if (!PyArg_ParseTuple(args, "dd", &x, &y)) return NULL; - - FEdge *fe = const_cast<FEdge *>( self->vm->getClosestFEdge(x,y) ); - if( fe ) + FEdge *fe = const_cast<FEdge *>(self->vm->getClosestFEdge(x,y)); + if (fe) return Any_BPy_FEdge_from_FEdge(*fe); - Py_RETURN_NONE; } -static char ViewMap_getScene3dBBox___doc__[] = -".. method:: getScene3dBBox()\n" -"\n" -" Returns the scene 3D bounding box.\n" -"\n" -" :return: The scene 3D bounding box.\n" -" :rtype: :class:`BBox`\n"; - -static PyObject * ViewMap_getScene3dBBox( BPy_ViewMap *self , PyObject *args) { - BBox<Vec3r> bb( self->vm->getScene3dBBox() ); - return BPy_BBox_from_BBox( bb ); -} - -static char ViewMap_setScene3dBBox___doc__[] = -".. method:: setScene3dBBox(bbox)\n" -"\n" -" Sets the scene 3D bounding box.\n" -"\n" -" :arg bbox: The scene 3D bounding box.\n" -" :type bbox: :class:`BBox`\n"; +// static ViewMap *getInstance (); -static PyObject * ViewMap_setScene3dBBox( BPy_ViewMap *self , PyObject *args) { - PyObject *py_bb = 0; +static PyMethodDef BPy_ViewMap_methods[] = { + {"get_closest_viewedge", (PyCFunction)ViewMap_get_closest_viewedge, METH_VARARGS, ViewMap_get_closest_viewedge_doc}, + {"get_closest_fedge", (PyCFunction)ViewMap_get_closest_fedge, METH_VARARGS, ViewMap_get_closest_fedge_doc}, + {NULL, NULL, 0, NULL} +}; - if(!( PyArg_ParseTuple(args, "O!", &BBox_Type, &py_bb) )) - return NULL; +/*----------------------ViewMap get/setters ----------------------------*/ - self->vm->setScene3dBBox(*( ((BPy_BBox *) py_bb)->bb )); +PyDoc_STRVAR(ViewMap_scene_bbox_doc, +"The 3D bounding box of the scene.\n" +"\n" +":type: :class:`BBox`"); - Py_RETURN_NONE; +static PyObject *ViewMap_scene_bbox_get(BPy_ViewMap *self, void *UNUSED(closure)) +{ + return BPy_BBox_from_BBox(self->vm->getScene3dBBox()); } -// static ViewMap *getInstance (); +static int ViewMap_scene_bbox_set(BPy_ViewMap *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_BBox_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be a BBox"); + return -1; + } + self->vm->setScene3dBBox(*(((BPy_BBox *)value)->bb)); + return 0; +} -/*---------------------- BPy_ViewShape instance definitions ----------------------------*/ -static PyMethodDef BPy_ViewMap_methods[] = { - {"getClosestViewEdge", ( PyCFunction ) ViewMap_getClosestViewEdge, METH_VARARGS, ViewMap_getClosestViewEdge___doc__}, - {"getClosestFEdge", ( PyCFunction ) ViewMap_getClosestFEdge, METH_VARARGS, ViewMap_getClosestFEdge___doc__}, - {"getScene3dBBox", ( PyCFunction ) ViewMap_getScene3dBBox, METH_NOARGS, ViewMap_getScene3dBBox___doc__}, - {"setScene3dBBox", ( PyCFunction ) ViewMap_setScene3dBBox, METH_VARARGS, ViewMap_setScene3dBBox___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_ViewMap_getseters[] = { + {(char *)"scene_bbox", (getter)ViewMap_scene_bbox_get, (setter)ViewMap_scene_bbox_set, (char *)ViewMap_scene_bbox_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_ViewMap type definition ------------------------------*/ @@ -152,12 +142,12 @@ PyTypeObject ViewMap_Type = { "ViewMap", /* tp_name */ sizeof(BPy_ViewMap), /* tp_basicsize */ 0, /* tp_itemsize */ - (destructor)ViewMap___dealloc__, /* tp_dealloc */ + (destructor)ViewMap_dealloc, /* tp_dealloc */ 0, /* tp_print */ 0, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_reserved */ - (reprfunc)ViewMap___repr__, /* tp_repr */ + (reprfunc)ViewMap_repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ @@ -168,7 +158,7 @@ PyTypeObject ViewMap_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - ViewMap___doc__, /* tp_doc */ + ViewMap_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -177,13 +167,13 @@ PyTypeObject ViewMap_Type = { 0, /* tp_iternext */ BPy_ViewMap_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_ViewMap_getseters, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)ViewMap___init__, /* tp_init */ + (initproc)ViewMap_init, /* tp_init */ 0, /* tp_alloc */ PyType_GenericNew, /* tp_new */ }; 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 */ }; diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp index e213edd5c79..3e2cc495785 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp @@ -9,9 +9,9 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------CurvePoint methods----------------------------*/ -static char CurvePoint___doc__[] = +PyDoc_STRVAR(CurvePoint_doc, "Class hierarchy: :class:`Interface0D` > :class:`CurvePoint`\n" "\n" "Class to represent a point of a curve. A CurvePoint can be any point\n" @@ -57,15 +57,15 @@ static char CurvePoint___doc__[] = " :type iB: :class:`CurvePoint`\n" " :arg t2d: The 2D interpolation parameter used to linearly\n" " interpolate iA and iB.\n" -" :type t2d: float\n"; +" :type t2d: float"); -static int CurvePoint___init__(BPy_CurvePoint *self, PyObject *args, PyObject *kwds) +static int CurvePoint_init(BPy_CurvePoint *self, PyObject *args, PyObject *kwds) { PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0; - if (! PyArg_ParseTuple(args, "|OOO!", &obj1, &obj2, &PyFloat_Type, &obj3) ) - return -1; + if (! PyArg_ParseTuple(args, "|OOO!", &obj1, &obj2, &PyFloat_Type, &obj3) ) + return -1; if( !obj1 ){ self->cp = new CurvePoint(); @@ -102,131 +102,99 @@ static int CurvePoint___init__(BPy_CurvePoint *self, PyObject *args, PyObject *k return 0; } -static char CurvePoint_A___doc__[] = -".. method:: A()\n" -"\n" -" Returns the first SVertex upon which the CurvePoint is built.\n" -"\n" -" :return: The first SVertex.\n" -" :rtype: :class:`SVertex`\n"; +///bool operator== (const CurvePoint &b) -static PyObject * CurvePoint_A( BPy_CurvePoint *self ) { - SVertex *A = self->cp->A(); - if( A ) - return BPy_SVertex_from_SVertex( *A ); +static PyMethodDef BPy_CurvePoint_methods[] = { + {NULL, NULL, 0, NULL} +}; - Py_RETURN_NONE; -} +/*----------------------CurvePoint get/setters ----------------------------*/ -static char CurvePoint_B___doc__[] = -".. method:: B()\n" +PyDoc_STRVAR(CurvePoint_first_svertex_doc, +"The first SVertex upon which the CurvePoint is built.\n" "\n" -" Returns the second SVertex upon which the CurvePoint is built.\n" -"\n" -" :return: The second SVertex.\n" -" :rtype: :class:`SVertex`\n"; - -static PyObject * CurvePoint_B( BPy_CurvePoint *self ) { - SVertex *B = self->cp->B(); - if( B ) - return BPy_SVertex_from_SVertex( *B ); +":type: int"); +static PyObject *CurvePoint_first_svertex_get(BPy_CurvePoint *self, void *UNUSED(closure)) +{ + SVertex *A = self->cp->A(); + if (A) + return BPy_SVertex_from_SVertex(*A); Py_RETURN_NONE; } -static char CurvePoint_t2d___doc__[] = -".. method:: t2d()\n" -"\n" -" Returns the 2D interpolation parameter.\n" -"\n" -" :return: The 2D interpolation parameter.\n" -" :rtype: float\n"; - -static PyObject * CurvePoint_t2d( BPy_CurvePoint *self ) { - return PyFloat_FromDouble( self->cp->t2d() ); +static int CurvePoint_first_svertex_set(BPy_CurvePoint *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->cp->setA(((BPy_SVertex *)value)->sv); + return 0; } -static char CurvePoint_setA___doc__[] = -".. method:: setA(iA)\n" +PyDoc_STRVAR(CurvePoint_second_svertex_doc, +"The second SVertex upon which the CurvePoint is built.\n" "\n" -" Sets the first SVertex upon which to build the CurvePoint.\n" -"\n" -" :arg iA: The first SVertex.\n" -" :type iA: :class:`SVertex`\n"; - -static PyObject *CurvePoint_setA( BPy_CurvePoint *self , PyObject *args) { - PyObject *py_sv; - - if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) )) - return NULL; - - self->cp->setA( ((BPy_SVertex *) py_sv)->sv ); +":type: int"); +static PyObject *CurvePoint_second_svertex_get(BPy_CurvePoint *self, void *UNUSED(closure)) +{ + SVertex *B = self->cp->B(); + if (B) + return BPy_SVertex_from_SVertex(*B); Py_RETURN_NONE; } -static char CurvePoint_setB___doc__[] = -".. method:: setB(iB)\n" -"\n" -" Sets the first SVertex upon which to build the CurvePoint.\n" -"\n" -" :arg iB: The second SVertex.\n" -" :type iB: :class:`SVertex`\n"; - -static PyObject *CurvePoint_setB( BPy_CurvePoint *self , PyObject *args) { - PyObject *py_sv; - - if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) )) - return NULL; - - self->cp->setB( ((BPy_SVertex *) py_sv)->sv ); - - Py_RETURN_NONE; +static int CurvePoint_second_svertex_set(BPy_CurvePoint *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->cp->setB(((BPy_SVertex *)value)->sv); + return 0; } -static char CurvePoint_setT2d___doc__[] = -".. method:: setT2d(t)\n" -"\n" -" Sets the 2D interpolation parameter to use.\n" +PyDoc_STRVAR(CurvePoint_t2d_doc, +"The 2D interpolation parameter.\n" "\n" -" :arg t: The 2D interpolation parameter.\n" -" :type t: float\n"; +":type: float"); -static PyObject *CurvePoint_setT2d( BPy_CurvePoint *self , PyObject *args) { - float t; - - if(!( PyArg_ParseTuple(args, "f", &t) )) - return NULL; - - self->cp->setT2d( t ); +static PyObject *CurvePoint_t2d_get(BPy_CurvePoint *self, void *UNUSED(closure)) +{ + return PyFloat_FromDouble(self->cp->t2d()); +} - Py_RETURN_NONE; +static int CurvePoint_t2d_set(BPy_CurvePoint *self, PyObject *value, void *UNUSED(closure)) +{ + float scalar; + if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "value must be a number"); + return -1; + } + self->cp->setT2d(scalar); + return 0; } -static char CurvePoint_curvatureFredo___doc__[] = -".. method:: curvatureFredo()\n" -"\n" -" Returns the angle in radians.\n" +PyDoc_STRVAR(CurvePoint_curvature_fredo_doc, +"The angle (Fredo's curvature) in radians.\n" "\n" -" :return: The angle in radians.\n" -" :rtype: float\n"; +":type: float"); -static PyObject *CurvePoint_curvatureFredo( BPy_CurvePoint *self , PyObject *args) { - return PyFloat_FromDouble( self->cp->curvatureFredo() ); +static PyObject *CurvePoint_curvature_fredo_get(BPy_CurvePoint *self, void *UNUSED(closure)) +{ + return PyFloat_FromDouble(self->cp->curvatureFredo()); } -///bool operator== (const CurvePoint &b) +// todo - CurvePoint.directionFredo() -/*----------------------CurvePoint instance definitions ----------------------------*/ -static PyMethodDef BPy_CurvePoint_methods[] = { - {"A", ( PyCFunction ) CurvePoint_A, METH_NOARGS, CurvePoint_A___doc__}, - {"B", ( PyCFunction ) CurvePoint_B, METH_NOARGS, CurvePoint_B___doc__}, - {"t2d", ( PyCFunction ) CurvePoint_t2d, METH_NOARGS, CurvePoint_t2d___doc__}, - {"setA", ( PyCFunction ) CurvePoint_setA, METH_VARARGS, CurvePoint_setA___doc__}, - {"setB", ( PyCFunction ) CurvePoint_setB, METH_VARARGS, CurvePoint_setB___doc__}, - {"setT2d", ( PyCFunction ) CurvePoint_setT2d, METH_VARARGS, CurvePoint_setT2d___doc__}, - {"curvatureFredo", ( PyCFunction ) CurvePoint_curvatureFredo, METH_NOARGS, CurvePoint_curvatureFredo___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_CurvePoint_getseters[] = { + {(char *)"first_svertex", (getter)CurvePoint_first_svertex_get, (setter)CurvePoint_first_svertex_set, (char *)CurvePoint_first_svertex_doc, NULL}, + {(char *)"second_svertex", (getter)CurvePoint_second_svertex_get, (setter)CurvePoint_second_svertex_set, (char *)CurvePoint_second_svertex_doc, NULL}, + {(char *)"t2d", (getter)CurvePoint_t2d_get, (setter)CurvePoint_t2d_set, (char *)CurvePoint_t2d_doc, NULL}, + {(char *)"curvature_fredo", (getter)CurvePoint_curvature_fredo_get, (setter)NULL, (char *)CurvePoint_curvature_fredo_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_CurvePoint type definition ------------------------------*/ @@ -251,7 +219,7 @@ PyTypeObject CurvePoint_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - CurvePoint___doc__, /* tp_doc */ + CurvePoint_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -260,13 +228,13 @@ PyTypeObject CurvePoint_Type = { 0, /* tp_iternext */ BPy_CurvePoint_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_CurvePoint_getseters, /* tp_getset */ &Interface0D_Type, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)CurvePoint___init__, /* tp_init */ + (initproc)CurvePoint_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp index 14e6f143b84..0d0a772b4e5 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp @@ -10,7 +10,9 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// -static char SVertex___doc__[] = +/*----------------------SVertex methods ----------------------------*/ + +PyDoc_STRVAR(SVertex_doc, "Class hierarchy: :class:`Interface0D` > :class:`SVertex`\n" "\n" "Class to define a vertex of the embedding.\n" @@ -33,32 +35,29 @@ static char SVertex___doc__[] = " :arg iPoint3D: A three-dimensional vector.\n" " :type iPoint3D: :class:`mathutils.Vector`\n" " :arg id: An Id object.\n" -" :type id: :class:`Id`\n"; - -//------------------------INSTANCE METHODS ---------------------------------- +" :type id: :class:`Id`"); -static int SVertex___init__(BPy_SVertex *self, PyObject *args, PyObject *kwds) +static int SVertex_init(BPy_SVertex *self, PyObject *args, PyObject *kwds) { PyObject *py_point = 0; BPy_Id *py_id = 0; - - if (! PyArg_ParseTuple(args, "|OO!", &py_point, &Id_Type, &py_id) ) - return -1; + if (!PyArg_ParseTuple(args, "|OO!", &py_point, &Id_Type, &py_id)) + return -1; - if( !py_point ) { + if (!py_point) { self->sv = new SVertex(); - } else if( !py_id && BPy_SVertex_Check(py_point) ) { + } else if (!py_id && BPy_SVertex_Check(py_point)) { self->sv = new SVertex( *(((BPy_SVertex *)py_point)->sv) ); - } else if( py_point && py_id ) { + } else if (py_point && py_id) { Vec3r *v = Vec3r_ptr_from_PyObject(py_point); - if( !v ) { + if (!v) { PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); return -1; } - self->sv = new SVertex( *v, *(py_id->id) ); + self->sv = new SVertex(*v, *(py_id->id)); delete v; } else { @@ -68,192 +67,310 @@ static int SVertex___init__(BPy_SVertex *self, PyObject *args, PyObject *kwds) self->py_if0D.if0D = self->sv; self->py_if0D.borrowed = 0; - + return 0; } -static char SVertex_normals___doc__[] = -".. method:: normals()\n" +PyDoc_STRVAR(SVertex_add_normal_doc, +".. method:: add_normal(n)\n" "\n" -" Returns the normals for this Vertex as a list. In a smooth surface,\n" -" a vertex has exactly one normal. In a sharp surface, a vertex can\n" -" have any number of normals.\n" +" Adds a normal to the SVertex's set of normals. If the same normal\n" +" is already in the set, nothing changes.\n" "\n" -" :return: A list of normals.\n" -" :rtype: List of :class:`mathutils.Vector` objects\n"; +" :arg n: A three-dimensional vector.\n" +" :type n: :class:`mathutils.Vector`, list or tuple of 3 real numbers"); -static PyObject * SVertex_normals( BPy_SVertex *self ) { - PyObject *py_normals; - set< Vec3r > normals; - - py_normals = PyList_New(0); - normals = self->sv->normals(); - - for( set< Vec3r >::iterator set_iterator = normals.begin(); set_iterator != normals.end(); set_iterator++ ) { - Vec3r v( *set_iterator ); - PyList_Append( py_normals, Vector_from_Vec3r(v) ); +static PyObject *SVertex_add_normal( BPy_SVertex *self , PyObject *args) { + PyObject *py_normal; + + if (!PyArg_ParseTuple(args, "O", &py_normal)) + return NULL; + Vec3r *n = Vec3r_ptr_from_PyObject(py_normal); + if (!n) { + PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); + return NULL; } - - return py_normals; + self->sv->AddNormal(*n); + delete n; + + Py_RETURN_NONE; } -static char SVertex_normalsSize___doc__[] = -".. method:: normalsSize()\n" +PyDoc_STRVAR(SVertex_add_fedge_doc, +".. method:: add_fedge(fe)\n" "\n" -" Returns the number of different normals for this vertex.\n" +" Add an FEdge to the list of edges emanating from this SVertex.\n" "\n" -" :return: The number of normals.\n" -" :rtype: int\n"; +" :arg fe: An FEdge.\n" +" :type fe: :class:`FEdge`"); + +static PyObject *SVertex_add_fedge( BPy_SVertex *self , PyObject *args) { + PyObject *py_fe; -static PyObject * SVertex_normalsSize( BPy_SVertex *self ) { - return PyLong_FromLong( self->sv->normalsSize() ); + if (!PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe)) + return NULL; + + self->sv->AddFEdge(((BPy_FEdge *)py_fe)->fe); + + Py_RETURN_NONE; } -static char SVertex_viewvertex___doc__[] = -".. method:: viewvertex()\n" -"\n" -" If this SVertex is also a ViewVertex, this method returns the\n" -" ViewVertex. None is returned otherwise.\n" -"\n" -" :return: The ViewVertex object.\n" -" :rtype: :class:`ViewVertex`\n"; +// virtual bool operator== (const SVertex &iBrother) -static PyObject * SVertex_viewvertex( BPy_SVertex *self ) { - ViewVertex *vv = self->sv->viewvertex(); - if( vv ) - return Any_BPy_ViewVertex_from_ViewVertex( *vv ); +static PyMethodDef BPy_SVertex_methods[] = { + {"add_normal", (PyCFunction)SVertex_add_normal, METH_VARARGS, SVertex_add_normal_doc}, + {"add_fedge", (PyCFunction)SVertex_add_fedge, METH_VARARGS, SVertex_add_fedge_doc}, + {NULL, NULL, 0, NULL} +}; - Py_RETURN_NONE; +/*----------------------mathutils callbacks ----------------------------*/ + +/* subtype */ +#define MATHUTILS_SUBTYPE_POINT3D 1 +#define MATHUTILS_SUBTYPE_POINT2D 2 + +static int SVertex_mathutils_check(BaseMathObject *bmo) +{ + if (!BPy_SVertex_Check(bmo->cb_user)) + return -1; + return 0; } -static char SVertex_setPoint3D___doc__[] = -".. method:: setPoint3D(p)\n" -"\n" -" Sets the 3D coordinates of the SVertex.\n" -"\n" -" :arg p: A three-dimensional vector.\n" -" :type p: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"; +static int SVertex_mathutils_get(BaseMathObject *bmo, int subtype) +{ + BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_POINT3D: + bmo->data[0] = self->sv->getX(); + bmo->data[1] = self->sv->getY(); + bmo->data[2] = self->sv->getZ(); + break; + case MATHUTILS_SUBTYPE_POINT2D: + bmo->data[0] = self->sv->getProjectedX(); + bmo->data[1] = self->sv->getProjectedY(); + bmo->data[2] = self->sv->getProjectedZ(); + break; + default: + return -1; + } + return 0; +} -static PyObject *SVertex_setPoint3D( BPy_SVertex *self , PyObject *args) { - PyObject *py_point; +static int SVertex_mathutils_set(BaseMathObject *bmo, int subtype) +{ + BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_POINT3D: + { + Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]); + self->sv->setPoint3D(p); + } + break; + case MATHUTILS_SUBTYPE_POINT2D: + { + Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]); + self->sv->setPoint2D(p); + } + break; + default: + return -1; + } + return 0; +} - if(!( PyArg_ParseTuple(args, "O", &py_point) )) - return NULL; - Vec3r *v = Vec3r_ptr_from_PyObject(py_point); - if( !v ) { - PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); - return NULL; +static int SVertex_mathutils_get_index(BaseMathObject *bmo, int subtype, int index) +{ + BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_POINT3D: + switch (index) { + case 0: bmo->data[0] = self->sv->getX(); break; + case 1: bmo->data[1] = self->sv->getY(); break; + case 2: bmo->data[2] = self->sv->getZ(); break; + default: + return -1; + } + break; + case MATHUTILS_SUBTYPE_POINT2D: + switch (index) { + case 0: bmo->data[0] = self->sv->getProjectedX(); break; + case 1: bmo->data[1] = self->sv->getProjectedY(); break; + case 2: bmo->data[2] = self->sv->getProjectedZ(); break; + default: + return -1; + } + break; + default: + return -1; } - self->sv->setPoint3D( *v ); - delete v; + return 0; +} - Py_RETURN_NONE; +static int SVertex_mathutils_set_index(BaseMathObject *bmo, int subtype, int index) +{ + BPy_SVertex *self = (BPy_SVertex *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_POINT3D: + { + Vec3r p(self->sv->point3D()); + p[index] = bmo->data[index]; + self->sv->setPoint3D(p); + } + break; + case MATHUTILS_SUBTYPE_POINT2D: + { + Vec3r p(self->sv->point2D()); + p[index] = bmo->data[index]; + self->sv->setPoint2D(p); + } + break; + default: + return -1; + } + return 0; } -static char SVertex_setPoint2D___doc__[] = -".. method:: setPoint2D(p)\n" -"\n" -" Sets the 2D projected coordinates of the SVertex.\n" +static Mathutils_Callback SVertex_mathutils_cb = { + SVertex_mathutils_check, + SVertex_mathutils_get, + SVertex_mathutils_set, + SVertex_mathutils_get_index, + SVertex_mathutils_set_index +}; + +static unsigned char SVertex_mathutils_cb_index = -1; + +void SVertex_mathutils_register_callback() +{ + SVertex_mathutils_cb_index = Mathutils_RegisterCallback(&SVertex_mathutils_cb); +} + +/*----------------------SVertex get/setters ----------------------------*/ + +PyDoc_STRVAR(SVertex_point_3d_doc, +"The 3D coordinates of the SVertex.\n" "\n" -" :arg p: A three-dimensional vector.\n" -" :type p: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"; +":type: mathutils.Vector"); -static PyObject *SVertex_setPoint2D( BPy_SVertex *self , PyObject *args) { - PyObject *py_point; +static PyObject *SVertex_point_3d_get(BPy_SVertex *self, void *UNUSED(closure)) +{ + return Vector_CreatePyObject_cb((PyObject *)self, 3, SVertex_mathutils_cb_index, MATHUTILS_SUBTYPE_POINT3D); +} - if(!( PyArg_ParseTuple(args, "O", &py_point) )) - return NULL; - Vec3r *v = Vec3r_ptr_from_PyObject(py_point); - if( !v ) { - PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); - return NULL; +static int SVertex_point_3d_set(BPy_SVertex *self, PyObject *value, void *UNUSED(closure)) +{ + float v[3]; + if (!float_array_from_PyObject(value, v, 3)) { + PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector"); + return -1; } - self->sv->setPoint2D( *v ); - delete v; - - Py_RETURN_NONE; + Vec3r p(v[0], v[1], v[2]); + self->sv->setPoint3D(p); + return 0; } -static char SVertex_AddNormal___doc__[] = -".. method:: AddNormal(n)\n" -"\n" -" Adds a normal to the SVertex's set of normals. If the same normal\n" -" is already in the set, nothing changes.\n" +PyDoc_STRVAR(SVertex_point_2d_doc, +"The projected 3D coordinates of the SVertex.\n" "\n" -" :arg n: A three-dimensional vector.\n" -" :type n: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"; +":type: mathutils.Vector"); -static PyObject *SVertex_AddNormal( BPy_SVertex *self , PyObject *args) { - PyObject *py_normal; +static PyObject *SVertex_point_2d_get(BPy_SVertex *self, void *UNUSED(closure)) +{ + return Vector_CreatePyObject_cb((PyObject *)self, 3, SVertex_mathutils_cb_index, MATHUTILS_SUBTYPE_POINT2D); +} - if(!( PyArg_ParseTuple(args, "O", &py_normal) )) - return NULL; - Vec3r *n = Vec3r_ptr_from_PyObject(py_normal); - if( !n ) { - PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); - return NULL; +static int SVertex_point_2d_set(BPy_SVertex *self, PyObject *value, void *UNUSED(closure)) +{ + float v[3]; + if (!float_array_from_PyObject(value, v, 3)) { + PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector"); + return -1; } - self->sv->AddNormal( *n ); - delete n; - - Py_RETURN_NONE; + Vec3r p(v[0], v[1], v[2]); + self->sv->setPoint2D(p); + return 0; } -static char SVertex_setId___doc__[] = -".. method:: setId(id)\n" -"\n" -" Sets the identifier of the SVertex.\n" +PyDoc_STRVAR(SVertex_id_doc, +"The Id of this SVertex.\n" "\n" -" :arg id: The identifier.\n" -" :type id: :class:`Id`\n"; +":type: :class:`Id`"); -static PyObject *SVertex_setId( BPy_SVertex *self , PyObject *args) { - BPy_Id *py_id; +static PyObject *SVertex_id_get(BPy_SVertex *self, void *UNUSED(closure)) +{ + Id id(self->sv->getId()); + return BPy_Id_from_Id(id); // return a copy +} - if( !PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) ) - return NULL; +static int SVertex_id_set(BPy_SVertex *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_Id_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an Id"); + return -1; + } + self->sv->setId(*(((BPy_Id *)value)->id)); + return 0; +} - self->sv->setId( *(py_id->id) ); +PyDoc_STRVAR(SVertex_normals_doc, +"The normals for this Vertex as a list. In a sharp surface, an SVertex\n" +"has exactly one normal. In a smooth surface, an SVertex can have any\n" +"number of normals.\n" +"\n" +":type: list of :class:`mathutils.Vector` objects"); - Py_RETURN_NONE; +static PyObject *SVertex_normals_get(BPy_SVertex *self, void *UNUSED(closure)) +{ + PyObject *py_normals; + set< Vec3r > normals; + + py_normals = PyList_New(0); + normals = self->sv->normals(); + for (set< Vec3r >::iterator set_iterator = normals.begin(); set_iterator != normals.end(); set_iterator++) { + Vec3r v(*set_iterator); + PyList_Append(py_normals, Vector_from_Vec3r(v)); + } + return py_normals; } -static char SVertex_AddFEdge___doc__[] = -".. method:: AddFEdge(fe)\n" -"\n" -" Add an FEdge to the list of edges emanating from this SVertex.\n" +PyDoc_STRVAR(SVertex_normals_size_doc, +"The number of different normals for this SVertex.\n" "\n" -" :arg fe: An FEdge.\n" -" :type fe: :class:`FEdge`\n"; +":type: int"); -static PyObject *SVertex_AddFEdge( BPy_SVertex *self , PyObject *args) { - PyObject *py_fe; +static PyObject *SVertex_normals_size_get(BPy_SVertex *self, void *UNUSED(closure)) +{ + return PyLong_FromLong(self->sv->normalsSize()); +} - if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) )) - return NULL; - - self->sv->AddFEdge( ((BPy_FEdge *) py_fe)->fe ); +PyDoc_STRVAR(SVertex_viewvertex_doc, +"If this SVertex is also a ViewVertex, this property refers to the\n" +"ViewVertex, and None otherwise.\n" +":type: :class:`ViewVertex`"); +static PyObject *SVertex_viewvertex_get(BPy_SVertex *self, void *UNUSED(closure)) +{ + ViewVertex *vv = self->sv->viewvertex(); + if (vv) + return Any_BPy_ViewVertex_from_ViewVertex(*vv); Py_RETURN_NONE; } -static char SVertex_curvatures___doc__[] = -".. method:: curvatures()\n" +PyDoc_STRVAR(SVertex_curvatures_doc, +"Curvature information expressed in the form of a seven-element tuple\n" +"(K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values\n" +"representing the first (maximum) and second (minimum) principal\n" +"curvatures at this SVertex, respectively; e1 and e2 are\n" +"three-dimensional vectors representing the first and second principal\n" +"directions, i.e. the directions of the normal plane where the\n" +"curvature takes its maximum and minimum values, respectively; and Kr,\n" +"er and dKr are the radial curvature, radial direction, and the\n" +"derivative of the radial curvature at this SVertex, repectively.\n" "\n" -" Returns curvature information in the form of a seven-element tuple\n" -" (K1, e1, K2, e2, Kr, er, dKr), where K1 and K2 are scalar values\n" -" representing the first (maximum) and second (minimum) principal\n" -" curvatures at this SVertex, respectively; e1 and e2 are\n" -" three-dimensional vectors representing the first and second principal\n" -" directions, i.e. the directions of the normal plane where the\n" -" curvature takes its maximum and minimum values, respectively; and Kr,\n" -" er and dKr are the radial curvature, radial direction, and the\n" -" derivative of the radial curvature at this SVertex, repectively.\n" -" :return: curvature information expressed by a seven-element tuple\n" -" (K1, e1, K2, e2, Kr, er, dKr).\n" -" :rtype: tuple\n"; - -static PyObject *SVertex_curvatures( BPy_SVertex *self , PyObject *args) { +":type: tuple"); + +static PyObject *SVertex_curvatures_get(BPy_SVertex *self, void *UNUSED(closure)) +{ const CurvatureInfo *info = self->sv->getCurvatureInfo(); if (!info) Py_RETURN_NONE; @@ -261,31 +378,25 @@ static PyObject *SVertex_curvatures( BPy_SVertex *self , PyObject *args) { Vec3r e2(info->e2.x(), info->e2.y(), info->e2.z()); Vec3r er(info->er.x(), info->er.y(), info->er.z()); PyObject *retval = PyTuple_New(7); - PyTuple_SET_ITEM( retval, 0, PyFloat_FromDouble(info->K1)); - PyTuple_SET_ITEM( retval, 2, Vector_from_Vec3r(e1)); - PyTuple_SET_ITEM( retval, 1, PyFloat_FromDouble(info->K2)); - PyTuple_SET_ITEM( retval, 3, Vector_from_Vec3r(e2)); - PyTuple_SET_ITEM( retval, 4, PyFloat_FromDouble(info->Kr)); - PyTuple_SET_ITEM( retval, 5, Vector_from_Vec3r(er)); - PyTuple_SET_ITEM( retval, 6, PyFloat_FromDouble(info->dKr)); + PyTuple_SET_ITEM(retval, 0, PyFloat_FromDouble(info->K1)); + PyTuple_SET_ITEM(retval, 2, Vector_from_Vec3r(e1)); + PyTuple_SET_ITEM(retval, 1, PyFloat_FromDouble(info->K2)); + PyTuple_SET_ITEM(retval, 3, Vector_from_Vec3r(e2)); + PyTuple_SET_ITEM(retval, 4, PyFloat_FromDouble(info->Kr)); + PyTuple_SET_ITEM(retval, 5, Vector_from_Vec3r(er)); + PyTuple_SET_ITEM(retval, 6, PyFloat_FromDouble(info->dKr)); return retval; } -// virtual bool operator== (const SVertex &iBrother) -// ViewVertex * viewvertex () - -/*----------------------SVertex instance definitions ----------------------------*/ -static PyMethodDef BPy_SVertex_methods[] = { - {"normals", ( PyCFunction ) SVertex_normals, METH_NOARGS, SVertex_normals___doc__}, - {"normalsSize", ( PyCFunction ) SVertex_normalsSize, METH_NOARGS, SVertex_normalsSize___doc__}, - {"viewvertex", ( PyCFunction ) SVertex_viewvertex, METH_NOARGS, SVertex_viewvertex___doc__}, - {"setPoint3D", ( PyCFunction ) SVertex_setPoint3D, METH_VARARGS, SVertex_setPoint3D___doc__}, - {"setPoint2D", ( PyCFunction ) SVertex_setPoint2D, METH_VARARGS, SVertex_setPoint2D___doc__}, - {"AddNormal", ( PyCFunction ) SVertex_AddNormal, METH_VARARGS, SVertex_AddNormal___doc__}, - {"setId", ( PyCFunction ) SVertex_setId, METH_VARARGS, SVertex_setId___doc__}, - {"AddFEdge", ( PyCFunction ) SVertex_AddFEdge, METH_VARARGS, SVertex_AddFEdge___doc__}, - {"curvatures", ( PyCFunction ) SVertex_curvatures, METH_NOARGS, SVertex_curvatures___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_SVertex_getseters[] = { + {(char *)"point_3d", (getter)SVertex_point_3d_get, (setter)SVertex_point_3d_set, (char *)SVertex_point_3d_doc, NULL}, + {(char *)"point_2d", (getter)SVertex_point_2d_get, (setter)SVertex_point_2d_set, (char *)SVertex_point_2d_doc, NULL}, + {(char *)"id", (getter)SVertex_id_get, (setter)SVertex_id_set, (char *)SVertex_id_doc, NULL}, + {(char *)"normals", (getter)SVertex_normals_get, (setter)NULL, (char *)SVertex_normals_doc, NULL}, + {(char *)"normals_size", (getter)SVertex_normals_size_get, (setter)NULL, (char *)SVertex_normals_size_doc, NULL}, + {(char *)"viewvertex", (getter)SVertex_viewvertex_get, (setter)NULL, (char *)SVertex_viewvertex_doc, NULL}, + {(char *)"curvatures", (getter)SVertex_curvatures_get, (setter)NULL, (char *)SVertex_curvatures_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_SVertex type definition ------------------------------*/ @@ -310,7 +421,7 @@ PyTypeObject SVertex_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - SVertex___doc__, /* tp_doc */ + SVertex_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -319,13 +430,13 @@ PyTypeObject SVertex_Type = { 0, /* tp_iternext */ BPy_SVertex_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_SVertex_getseters, /* tp_getset */ &Interface0D_Type, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)SVertex___init__, /* tp_init */ + (initproc)SVertex_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; @@ -335,4 +446,3 @@ PyTypeObject SVertex_Type = { #ifdef __cplusplus } #endif - diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h index 7d310f2b7dc..61c65659a5e 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h @@ -23,6 +23,10 @@ typedef struct { SVertex *sv; } BPy_SVertex; +/*---------------------------Python BPy_SVertex visible prototypes-----------*/ + +void SVertex_mathutils_register_callback(); + /////////////////////////////////////////////////////////////////////////////////////////// #ifdef __cplusplus diff --git a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp index c1fe6875ea7..4fabfc508db 100644 --- a/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp @@ -10,9 +10,9 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------ViewVertex methods----------------------------*/ -static char ViewVertex___doc__[] = +PyDoc_STRVAR(ViewVertex_doc, "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex`\n" "\n" "Class to define a view vertex. A view vertex is a feature vertex\n" @@ -34,43 +34,20 @@ static char ViewVertex___doc__[] = " Copy constructor.\n" "\n" " :arg iBrother: A ViewVertex object.\n" -" :type iBrother: :class:`ViewVertex`\n"; +" :type iBrother: :class:`ViewVertex`"); -static int ViewVertex___init__( BPy_ViewVertex *self, PyObject *args, PyObject *kwds ) -{ - if( !PyArg_ParseTuple(args, "") ) - return -1; +static int ViewVertex_init(BPy_ViewVertex *self, PyObject *args, PyObject *kwds) +{ + if (!PyArg_ParseTuple(args, "")) + return -1; self->vv = 0; // ViewVertex is abstract self->py_if0D.if0D = self->vv; self->py_if0D.borrowed = 0; return 0; } -static char ViewVertex_setNature___doc__[] = -".. method:: setNature(iNature)\n" -"\n" -" Sets the nature of the vertex.\n" -"\n" -" :arg iNature: A Nature object.\n" -" :type iNature: :class:`Nature`\n"; - -static PyObject * ViewVertex_setNature( BPy_ViewVertex *self, PyObject *args ) { - PyObject *py_n; - - if( !self->vv ) - Py_RETURN_NONE; - - if(!( PyArg_ParseTuple(args, "O!", &Nature_Type, &py_n) )) - return NULL; - - PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i ); - ((ViewVertex *) self->py_if0D.if0D)->setNature( PyLong_AsLong(i) ); - - Py_RETURN_NONE; -} - -static char ViewVertex_edgesBegin___doc__[] = -".. method:: edgesBegin()\n" +PyDoc_STRVAR(ViewVertex_edges_begin_doc, +".. method:: edges_begin()\n" "\n" " Returns an iterator over the ViewEdges that goes to or comes from\n" " this ViewVertex pointing to the first ViewEdge of the list. The\n" @@ -79,40 +56,40 @@ static char ViewVertex_edgesBegin___doc__[] = " (incoming/outgoing).\n" "\n" " :return: An orientedViewEdgeIterator pointing to the first ViewEdge.\n" -" :rtype: :class:`orientedViewEdgeIterator`\n"; +" :rtype: :class:`orientedViewEdgeIterator`"); -static PyObject * ViewVertex_edgesBegin( BPy_ViewVertex *self ) { - if( !self->vv ) +static PyObject * ViewVertex_edges_begin(BPy_ViewVertex *self) +{ + if (!self->vv) Py_RETURN_NONE; - - ViewVertexInternal::orientedViewEdgeIterator ove_it( self->vv->edgesBegin() ); - return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator( ove_it, 0 ); + ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesBegin()); + return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 0); } -static char ViewVertex_edgesEnd___doc__[] = -".. method:: edgesEnd()\n" +PyDoc_STRVAR(ViewVertex_edges_end_doc, +".. method:: edges_end()\n" "\n" " Returns an orientedViewEdgeIterator over the ViewEdges around this\n" " ViewVertex, pointing after the last ViewEdge.\n" "\n" " :return: An orientedViewEdgeIterator pointing after the last ViewEdge.\n" -" :rtype: :class:`orientedViewEdgeIterator`\n"; +" :rtype: :class:`orientedViewEdgeIterator`"); -static PyObject * ViewVertex_edgesEnd( BPy_ViewVertex *self ) { +static PyObject * ViewVertex_edges_end(BPy_ViewVertex *self) +{ #if 0 - if( !self->vv ) + if (!self->vv) Py_RETURN_NONE; - - ViewVertexInternal::orientedViewEdgeIterator ove_it( self->vv->edgesEnd() ); - return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator( ove_it, 1 ); + ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesEnd()); + return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 1); #else - PyErr_SetString(PyExc_NotImplementedError, "edgesEnd method currently disabled"); + PyErr_SetString(PyExc_NotImplementedError, "edges_end method currently disabled"); return NULL; #endif } -static char ViewVertex_edgesIterator___doc__[] = -".. method:: edgesIterator(iEdge)\n" +PyDoc_STRVAR(ViewVertex_edges_iterator_doc, +".. method:: edges_iterator(iEdge)\n" "\n" " Returns an orientedViewEdgeIterator pointing to the ViewEdge given\n" " as argument.\n" @@ -120,31 +97,58 @@ static char ViewVertex_edgesIterator___doc__[] = " :arg iEdge: A ViewEdge object.\n" " :type iEdge: :class:`ViewEdge`\n" " :return: An orientedViewEdgeIterator pointing to the given ViewEdge.\n" -" :rtype: :class:`orientedViewEdgeIterator`\n"; +" :rtype: :class:`orientedViewEdgeIterator`"); -static PyObject * ViewVertex_edgesIterator( BPy_ViewVertex *self, PyObject *args ) { +static PyObject * ViewVertex_edges_iterator(BPy_ViewVertex *self, PyObject *args) +{ PyObject *py_ve; - if( !self->vv ) + if (!self->vv) Py_RETURN_NONE; - - if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) )) + if (!PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve)) return NULL; - - ViewEdge *ve = ((BPy_ViewEdge *) py_ve)->ve; - ViewVertexInternal::orientedViewEdgeIterator ove_it( self->vv->edgesIterator( ve ) ); - return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator( ove_it, 0 ); + ViewEdge *ve = ((BPy_ViewEdge *)py_ve)->ve; + ViewVertexInternal::orientedViewEdgeIterator ove_it(self->vv->edgesIterator(ve)); + return BPy_orientedViewEdgeIterator_from_orientedViewEdgeIterator(ove_it, 0); } -/*----------------------ViewVertex instance definitions ----------------------------*/ static PyMethodDef BPy_ViewVertex_methods[] = { - {"setNature", ( PyCFunction ) ViewVertex_setNature, METH_VARARGS, ViewVertex_setNature___doc__}, - {"edgesBegin", ( PyCFunction ) ViewVertex_edgesBegin, METH_NOARGS, ViewVertex_edgesBegin___doc__}, - {"edgesEnd", ( PyCFunction ) ViewVertex_edgesEnd, METH_NOARGS, ViewVertex_edgesEnd___doc__}, - {"edgesIterator", ( PyCFunction ) ViewVertex_edgesIterator, METH_VARARGS, ViewVertex_edgesIterator___doc__}, + {"edges_begin", (PyCFunction)ViewVertex_edges_begin, METH_NOARGS, ViewVertex_edges_begin_doc}, + {"edges_end", (PyCFunction)ViewVertex_edges_end, METH_NOARGS, ViewVertex_edges_end_doc}, + {"edges_iterator", (PyCFunction)ViewVertex_edges_iterator, METH_VARARGS, ViewVertex_edges_iterator_doc}, {NULL, NULL, 0, NULL} }; +/*----------------------ViewVertex get/setters ----------------------------*/ + +PyDoc_STRVAR(ViewVertex_nature_doc, +"The nature of this ViewVertex.\n" +"\n" +":type: :class:`Nature`"); + +static PyObject *ViewVertex_nature_get(BPy_ViewVertex *self, void *UNUSED(closure)) +{ + Nature::VertexNature nature = self->vv->getNature(); + if (PyErr_Occurred()) + return NULL; + return BPy_Nature_from_Nature(nature); // return a copy +} + +static int ViewVertex_nature_set(BPy_ViewVertex *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_Nature_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be a Nature"); + return -1; + } + self->vv->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i)); + return 0; +} + +static PyGetSetDef BPy_ViewVertex_getseters[] = { + {(char *)"nature", (getter)ViewVertex_nature_get, (setter)ViewVertex_nature_set, (char *)ViewVertex_nature_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ +}; + /*-----------------------BPy_ViewVertex type definition ------------------------------*/ PyTypeObject ViewVertex_Type = { PyVarObject_HEAD_INIT(NULL, 0) @@ -167,7 +171,7 @@ PyTypeObject ViewVertex_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - ViewVertex___doc__, /* tp_doc */ + ViewVertex_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -176,13 +180,13 @@ PyTypeObject ViewVertex_Type = { 0, /* tp_iternext */ BPy_ViewVertex_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_ViewVertex_getseters, /* tp_getset */ &Interface0D_Type, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)ViewVertex___init__, /* tp_init */ + (initproc)ViewVertex_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; diff --git a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp index ebb2920353d..a0e0717ef37 100644 --- a/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp +++ b/source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp @@ -9,9 +9,9 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------NonTVertex methods ----------------------------*/ -static char NonTVertex___doc__[] = +PyDoc_STRVAR(NonTVertex_doc, "Class hierarchy: :class:`Interface0D` > :class:`ViewVertex` > :class:`NonTVertex`\n" "\n" "View vertex for corners, cusps, etc. associated to a single SVertex.\n" @@ -33,21 +33,20 @@ static char NonTVertex___doc__[] = " Builds a NonTVertex from a SVertex.\n" "\n" " :arg iSVertex: An SVertex object.\n" -" :type iSVertex: :class:`SVertex`\n"; +" :type iSVertex: :class:`SVertex`"); -static int NonTVertex___init__(BPy_NonTVertex *self, PyObject *args, PyObject *kwds) +static int NonTVertex_init(BPy_NonTVertex *self, PyObject *args, PyObject *kwds) { - PyObject *obj = 0; - if (! PyArg_ParseTuple(args, "|O!", &SVertex_Type, &obj) ) - return -1; + if (!PyArg_ParseTuple(args, "|O!", &SVertex_Type, &obj)) + return -1; - if( !obj ){ + if (!obj) { self->ntv = new NonTVertex(); - } else if( ((BPy_SVertex *) obj)->sv ) { - self->ntv = new NonTVertex( ((BPy_SVertex *) obj)->sv ); + } else if(((BPy_SVertex *)obj)->sv) { + self->ntv = new NonTVertex(((BPy_SVertex *)obj)->sv); } else { PyErr_SetString(PyExc_TypeError, "invalid argument"); @@ -61,47 +60,38 @@ static int NonTVertex___init__(BPy_NonTVertex *self, PyObject *args, PyObject *k return 0; } -static char NonTVertex_svertex___doc__[] = -".. method:: svertex()\n" -"\n" -" Returns the SVertex on top of which this NonTVertex is built.\n" +static PyMethodDef BPy_NonTVertex_methods[] = { + {NULL, NULL, 0, NULL} +}; + +/*----------------------NonTVertex get/setters ----------------------------*/ + +PyDoc_STRVAR(NonTVertex_svertex_doc, +"The SVertex on top of which this NonTVertex is built.\n" "\n" -" :return: The SVertex on top of which this NonTVertex is built.\n" -" :rtype: :class:`SVertex`\n"; +":type: :class:`SVertex`"); -static PyObject * NonTVertex_svertex( BPy_NonTVertex *self ) { +static PyObject *NonTVertex_svertex_get(BPy_NonTVertex *self, void *UNUSED(closure)) +{ SVertex *v = self->ntv->svertex(); - if( v ){ - return BPy_SVertex_from_SVertex( *v ); - } - + if (v) + return BPy_SVertex_from_SVertex(*v); Py_RETURN_NONE; } -static char NonTVertex_setSVertex___doc__[] = -".. method:: setSVertex(iSVertex)\n" -"\n" -" Sets the SVertex on top of which this NonTVertex is built.\n" -"\n" -" :arg iSVertex: The SVertex on top of which this NonTVertex is built.\n" -" :type iSVertex: :class:`SVertex`\n"; - -static PyObject * NonTVertex_setSVertex( BPy_NonTVertex *self, PyObject *args) { - PyObject *py_sv; - - if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) )) - return NULL; - - self->ntv->setSVertex( ((BPy_SVertex *) py_sv)->sv ); - - Py_RETURN_NONE; +static int NonTVertex_svertex_set(BPy_NonTVertex *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->ntv->setSVertex(((BPy_SVertex *)value)->sv); + return 0; } -/*----------------------NonTVertex instance definitions ----------------------------*/ -static PyMethodDef BPy_NonTVertex_methods[] = { - {"svertex", ( PyCFunction ) NonTVertex_svertex, METH_NOARGS, NonTVertex_svertex___doc__}, - {"setSVertex", ( PyCFunction ) NonTVertex_setSVertex, METH_VARARGS, NonTVertex_setSVertex___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_NonTVertex_getseters[] = { + {(char *)"svertex", (getter)NonTVertex_svertex_get, (setter)NonTVertex_svertex_set, (char *)NonTVertex_svertex_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_NonTVertex type definition ------------------------------*/ @@ -126,7 +116,7 @@ PyTypeObject NonTVertex_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - NonTVertex___doc__, /* tp_doc */ + NonTVertex_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -135,13 +125,13 @@ PyTypeObject NonTVertex_Type = { 0, /* tp_iternext */ BPy_NonTVertex_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_NonTVertex_getseters, /* tp_getset */ &ViewVertex_Type, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)NonTVertex___init__, /* tp_init */ + (initproc)NonTVertex_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; 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 */ }; diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp index a7b710f796b..be3d97f5f78 100644 --- a/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp +++ b/source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp @@ -12,9 +12,9 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// -//------------------------INSTANCE METHODS ---------------------------------- - -static char FEdge___doc__[] = +/*----------------------FEdge methods ----------------------------*/ + +PyDoc_STRVAR(FEdge_doc, "Class hierarchy: :class:`Interface1D` > :class:`FEdge`\n" "\n" "Base Class for feature edges. This FEdge can represent a silhouette,\n" @@ -45,23 +45,23 @@ static char FEdge___doc__[] = " :arg vA: The first SVertex.\n" " :type vA: :class:`SVertex`\n" " :arg vB: The second SVertex.\n" -" :type vB: :class:`SVertex`\n"; +" :type vB: :class:`SVertex`"); -static int FEdge___init__(BPy_FEdge *self, PyObject *args, PyObject *kwds) +static int FEdge_init(BPy_FEdge *self, PyObject *args, PyObject *kwds) { PyObject *obj1 = 0, *obj2 = 0; - if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) ) - return -1; + if (!PyArg_ParseTuple(args, "|OO", &obj1, &obj2)) + return -1; - if( !obj1 ){ + if (!obj1) { self->fe = new FEdge(); - } else if( !obj2 && BPy_FEdge_Check(obj1) ) { - self->fe = new FEdge(*( ((BPy_FEdge *) obj1)->fe )); - - } else if( obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) { - self->fe = new FEdge( ((BPy_SVertex *) obj1)->sv, ((BPy_SVertex *) obj2)->sv ); + } else if(!obj2 && BPy_FEdge_Check(obj1)) { + self->fe = new FEdge(*(((BPy_FEdge *)obj1)->fe)); + + } else if(obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2)) { + self->fe = new FEdge(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv); } else { PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); @@ -74,296 +74,234 @@ static int FEdge___init__(BPy_FEdge *self, PyObject *args, PyObject *kwds) return 0; } -static char FEdge_vertexA___doc__[] = -".. method:: vertexA()\n" -"\n" -" Returns the first SVertex.\n" -"\n" -" :return: The first SVertex.\n" -" :rtype: :class:`SVertex`\n"; +static PyMethodDef BPy_FEdge_methods[] = { + {NULL, NULL, 0, NULL} +}; -static PyObject * FEdge_vertexA( BPy_FEdge *self ) { - SVertex *A = self->fe->vertexA(); - if( A ){ - return BPy_SVertex_from_SVertex( *A ); - } - - Py_RETURN_NONE; -} +/*----------------------FEdge sequence protocol ----------------------------*/ -static char FEdge_vertexB___doc__[] = -".. method:: vertexB()\n" -"\n" -" Returns the second SVertex.\n" -"\n" -" :return: The second SVertex.\n" -" :rtype: :class:`SVertex`\n"; +static Py_ssize_t FEdge_sq_length(BPy_FEdge *self) +{ + return 2; +} -static PyObject * FEdge_vertexB( BPy_FEdge *self ) { - SVertex *B = self->fe->vertexB(); - if( B ){ - return BPy_SVertex_from_SVertex( *B ); +static PyObject *FEdge_sq_item(BPy_FEdge *self, int keynum) +{ + if (keynum < 0) + keynum += FEdge_sq_length(self); + if (keynum == 0 || keynum == 1) { + SVertex *v = self->fe->operator[](keynum); + if (v) + return BPy_SVertex_from_SVertex(*v); + Py_RETURN_NONE; } - - Py_RETURN_NONE; + PyErr_Format(PyExc_IndexError, "FEdge[index]: index %d out of range", keynum); + return NULL; } +static PySequenceMethods BPy_FEdge_as_sequence = { + (lenfunc)FEdge_sq_length, /* sq_length */ + NULL, /* sq_concat */ + NULL, /* sq_repeat */ + (ssizeargfunc)FEdge_sq_item, /* sq_item */ + NULL, /* sq_slice */ + NULL, /* sq_ass_item */ + NULL, /* *was* sq_ass_slice */ + NULL, /* sq_contains */ + NULL, /* sq_inplace_concat */ + NULL, /* sq_inplace_repeat */ +}; -static PyObject * FEdge___getitem__( BPy_FEdge *self, PyObject *args ) { - int i; - - if(!( PyArg_ParseTuple(args, "i", &i) )) - return NULL; - if(!(i == 0 || i == 1)) { - PyErr_SetString(PyExc_IndexError, "index must be either 0 or 1"); - return NULL; - } - - SVertex *v = self->fe->operator[](i); - if( v ) - return BPy_SVertex_from_SVertex( *v ); - - Py_RETURN_NONE; -} +/*----------------------FEdge get/setters ----------------------------*/ -static char FEdge_nextEdge___doc__[] = -".. method:: nextEdge()\n" +PyDoc_STRVAR(FEdge_first_svertex_doc, +"The first SVertex constituting this FEdge.\n" "\n" -" Returns the FEdge following this one in the ViewEdge. If this FEdge\n" -" is the last of the ViewEdge, None is returned.\n" -"\n" -" :return: The edge following this one in the ViewEdge.\n" -" :rtype: :class:`FEdge`\n"; - -static PyObject * FEdge_nextEdge( BPy_FEdge *self ) { - FEdge *fe = self->fe->nextEdge(); - if( fe ) - return Any_BPy_FEdge_from_FEdge( *fe ); +":type: :class:`SVertex`"); +static PyObject *FEdge_first_svertex_get(BPy_FEdge *self, void *UNUSED(closure)) +{ + SVertex *A = self->fe->vertexA(); + if (A) + return BPy_SVertex_from_SVertex(*A); Py_RETURN_NONE; } -static char FEdge_previousEdge___doc__[] = -".. method:: previousEdge()\n" -"\n" -" Returns the FEdge preceding this one in the ViewEdge. If this FEdge\n" -" is the first one of the ViewEdge, None is returned.\n" -"\n" -" :return: The edge preceding this one in the ViewEdge.\n" -" :rtype: :class:`FEdge`\n"; - -static PyObject * FEdge_previousEdge( BPy_FEdge *self ) { - FEdge *fe = self->fe->previousEdge(); - if( fe ) - return Any_BPy_FEdge_from_FEdge( *fe ); - - Py_RETURN_NONE; +static int FEdge_first_svertex_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->fe->setVertexA(((BPy_SVertex *)value)->sv); + return 0; } -static char FEdge_viewedge___doc__[] = -".. method:: viewedge()\n" -"\n" -" Returns the ViewEdge to which this FEdge belongs to.\n" +PyDoc_STRVAR(FEdge_second_svertex_doc, +"The second SVertex constituting this FEdge.\n" "\n" -" :return: The ViewEdge to which this FEdge belongs to.\n" -" :rtype: :class:`ViewEdge`\n"; - -static PyObject * FEdge_viewedge( BPy_FEdge *self ) { - ViewEdge *ve = self->fe->viewedge(); - if( ve ) - return BPy_ViewEdge_from_ViewEdge( *ve ); +":type: :class:`SVertex`"); +static PyObject *FEdge_second_svertex_get(BPy_FEdge *self, void *UNUSED(closure)) +{ + SVertex *B = self->fe->vertexB(); + if (B) + return BPy_SVertex_from_SVertex(*B); Py_RETURN_NONE; } -static char FEdge_isSmooth___doc__[] = -".. method:: isSmooth()\n" -"\n" -" Returns true if this FEdge is a smooth FEdge.\n" -"\n" -" :return: True if this FEdge is a smooth FEdge.\n" -" :rtype: bool\n"; - -static PyObject * FEdge_isSmooth( BPy_FEdge *self ) { - return PyBool_from_bool( self->fe->isSmooth() ); +static int FEdge_second_svertex_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_SVertex_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an SVertex"); + return -1; + } + self->fe->setVertexB(((BPy_SVertex *)value)->sv); + return 0; } - -static char FEdge_setVertexA___doc__[] = -".. method:: setVertexA(vA)\n" -"\n" -" Sets the first SVertex.\n" -"\n" -" :arg vA: An SVertex object.\n" -" :type vA: :class:`SVertex`\n"; - -static PyObject *FEdge_setVertexA( BPy_FEdge *self , PyObject *args) { - PyObject *py_sv; - if(!( PyArg_ParseTuple(args, "O!", &SVertex_Type, &py_sv) )) - return NULL; - - self->fe->setVertexA( ((BPy_SVertex *) py_sv)->sv ); +PyDoc_STRVAR(FEdge_next_fedge_doc, +"The FEdge following this one in the ViewEdge. The value is None if\n" +"this FEdge is the last of the ViewEdge.\n" +"\n" +":type: :class:`FEdge`"); +static PyObject *FEdge_next_fedge_get(BPy_FEdge *self, void *UNUSED(closure)) +{ + FEdge *fe = self->fe->nextEdge(); + if (fe) + return Any_BPy_FEdge_from_FEdge(*fe); Py_RETURN_NONE; } -static char FEdge_setVertexB___doc__[] = -".. method:: setVertexB(vB)\n" -"\n" -" Sets the second SVertex.\n" -"\n" -" :arg vB: An SVertex object.\n" -" :type vB: :class:`SVertex`\n"; - -static PyObject *FEdge_setVertexB( BPy_FEdge *self , PyObject *args) { - PyObject *py_sv; - - if(!( PyArg_ParseTuple(args, "O", &py_sv) && BPy_SVertex_Check(py_sv) )) { - cout << "ERROR: FEdge_setVertexB" << endl; - Py_RETURN_NONE; +static int FEdge_next_fedge_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_FEdge_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an FEdge"); + return -1; } - - self->fe->setVertexB( ((BPy_SVertex *) py_sv)->sv ); - - Py_RETURN_NONE; + self->fe->setNextEdge(((BPy_FEdge *)value)->fe); + return 0; } -static char FEdge_setId___doc__[] = -".. method:: setId(id)\n" -"\n" -" Sets the Id of this FEdge.\n" +PyDoc_STRVAR(FEdge_previous_fedge_doc, +"The FEdge preceding this one in the ViewEdge. The value is None if\n" +"this FEdge is the first one of the ViewEdge.\n" "\n" -" :arg id: An Id object.\n" -" :type id: :class:`Id`\n"; - -static PyObject *FEdge_setId( BPy_FEdge *self , PyObject *args) { - PyObject *py_id; - - if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) )) - return NULL; - - self->fe->setId(*( ((BPy_Id *) py_id)->id )); +":type: :class:`FEdge`"); +static PyObject *FEdge_previous_fedge_get(BPy_FEdge *self, void *UNUSED(closure)) +{ + FEdge *fe = self->fe->previousEdge(); + if (fe) + return Any_BPy_FEdge_from_FEdge(*fe); Py_RETURN_NONE; } -static char FEdge_setNextEdge___doc__[] = -".. method:: setNextEdge(iEdge)\n" -"\n" -" Sets the pointer to the next FEdge.\n" -"\n" -" :arg iEdge: An FEdge object.\n" -" :type iEdge: :class:`FEdge`\n"; - -static PyObject *FEdge_setNextEdge( BPy_FEdge *self , PyObject *args) { - PyObject *py_fe; - - if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) )) - return NULL; - - self->fe->setNextEdge( ((BPy_FEdge *) py_fe)->fe ); - - Py_RETURN_NONE; +static int FEdge_previous_fedge_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_FEdge_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an FEdge"); + return -1; + } + self->fe->setPreviousEdge(((BPy_FEdge *)value)->fe); + return 0; } -static char FEdge_setPreviousEdge___doc__[] = -".. method:: setPreviousEdge(iEdge)\n" +PyDoc_STRVAR(FEdge_viewedge_doc, +"The ViewEdge to which this FEdge belongs to.\n" "\n" -" Sets the pointer to the previous FEdge.\n" -"\n" -" :arg iEdge: An FEdge object.\n" -" :type iEdge: :class:`FEdge`\n"; - -static PyObject *FEdge_setPreviousEdge( BPy_FEdge *self , PyObject *args) { - PyObject *py_fe; - - if(!( PyArg_ParseTuple(args, "O!", &FEdge_Type, &py_fe) )) - return NULL; - - self->fe->setPreviousEdge( ((BPy_FEdge *) py_fe)->fe ); +":type: :class:`ViewEdge`"); +static PyObject *FEdge_viewedge_get(BPy_FEdge *self, void *UNUSED(closure)) +{ + ViewEdge *ve = self->fe->viewedge(); + if (ve) + return BPy_ViewEdge_from_ViewEdge(*ve); Py_RETURN_NONE; } -static char FEdge_setNature___doc__[] = -".. method:: setNature(iNature)\n" -"\n" -" Sets the nature of this FEdge.\n" -"\n" -" :arg iNature: A Nature object.\n" -" :type iNature: :class:`Nature`\n"; +static int FEdge_viewedge_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_ViewEdge_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an ViewEdge"); + return -1; + } + self->fe->setViewEdge(((BPy_ViewEdge *)value)->ve); + return 0; +} -static PyObject * FEdge_setNature( BPy_FEdge *self, PyObject *args ) { - PyObject *py_n; +PyDoc_STRVAR(FEdge_is_smooth_doc, +"True if this FEdge is a smooth FEdge.\n" +"\n" +":type: bool"); - if(!( PyArg_ParseTuple(args, "O!", &Nature_Type, &py_n) )) - return NULL; - - PyObject *i = (PyObject *) &( ((BPy_Nature *) py_n)->i ); - self->fe->setNature( PyLong_AsLong(i) ); +static PyObject *FEdge_is_smooth_get(BPy_FEdge *self, void *UNUSED(closure)) +{ + return PyBool_from_bool(self->fe->isSmooth()); +} - Py_RETURN_NONE; +static int FEdge_is_smooth_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure)) +{ + if (!PyBool_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be boolean"); + return -1; + } + self->fe->setSmooth(bool_from_PyBool(value)); + return 0; } -static char FEdge_setViewEdge___doc__[] = -".. method:: setViewEdge(iViewEdge)\n" -"\n" -" Sets the ViewEdge to which this FEdge belongs to.\n" +PyDoc_STRVAR(FEdge_id_doc, +"The Id of this FEdge.\n" "\n" -" :arg iViewEdge: A ViewEdge object.\n" -" :type iViewEdge: :class:`ViewEdge`\n"; +":type: :class:`Id`"); -static PyObject * FEdge_setViewEdge( BPy_FEdge *self, PyObject *args ) { - PyObject *py_ve; - - if(!( PyArg_ParseTuple(args, "O!", &ViewEdge_Type, &py_ve) )) - return NULL; - - ViewEdge *ve = ((BPy_ViewEdge *) py_ve)->ve; - self->fe->setViewEdge( ve ); +static PyObject *FEdge_id_get(BPy_FEdge *self, void *UNUSED(closure)) +{ + Id id(self->fe->getId()); + return BPy_Id_from_Id(id); // return a copy +} - Py_RETURN_NONE; +static int FEdge_id_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_Id_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an Id"); + return -1; + } + self->fe->setId(*(((BPy_Id *)value)->id)); + return 0; } -static char FEdge_setSmooth___doc__[] = -".. method:: setSmooth(iFlag)\n" -"\n" -" Sets the flag telling whether this FEdge is smooth or sharp. True\n" -" for Smooth, false for Sharp.\n" +PyDoc_STRVAR(FEdge_nature_doc, +"The nature of this FEdge.\n" "\n" -" :arg iFlag: True for Smooth, false for Sharp.\n" -" :type iFlag: bool\n"; - -static PyObject *FEdge_setSmooth( BPy_FEdge *self , PyObject *args) { - PyObject *py_b; - - if(!( PyArg_ParseTuple(args, "O", &py_b) )) - return NULL; +":type: :class:`Nature`"); - self->fe->setSmooth( bool_from_PyBool(py_b) ); +static PyObject *FEdge_nature_get(BPy_FEdge *self, void *UNUSED(closure)) +{ + return BPy_Nature_from_Nature(self->fe->getNature()); +} - Py_RETURN_NONE; +static int FEdge_nature_set(BPy_FEdge *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_Nature_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be a Nature"); + return -1; + } + self->fe->setNature(PyLong_AsLong((PyObject *)&((BPy_Nature *)value)->i)); + return 0; } -/*----------------------FEdge instance definitions ----------------------------*/ - -static PyMethodDef BPy_FEdge_methods[] = { - {"vertexA", ( PyCFunction ) FEdge_vertexA, METH_NOARGS, FEdge_vertexA___doc__}, - {"vertexB", ( PyCFunction ) FEdge_vertexB, METH_NOARGS, FEdge_vertexB___doc__}, - {"__getitem__", ( PyCFunction ) FEdge___getitem__, METH_VARARGS, "(int i) Returns the first SVertex if i=0, the seccond SVertex if i=1."}, - {"nextEdge", ( PyCFunction ) FEdge_nextEdge, METH_NOARGS, FEdge_nextEdge___doc__}, - {"previousEdge", ( PyCFunction ) FEdge_previousEdge, METH_NOARGS, FEdge_previousEdge___doc__}, - {"viewedge", ( PyCFunction ) FEdge_viewedge, METH_NOARGS, FEdge_viewedge___doc__}, - {"isSmooth", ( PyCFunction ) FEdge_isSmooth, METH_NOARGS, FEdge_isSmooth___doc__}, - {"setVertexA", ( PyCFunction ) FEdge_setVertexA, METH_VARARGS, FEdge_setVertexA___doc__}, - {"setVertexB", ( PyCFunction ) FEdge_setVertexB, METH_VARARGS, FEdge_setVertexB___doc__}, - {"setId", ( PyCFunction ) FEdge_setId, METH_VARARGS, FEdge_setId___doc__}, - {"setNextEdge", ( PyCFunction ) FEdge_setNextEdge, METH_VARARGS, FEdge_setNextEdge___doc__}, - {"setPreviousEdge", ( PyCFunction ) FEdge_setPreviousEdge, METH_VARARGS, FEdge_setPreviousEdge___doc__}, - {"setSmooth", ( PyCFunction ) FEdge_setSmooth, METH_VARARGS, FEdge_setSmooth___doc__}, - {"setViewEdge", ( PyCFunction ) FEdge_setViewEdge, METH_VARARGS, FEdge_setViewEdge___doc__}, - {"setNature", ( PyCFunction ) FEdge_setNature, METH_VARARGS, FEdge_setNature___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_FEdge_getseters[] = { + {(char *)"first_svertex", (getter)FEdge_first_svertex_get, (setter)FEdge_first_svertex_set, (char *)FEdge_first_svertex_doc, NULL}, + {(char *)"second_svertex", (getter)FEdge_second_svertex_get, (setter)FEdge_second_svertex_set, (char *)FEdge_second_svertex_doc, NULL}, + {(char *)"next_fedge", (getter)FEdge_next_fedge_get, (setter)FEdge_next_fedge_set, (char *)FEdge_next_fedge_doc, NULL}, + {(char *)"previous_fedge", (getter)FEdge_previous_fedge_get, (setter)FEdge_previous_fedge_set, (char *)FEdge_previous_fedge_doc, NULL}, + {(char *)"viewedge", (getter)FEdge_viewedge_get, (setter)FEdge_viewedge_set, (char *)FEdge_viewedge_doc, NULL}, + {(char *)"is_smooth", (getter)FEdge_is_smooth_get, (setter)FEdge_is_smooth_set, (char *)FEdge_is_smooth_doc, NULL}, + {(char *)"id", (getter)FEdge_id_get, (setter)FEdge_id_set, (char *)FEdge_id_doc, NULL}, + {(char *)"nature", (getter)FEdge_nature_get, (setter)FEdge_nature_set, (char *)FEdge_nature_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_FEdge type definition ------------------------------*/ @@ -380,7 +318,7 @@ PyTypeObject FEdge_Type = { 0, /* tp_reserved */ 0, /* tp_repr */ 0, /* tp_as_number */ - 0, /* tp_as_sequence */ + &BPy_FEdge_as_sequence, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ @@ -389,7 +327,7 @@ PyTypeObject FEdge_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - FEdge___doc__, /* tp_doc */ + FEdge_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -398,13 +336,13 @@ PyTypeObject FEdge_Type = { 0, /* tp_iternext */ BPy_FEdge_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_FEdge_getseters, /* tp_getset */ &Interface1D_Type, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)FEdge___init__, /* tp_init */ + (initproc)FEdge_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp index 5b20db3a267..e5b984e41bd 100644 --- a/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp +++ b/source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp @@ -11,9 +11,9 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------CurvePoint methods ----------------------------*/ -static char FrsCurve___doc__[] = +PyDoc_STRVAR(FrsCurve_doc, "Class hierarchy: :class:`Interface1D` > :class:`Curve`\n" "\n" "Base class for curves made of CurvePoints. :class:`SVertex` is the\n" @@ -36,25 +36,25 @@ static char FrsCurve___doc__[] = " Builds a Curve from its Id.\n" "\n" " :arg iId: An Id object.\n" -" :type iId: :class:`Id`\n"; +" :type iId: :class:`Id`"); -static int FrsCurve___init__(BPy_FrsCurve *self, PyObject *args, PyObject *kwds) +static int FrsCurve_init(BPy_FrsCurve *self, PyObject *args, PyObject *kwds) { PyObject *obj = 0; - if (! PyArg_ParseTuple(args, "|O", &obj) ) - return -1; + if (!PyArg_ParseTuple(args, "|O", &obj)) + return -1; - if( !obj ){ + if (!obj) { self->c = new Curve(); - - } else if( BPy_FrsCurve_Check(obj) ) { + + } else if (BPy_FrsCurve_Check(obj)) { self->c = new Curve(*( ((BPy_FrsCurve *) obj)->c )); - - } else if( BPy_Id_Check(obj) ) { + + } else if (BPy_Id_Check(obj)) { self->c = new Curve(*( ((BPy_Id *) obj)->id )); - + } else { PyErr_SetString(PyExc_TypeError, "invalid argument"); return -1; @@ -66,24 +66,25 @@ static int FrsCurve___init__(BPy_FrsCurve *self, PyObject *args, PyObject *kwds) return 0; } -static char FrsCurve_push_vertex_back___doc__[] = +PyDoc_STRVAR(FrsCurve_push_vertex_back_doc, ".. method:: push_vertex_back(iVertex)\n" "\n" " Adds a single vertex at the end of the Curve.\n" "\n" " :arg iVertex: A vertex object.\n" -" :type iVertex: :class:`SVertex` or :class:`CurvePoint`\n"; +" :type iVertex: :class:`SVertex` or :class:`CurvePoint`"); -static PyObject * FrsCurve_push_vertex_back( BPy_FrsCurve *self, PyObject *args ) { +static PyObject * FrsCurve_push_vertex_back( BPy_FrsCurve *self, PyObject *args ) +{ PyObject *obj; - if(!( PyArg_ParseTuple(args, "O", &obj) )) + if (!PyArg_ParseTuple(args, "O", &obj)) return NULL; - if( BPy_CurvePoint_Check(obj) ) { - self->c->push_vertex_back( ((BPy_CurvePoint *) obj)->cp ); - } else if( BPy_SVertex_Check(obj) ) { - self->c->push_vertex_back( ((BPy_SVertex *) obj)->sv ); + if (BPy_CurvePoint_Check(obj)) { + self->c->push_vertex_back(((BPy_CurvePoint *)obj)->cp); + } else if (BPy_SVertex_Check(obj)) { + self->c->push_vertex_back(((BPy_SVertex *)obj)->sv); } else { PyErr_SetString(PyExc_TypeError, "invalid argument"); return NULL; @@ -92,24 +93,25 @@ static PyObject * FrsCurve_push_vertex_back( BPy_FrsCurve *self, PyObject *args Py_RETURN_NONE; } -static char FrsCurve_push_vertex_front___doc__[] = +PyDoc_STRVAR(FrsCurve_push_vertex_front_doc, ".. method:: push_vertex_front(iVertex)\n" "\n" " Adds a single vertex at the front of the Curve.\n" "\n" " :arg iVertex: A vertex object.\n" -" :type iVertex: :class:`SVertex` or :class:`CurvePoint`\n"; +" :type iVertex: :class:`SVertex` or :class:`CurvePoint`"); -static PyObject * FrsCurve_push_vertex_front( BPy_FrsCurve *self, PyObject *args ) { +static PyObject * FrsCurve_push_vertex_front( BPy_FrsCurve *self, PyObject *args ) +{ PyObject *obj; - if(!( PyArg_ParseTuple(args, "O", &obj) )) + if (!PyArg_ParseTuple(args, "O", &obj)) return NULL; - if( BPy_CurvePoint_Check(obj) ) { - self->c->push_vertex_front( ((BPy_CurvePoint *) obj)->cp ); - } else if( BPy_SVertex_Check(obj) ) { - self->c->push_vertex_front( ((BPy_SVertex *) obj)->sv ); + if (BPy_CurvePoint_Check(obj)) { + self->c->push_vertex_front(((BPy_CurvePoint *)obj)->cp); + } else if( BPy_SVertex_Check(obj)) { + self->c->push_vertex_front(((BPy_SVertex *)obj)->sv); } else { PyErr_SetString(PyExc_TypeError, "invalid argument"); return NULL; @@ -118,38 +120,38 @@ static PyObject * FrsCurve_push_vertex_front( BPy_FrsCurve *self, PyObject *args Py_RETURN_NONE; } -static char FrsCurve_empty___doc__[] = -".. method:: empty()\n" -"\n" -" Returns true if the Curve doesn't have any Vertex yet.\n" +static PyMethodDef BPy_FrsCurve_methods[] = { + {"push_vertex_back", (PyCFunction)FrsCurve_push_vertex_back, METH_VARARGS, FrsCurve_push_vertex_back_doc}, + {"push_vertex_front", (PyCFunction)FrsCurve_push_vertex_front, METH_VARARGS, FrsCurve_push_vertex_front_doc}, + {NULL, NULL, 0, NULL} +}; + +/*----------------------CurvePoint get/setters ----------------------------*/ + +PyDoc_STRVAR(FrsCurve_is_empty_doc, +"True if the Curve doesn't have any Vertex yet.\n" "\n" -" :return: True if the Curve has no vertices.\n" -" :rtype: bool\n"; +":type: bool"); -static PyObject * FrsCurve_empty( BPy_FrsCurve *self ) { - return PyBool_from_bool( self->c->empty() ); +static PyObject *FrsCurve_is_empty_get(BPy_FrsCurve *self, void *UNUSED(closure)) +{ + return PyBool_from_bool(self->c->empty()); } -static char FrsCurve_nSegments___doc__[] = -".. method:: nSegments()\n" +PyDoc_STRVAR(FrsCurve_segments_size_doc, +"The number of segments in the polyline constituing the Curve.\n" "\n" -" Returns the number of segments in the polyline constituing the\n" -" Curve.\n" -"\n" -" :return: The number of segments.\n" -" :rtype: int\n"; +":type: int"); -static PyObject * FrsCurve_nSegments( BPy_FrsCurve *self ) { - return PyLong_FromLong( self->c->nSegments() ); +static PyObject *FrsCurve_segments_size_get(BPy_FrsCurve *self, void *UNUSED(closure)) +{ + return PyLong_FromLong(self->c->nSegments()); } -/*----------------------FrsCurve instance definitions ----------------------------*/ -static PyMethodDef BPy_FrsCurve_methods[] = { - {"push_vertex_back", ( PyCFunction ) FrsCurve_push_vertex_back, METH_VARARGS, FrsCurve_push_vertex_back___doc__}, - {"push_vertex_front", ( PyCFunction ) FrsCurve_push_vertex_front, METH_VARARGS, FrsCurve_push_vertex_front___doc__}, - {"empty", ( PyCFunction ) FrsCurve_empty, METH_NOARGS, FrsCurve_empty___doc__}, - {"nSegments", ( PyCFunction ) FrsCurve_nSegments, METH_NOARGS, FrsCurve_nSegments___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_FrsCurve_getseters[] = { + {(char *)"is_empty", (getter)FrsCurve_is_empty_get, (setter)NULL, (char *)FrsCurve_is_empty_doc, NULL}, + {(char *)"segments_size", (getter)FrsCurve_segments_size_get, (setter)NULL, (char *)FrsCurve_segments_size_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_FrsCurve type definition ------------------------------*/ @@ -175,7 +177,7 @@ PyTypeObject FrsCurve_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - FrsCurve___doc__, /* tp_doc */ + FrsCurve_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -184,13 +186,13 @@ PyTypeObject FrsCurve_Type = { 0, /* tp_iternext */ BPy_FrsCurve_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_FrsCurve_getseters, /* tp_getset */ &Interface1D_Type, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)FrsCurve___init__, /* tp_init */ + (initproc)FrsCurve_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; diff --git a/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp b/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp index fe215588275..f0cc91b9a79 100644 --- a/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp +++ b/source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp @@ -13,7 +13,7 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------Stroke methods ----------------------------*/ // Stroke () // template<class InputVertexIterator> Stroke (InputVertexIterator iBegin, InputVertexIterator iEnd) @@ -21,7 +21,7 @@ extern "C" { // pb: - need to be able to switch representation: InputVertexIterator <=> position // - is it even used ? not even in SWIG version -static char Stroke___doc__[] = +PyDoc_STRVAR(Stroke_doc, "Class hierarchy: :class:`Interface1D` > :class:`Stroke`\n" "\n" "Class to define a stroke. A stroke is made of a set of 2D vertices\n" @@ -49,25 +49,26 @@ static char Stroke___doc__[] = " :arg iBegin: The iterator pointing to the first vertex.\n" " :type iBegin: InputVertexIterator\n" " :arg iEnd: The iterator pointing to the end of the vertex list.\n" -" :type iEnd: InputVertexIterator\n"; +" :type iEnd: InputVertexIterator"); -static int Stroke___init__(BPy_Stroke *self, PyObject *args, PyObject *kwds) +static int Stroke_init(BPy_Stroke *self, PyObject *args, PyObject *kwds) { PyObject *obj1 = NULL, *obj2 = NULL; - if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) ) - return -1; + if (!PyArg_ParseTuple(args, "|OO", &obj1, &obj2)) + return -1; - if( !obj1 ){ + if (!obj1) { self->s = new Stroke(); - } else if ( !obj2 && BPy_Stroke_Check(obj1) ) { - self->s = new Stroke(*( ((BPy_Stroke *)obj1)->s )); + } else if (!obj2 && BPy_Stroke_Check(obj1)) { + self->s = new Stroke(*(((BPy_Stroke *)obj1)->s)); - } else if ( obj2 ) { + } else if (obj2) { PyErr_SetString(PyExc_TypeError, "Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd) not implemented"); return -1; + } else { PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); return -1; @@ -79,41 +80,30 @@ static int Stroke___init__(BPy_Stroke *self, PyObject *args, PyObject *kwds) return 0; } -static PyObject * Stroke___iter__( PyObject *self ) { +static PyObject * Stroke_iter(PyObject *self) +{ StrokeInternal::StrokeVertexIterator sv_it( ((BPy_Stroke *)self)->s->strokeVerticesBegin() ); return BPy_StrokeVertexIterator_from_StrokeVertexIterator( sv_it, 0 ); } -static Py_ssize_t Stroke_length( BPy_Stroke *self ) { +static Py_ssize_t Stroke_sq_length(BPy_Stroke *self) +{ return self->s->strokeVerticesSize(); } -static PyObject * Stroke_item( BPy_Stroke *self, Py_ssize_t i ) { - if (i < 0 || i >= (Py_ssize_t)self->s->strokeVerticesSize()) { - PyErr_SetString(PyExc_IndexError, "subscript index out of range"); - return NULL; - } - return BPy_StrokeVertex_from_StrokeVertex( self->s->strokeVerticeAt(i) ); -} - -static PyObject * Stroke___getitem__( BPy_Stroke *self, PyObject *item ) { - long i; - - if (!PyLong_Check(item)) { - PyErr_SetString(PyExc_TypeError, "subscript indices must be integers"); - return NULL; - } - i = PyLong_AsLong(item); - if (i == -1 && PyErr_Occurred()) +static PyObject *Stroke_sq_item(BPy_Stroke *self, int keynum) +{ + if (keynum < 0) + keynum += Stroke_sq_length(self); + if (keynum < 0 || keynum >= Stroke_sq_length(self)) { + PyErr_Format(PyExc_IndexError, "Stroke[index]: index %d out of range", keynum); return NULL; - if (i < 0) { - i += self->s->strokeVerticesSize(); } - return Stroke_item(self, i); + return BPy_StrokeVertex_from_StrokeVertex(self->s->strokeVerticeAt(keynum)); } -static char Stroke_ComputeSampling___doc__[] = -".. method:: ComputeSampling(iNVertices)\n" +PyDoc_STRVAR(Stroke_compute_sampling_doc, +".. method:: compute_sampling(iNVertices)\n" "\n" " Compute the sampling needed to get iNVertices vertices. If the\n" " specified number of vertices is less than the actual number of\n" @@ -125,19 +115,19 @@ static char Stroke_ComputeSampling___doc__[] = " :type iNVertices: int\n" " :return: The sampling that must be used in the Resample(float)\n" " method.\n" -" :rtype: float\n"; +" :rtype: float"); -static PyObject * Stroke_ComputeSampling( BPy_Stroke *self, PyObject *args ) { +static PyObject * Stroke_compute_sampling(BPy_Stroke *self, PyObject *args) +{ int i; - if(!( PyArg_ParseTuple(args, "i", &i) )) + if (!PyArg_ParseTuple(args, "i", &i)) return NULL; - - return PyFloat_FromDouble( self->s->ComputeSampling( i ) ); + return PyFloat_FromDouble(self->s->ComputeSampling(i)); } -static char Stroke_Resample___doc__[] = -".. method:: Resample(iNPoints)\n" +PyDoc_STRVAR(Stroke_resample_doc, +".. method:: resample(iNPoints)\n" "\n" " Resamples the stroke so that it eventually has iNPoints. That means\n" " it is going to add iNPoints-vertices_size, if vertices_size is the\n" @@ -147,34 +137,33 @@ static char Stroke_Resample___doc__[] = " :arg iNPoints: The number of vertices we eventually want in our stroke.\n" " :type iNPoints: int\n" "\n" -".. method:: Resample(iSampling)\n" +".. method:: resample(iSampling)\n" "\n" " Resamples the stroke with a given sampling. If the sampling is\n" " smaller than the actual sampling value, no resampling is done.\n" "\n" " :arg iSampling: The new sampling value.\n" -" :type iSampling: float\n"; +" :type iSampling: float"); -static PyObject * Stroke_Resample( BPy_Stroke *self, PyObject *args ) { +static PyObject * Stroke_resample(BPy_Stroke *self, PyObject *args) +{ PyObject *obj; - if(!( PyArg_ParseTuple(args, "O", &obj) )) + if (!PyArg_ParseTuple(args, "O", &obj)) return NULL; - - if( PyLong_Check(obj) ) - self->s->Resample( (int) PyLong_AsLong(obj) ); - else if( PyFloat_Check(obj) ) - self->s->Resample( (float) PyFloat_AsDouble(obj) ); - else { + if (PyLong_Check(obj)) { + self->s->Resample((int)PyLong_AsLong(obj)); + } else if (PyFloat_Check(obj)) { + self->s->Resample((float)PyFloat_AsDouble(obj)); + } else { PyErr_SetString(PyExc_TypeError, "invalid argument"); return NULL; } - Py_RETURN_NONE; } -static char Stroke_InsertVertex___doc__[] = -".. method:: InsertVertex(iVertex, next)\n" +PyDoc_STRVAR(Stroke_insert_vertex_doc, +".. method:: insert_vertex(iVertex, next)\n" "\n" " Inserts the stroke vertex iVertex in the stroke before next. The\n" " length, curvilinear abscissa are updated consequently.\n" @@ -183,290 +172,241 @@ static char Stroke_InsertVertex___doc__[] = " :type iVertex: :class:`StrokeVertex`\n" " :arg next: A StrokeVertexIterator pointing to the StrokeVertex\n" " before which iVertex must be inserted.\n" -" :type next: :class:`StrokeVertexIterator`\n"; +" :type next: :class:`StrokeVertexIterator`"); -static PyObject * Stroke_InsertVertex( BPy_Stroke *self, PyObject *args ) { +static PyObject * Stroke_insert_vertex(BPy_Stroke *self, PyObject *args) +{ PyObject *py_sv = 0, *py_sv_it = 0; - if(!( PyArg_ParseTuple(args, "O!O!", &StrokeVertex_Type, &py_sv, &StrokeVertexIterator_Type, &py_sv_it) )) + if (!PyArg_ParseTuple(args, "O!O!", &StrokeVertex_Type, &py_sv, &StrokeVertexIterator_Type, &py_sv_it)) return NULL; - - StrokeVertex *sv = ((BPy_StrokeVertex *) py_sv)->sv; - StrokeInternal::StrokeVertexIterator sv_it(*( ((BPy_StrokeVertexIterator *) py_sv_it)->sv_it )); - self->s->InsertVertex( sv, sv_it ); - + StrokeVertex *sv = ((BPy_StrokeVertex *)py_sv)->sv; + StrokeInternal::StrokeVertexIterator sv_it(*(((BPy_StrokeVertexIterator *)py_sv_it)->sv_it)); + self->s->InsertVertex(sv, sv_it); Py_RETURN_NONE; } -static char Stroke_RemoveVertex___doc__[] = -".. method:: RemoveVertex(iVertex)\n" +PyDoc_STRVAR(Stroke_remove_vertex_doc, +".. method:: remove_vertex(iVertex)\n" "\n" " Removes the stroke vertex iVertex from the stroke. The length and\n" " curvilinear abscissa are updated consequently.\n" "\n" " :arg iVertex: \n" -" :type iVertex: :class:`StrokeVertex`\n"; +" :type iVertex: :class:`StrokeVertex`"); -static PyObject * Stroke_RemoveVertex( BPy_Stroke *self, PyObject *args ) { +static PyObject * Stroke_remove_vertex( BPy_Stroke *self, PyObject *args ) +{ PyObject *py_sv; - if(!( PyArg_ParseTuple(args, "O!", &StrokeVertex_Type, &py_sv) )) + if (!PyArg_ParseTuple(args, "O!", &StrokeVertex_Type, &py_sv)) return NULL; - - if( ((BPy_StrokeVertex *) py_sv)->sv ) - self->s->RemoveVertex( ((BPy_StrokeVertex *) py_sv)->sv ); - else { + if (((BPy_StrokeVertex *)py_sv)->sv) { + self->s->RemoveVertex(((BPy_StrokeVertex *)py_sv)->sv); + } else { PyErr_SetString(PyExc_TypeError, "invalid argument"); return NULL; } - Py_RETURN_NONE; } -static char Stroke_UpdateLength___doc__[] = -".. method:: UpdateLength()\n" +PyDoc_STRVAR(Stroke_update_length_doc, +".. method:: update_length()\n" "\n" -" Updates the 2D length of the Stroke.\n"; +" Updates the 2D length of the Stroke."); -static PyObject * Stroke_UpdateLength( BPy_Stroke *self ) { +static PyObject * Stroke_update_length(BPy_Stroke *self) +{ self->s->UpdateLength(); - Py_RETURN_NONE; } -static char Stroke_getLength2D___doc__[] = -".. method:: getLength2D()\n" +PyDoc_STRVAR(Stroke_stroke_vertices_begin_doc, +".. method:: stroke_vertices_begin(t=0.0)\n" "\n" -" Returns the 2D length of the Stroke.\n" +" Returns a StrokeVertexIterator pointing on the first StrokeVertex of\n" +" the Stroke. O ne can specify a sampling value to resample the Stroke\n" +" on the fly if needed.\n" "\n" -" :return: the 2D length of the Stroke.\n" -" :rtype: float\n"; - -static PyObject * Stroke_getLength2D( BPy_Stroke *self ) { - return PyFloat_FromDouble( self->s->getLength2D() ); -} +" :arg t: The resampling value with which we want our Stroke to be\n" +" resampled. If 0 is specified, no resampling is done.\n" +" :type t: float\n" +" :return: A StrokeVertexIterator pointing on the first StrokeVertex.\n" +" :rtype: :class:`StrokeVertexIterator`"); -static char Stroke_getMediumType___doc__[] = -".. method:: getMediumType()\n" -"\n" -" Returns the MediumType used for this Stroke.\n" -"\n" -" :return: the MediumType used for this Stroke.\n" -" :rtype: :class:`MediumType`\n"; +static PyObject * Stroke_stroke_vertices_begin( BPy_Stroke *self , PyObject *args) +{ + float f = 0; -static PyObject * Stroke_getMediumType( BPy_Stroke *self ) { - return BPy_MediumType_from_MediumType( self->s->getMediumType() ); + if (!PyArg_ParseTuple(args, "|f", &f)) + return NULL; + StrokeInternal::StrokeVertexIterator sv_it(self->s->strokeVerticesBegin(f)); + return BPy_StrokeVertexIterator_from_StrokeVertexIterator(sv_it, 0); } -static char Stroke_getTextureId___doc__[] = -".. method:: getTextureId()\n" +PyDoc_STRVAR(Stroke_stroke_vertices_end_doc, +".. method:: strokeVerticesEnd()\n" "\n" -" Returns the ID of the texture used to simulate th marks system for\n" -" this Stroke\n" +" Returns a StrokeVertexIterator pointing after the last StrokeVertex\n" +" of the Stroke.\n" "\n" -" :return: The texture ID.\n" -" :rtype: int\n"; +" :return: A StrokeVertexIterator pointing after the last StrokeVertex.\n" +" :rtype: :class:`StrokeVertexIterator`"); -static PyObject * Stroke_getTextureId( BPy_Stroke *self ) { - return PyLong_FromLong( self->s->getTextureId() ); +static PyObject * Stroke_stroke_vertices_end(BPy_Stroke *self) +{ + StrokeInternal::StrokeVertexIterator sv_it(self->s->strokeVerticesEnd()); + return BPy_StrokeVertexIterator_from_StrokeVertexIterator(sv_it, 1); } -static char Stroke_hasTips___doc__[] = -".. method:: hasTips()\n" +PyDoc_STRVAR(Stroke_stroke_vertices_size_doc, +".. method:: stroke_vertices_size()\n" "\n" -" Returns true if this Stroke uses a texture with tips, false\n" -" otherwise.\n" +" Returns the number of StrokeVertex constituing the Stroke.\n" "\n" -" :return: True if this Stroke uses a texture with tips.\n" -" :rtype: bool\n"; +" :return: The number of stroke vertices.\n" +" :rtype: int"); -static PyObject * Stroke_hasTips( BPy_Stroke *self ) { - return PyBool_from_bool( self->s->hasTips() ); +static PyObject * Stroke_stroke_vertices_size(BPy_Stroke *self) +{ + return PyLong_FromLong(self->s->strokeVerticesSize()); } -static char Stroke_setId___doc__[] = -".. method:: setId(id)\n" -"\n" -" Sets the Id of the Stroke.\n" -"\n" -" :arg id: the Id of the Stroke.\n" -" :type id: :class:`Id`\n"; - -static PyObject *Stroke_setId( BPy_Stroke *self , PyObject *args) { - PyObject *py_id; - - if(!( PyArg_ParseTuple(args, "O!", &Id_Type, &py_id) )) - return NULL; - - self->s->setId(*( ((BPy_Id *) py_id)->id )); +static PyMethodDef BPy_Stroke_methods[] = { + {"compute_sampling", (PyCFunction)Stroke_compute_sampling, METH_VARARGS, Stroke_compute_sampling_doc}, + {"resample", (PyCFunction)Stroke_resample, METH_VARARGS, Stroke_resample_doc}, + {"remove_vertex", (PyCFunction)Stroke_remove_vertex, METH_VARARGS, Stroke_remove_vertex_doc}, + {"insert_vertex", (PyCFunction)Stroke_insert_vertex, METH_VARARGS, Stroke_insert_vertex_doc}, + {"update_length", (PyCFunction)Stroke_update_length, METH_NOARGS, Stroke_update_length_doc}, + {"stroke_vertices_begin", (PyCFunction)Stroke_stroke_vertices_begin, METH_VARARGS, Stroke_stroke_vertices_begin_doc}, + {"stroke_vertices_end", (PyCFunction)Stroke_stroke_vertices_end, METH_NOARGS, Stroke_stroke_vertices_end_doc}, + {"stroke_vertices_size", (PyCFunction)Stroke_stroke_vertices_size, METH_NOARGS, Stroke_stroke_vertices_size_doc}, + {NULL, NULL, 0, NULL} +}; - Py_RETURN_NONE; -} +/*----------------------Stroke get/setters ----------------------------*/ -static char Stroke_setLength___doc__[] = -".. method:: setLength(iLength)\n" +PyDoc_STRVAR(Stroke_medium_type_doc, +"The MediumType used for this Stroke.\n" "\n" -" Sets the 2D length of the Stroke.\n" -"\n" -" :arg iLength: The 2D length of the Stroke.\n" -" :type iLength: float\n"; - -static PyObject *Stroke_setLength( BPy_Stroke *self , PyObject *args) { - float f; - - if(!( PyArg_ParseTuple(args, "f", &f) )) - return NULL; +":type: :class:`MediumType`"); - self->s->setLength( f ); - - Py_RETURN_NONE; +static PyObject *Stroke_medium_type_get(BPy_Stroke *self, void *UNUSED(closure)) +{ + return BPy_MediumType_from_MediumType(self->s->getMediumType()); } -static char Stroke_setMediumType___doc__[] = -".. method:: setMediumType(iType)\n" -"\n" -" Sets the medium type that must be used for this Stroke.\n" -"\n" -" :arg iType: A MediumType object.\n" -" :type iType: :class:`MediumType`\n"; - -static PyObject *Stroke_setMediumType( BPy_Stroke *self , PyObject *args) { - PyObject *py_mt; - - if(!( PyArg_ParseTuple(args, "O!", &MediumType_Type, &py_mt) )) - return NULL; - - self->s->setMediumType( MediumType_from_BPy_MediumType(py_mt) ); - - Py_RETURN_NONE; +static int Stroke_medium_type_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_MediumType_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be a MediumType"); + return -1; + } + self->s->setMediumType(MediumType_from_BPy_MediumType(value)); + return 0; } -static char Stroke_setTextureId___doc__[] = -".. method:: setTextureId(iId)\n" +PyDoc_STRVAR(Stroke_texture_id_doc, +"The ID of the texture used to simulate th marks system for this Stroke.\n" "\n" -" Sets the texture ID to be used to simulate the marks system for this\n" -" Stroke.\n" -"\n" -" :arg iId: A texture ID.\n" -" :type iId: int\n"; - -static PyObject *Stroke_setTextureId( BPy_Stroke *self , PyObject *args) { - unsigned int i; +":type: int"); - if(!( PyArg_ParseTuple(args, "I", &i) )) - return NULL; - - self->s->setTextureId( i ); +static PyObject *Stroke_texture_id_get(BPy_Stroke *self, void *UNUSED(closure)) +{ + return PyLong_FromLong( self->s->getTextureId() ); +} - Py_RETURN_NONE; +static int Stroke_texture_id_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure)) +{ + unsigned int i = PyLong_AsUnsignedLong(value); + if(PyErr_Occurred()) + return -1; + self->s->setTextureId(i); + return 0; } -static char Stroke_setTips___doc__[] = -".. method:: setTips(iTips)\n" +PyDoc_STRVAR(Stroke_tips_doc, +"True if this Stroke uses a texture with tips, and false otherwise.\n" "\n" -" Sets the flag telling whether this stroke is using a texture with\n" -" tips or not.\n" -"\n" -" :arg iTips: True if this stroke uses a texture with tips.\n" -" :type iTips: bool\n"; - -static PyObject *Stroke_setTips( BPy_Stroke *self , PyObject *args) { - PyObject *py_b; - - if(!( PyArg_ParseTuple(args, "O", &py_b) )) - return NULL; +":type: bool"); - self->s->setTips( bool_from_PyBool(py_b) ); +static PyObject *Stroke_tips_get(BPy_Stroke *self, void *UNUSED(closure)) +{ + return PyBool_from_bool(self->s->hasTips()); +} - Py_RETURN_NONE; +static int Stroke_tips_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure)) +{ + if (!PyBool_Check(value)) + return -1; + self->s->setTips(bool_from_PyBool(value)); + return 0; } -static char Stroke_strokeVerticesBegin___doc__[] = -".. method:: strokeVerticesBegin(t=0.0)\n" +PyDoc_STRVAR(Stroke_length_2d_doc, +"The 2D length of the Stroke.\n" "\n" -" Returns a StrokeVertexIterator pointing on the first StrokeVertex of\n" -" the Stroke. O ne can specify a sampling value to resample the Stroke\n" -" on the fly if needed.\n" -"\n" -" :arg t: The resampling value with which we want our Stroke to be\n" -" resampled. If 0 is specified, no resampling is done.\n" -" :type t: float\n" -" :return: A StrokeVertexIterator pointing on the first StrokeVertex.\n" -" :rtype: :class:`StrokeVertexIterator`\n"; - -static PyObject * Stroke_strokeVerticesBegin( BPy_Stroke *self , PyObject *args) { - float f = 0; +":type: float"); - if(!( PyArg_ParseTuple(args, "|f", &f) )) - return NULL; +static PyObject *Stroke_length_2d_get(BPy_Stroke *self, void *UNUSED(closure)) +{ + return PyFloat_FromDouble(self->s->getLength2D()); +} - StrokeInternal::StrokeVertexIterator sv_it( self->s->strokeVerticesBegin(f) ); - return BPy_StrokeVertexIterator_from_StrokeVertexIterator( sv_it, 0 ); +static int Stroke_length_2d_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure)) +{ + float scalar; + if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ + PyErr_SetString(PyExc_TypeError, "value must be a number"); + return -1; + } + self->s->setLength(scalar); + return 0; } -static char Stroke_strokeVerticesEnd___doc__[] = -".. method:: strokeVerticesEnd()\n" +PyDoc_STRVAR(Stroke_id_doc, +"The Id of this Stroke.\n" "\n" -" Returns a StrokeVertexIterator pointing after the last StrokeVertex\n" -" of the Stroke.\n" -"\n" -" :return: A StrokeVertexIterator pointing after the last StrokeVertex.\n" -" :rtype: :class:`StrokeVertexIterator`\n"; +":type: :class:`Id`"); -static PyObject * Stroke_strokeVerticesEnd( BPy_Stroke *self ) { - StrokeInternal::StrokeVertexIterator sv_it( self->s->strokeVerticesEnd() ); - return BPy_StrokeVertexIterator_from_StrokeVertexIterator( sv_it, 1 ); +static PyObject *Stroke_id_get(BPy_Stroke *self, void *UNUSED(closure)) +{ + Id id(self->s->getId()); + return BPy_Id_from_Id(id); // return a copy } -static char Stroke_strokeVerticesSize___doc__[] = -".. method:: strokeVerticesSize()\n" -"\n" -" Returns the number of StrokeVertex constituing the Stroke.\n" -"\n" -" :return: The number of stroke vertices.\n" -" :rtype: int\n"; - -static PyObject * Stroke_strokeVerticesSize( BPy_Stroke *self ) { - return PyLong_FromLong( self->s->strokeVerticesSize() ); +static int Stroke_id_set(BPy_Stroke *self, PyObject *value, void *UNUSED(closure)) +{ + if (!BPy_Id_Check(value)) { + PyErr_SetString(PyExc_TypeError, "value must be an Id"); + return -1; + } + self->s->setId(*(((BPy_Id *)value)->id)); + return 0; } - -/*----------------------Stroke instance definitions ----------------------------*/ -static PyMethodDef BPy_Stroke_methods[] = { - {"__getitem__", ( PyCFunction ) Stroke___getitem__, METH_O, "(int i) Returns the i-th StrokeVertex constituting the Stroke."}, - {"ComputeSampling", ( PyCFunction ) Stroke_ComputeSampling, METH_VARARGS, Stroke_ComputeSampling___doc__}, - {"Resample", ( PyCFunction ) Stroke_Resample, METH_VARARGS, Stroke_Resample___doc__}, - {"RemoveVertex", ( PyCFunction ) Stroke_RemoveVertex, METH_VARARGS, Stroke_RemoveVertex___doc__}, - {"InsertVertex", ( PyCFunction ) Stroke_InsertVertex, METH_VARARGS, Stroke_InsertVertex___doc__}, - {"UpdateLength", ( PyCFunction ) Stroke_UpdateLength, METH_NOARGS, Stroke_UpdateLength___doc__}, - {"getLength2D", ( PyCFunction ) Stroke_getLength2D, METH_NOARGS, Stroke_getLength2D___doc__}, - {"getMediumType", ( PyCFunction ) Stroke_getMediumType, METH_NOARGS, Stroke_getMediumType___doc__}, - {"getTextureId", ( PyCFunction ) Stroke_getTextureId, METH_NOARGS, Stroke_getTextureId___doc__}, - {"hasTips", ( PyCFunction ) Stroke_hasTips, METH_NOARGS, Stroke_hasTips___doc__}, - {"setId", ( PyCFunction ) Stroke_setId, METH_VARARGS, Stroke_setId___doc__}, - {"setLength", ( PyCFunction ) Stroke_setLength, METH_VARARGS, Stroke_setLength___doc__}, - {"setMediumType", ( PyCFunction ) Stroke_setMediumType, METH_VARARGS, Stroke_setMediumType___doc__}, - {"setTextureId", ( PyCFunction ) Stroke_setTextureId, METH_VARARGS, Stroke_setTextureId___doc__}, - {"setTips", ( PyCFunction ) Stroke_setTips, METH_VARARGS, Stroke_setTips___doc__}, - {"strokeVerticesBegin", ( PyCFunction ) Stroke_strokeVerticesBegin, METH_VARARGS, Stroke_strokeVerticesBegin___doc__}, - {"strokeVerticesEnd", ( PyCFunction ) Stroke_strokeVerticesEnd, METH_NOARGS, Stroke_strokeVerticesEnd___doc__}, - {"strokeVerticesSize", ( PyCFunction ) Stroke_strokeVerticesSize, METH_NOARGS, Stroke_strokeVerticesSize___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_Stroke_getseters[] = { + {(char *)"medium_type", (getter)Stroke_medium_type_get, (setter)Stroke_medium_type_set, (char *)Stroke_medium_type_doc, NULL}, + {(char *)"texture_id", (getter)Stroke_texture_id_get, (setter)Stroke_texture_id_set, (char *)Stroke_texture_id_doc, NULL}, + {(char *)"tips", (getter)Stroke_tips_get, (setter)Stroke_tips_set, (char *)Stroke_tips_doc, NULL}, + {(char *)"length_2d", (getter)Stroke_length_2d_get, (setter)Stroke_length_2d_set, (char *)Stroke_length_2d_doc, NULL}, + {(char *)"id", (getter)Stroke_id_get, (setter)Stroke_id_set, (char *)Stroke_id_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_Stroke type definition ------------------------------*/ -static PySequenceMethods Stroke_as_sequence = { - (lenfunc)Stroke_length, /* sq_length */ - NULL, /* sq_concat */ - NULL, /* sq_repeat */ - (ssizeargfunc)Stroke_item, /* sq_item */ - NULL, /* sq_slice */ - NULL, /* sq_ass_item */ - NULL, /* sq_ass_slice */ - NULL, /* sq_contains */ - NULL, /* sq_inplace_concat */ - NULL, /* sq_inplace_repeat */ +static PySequenceMethods BPy_Stroke_as_sequence = { + (lenfunc)Stroke_sq_length, /* sq_length */ + NULL, /* sq_concat */ + NULL, /* sq_repeat */ + (ssizeargfunc)Stroke_sq_item, /* sq_item */ + NULL, /* sq_slice */ + NULL, /* sq_ass_item */ + NULL, /* *was* sq_ass_slice */ + NULL, /* sq_contains */ + NULL, /* sq_inplace_concat */ + NULL, /* sq_inplace_repeat */ }; PyTypeObject Stroke_Type = { @@ -481,7 +421,7 @@ PyTypeObject Stroke_Type = { 0, /* tp_reserved */ 0, /* tp_repr */ 0, /* tp_as_number */ - &Stroke_as_sequence, /* tp_as_sequence */ + &BPy_Stroke_as_sequence, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ @@ -490,22 +430,22 @@ PyTypeObject Stroke_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - Stroke___doc__, /* tp_doc */ + Stroke_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ - (getiterfunc)Stroke___iter__, /* tp_iter */ + (getiterfunc)Stroke_iter, /* tp_iter */ 0, /* tp_iternext */ BPy_Stroke_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_Stroke_getseters, /* tp_getset */ &Interface1D_Type, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)Stroke___init__, /* tp_init */ + (initproc)Stroke_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; 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", ×tamp) ) - 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 */ }; diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp index 39d644b7714..aef1086a641 100644 --- a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp +++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp @@ -9,9 +9,9 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------FEdgeSharp methods ----------------------------*/ -static char FEdgeSharp___doc__[] = +PyDoc_STRVAR(FEdgeSharp_doc, "Class hierarchy: :class:`Interface1D` > :class:`FEdge` > :class:`FEdgeSharp`\n" "\n" "Class defining a sharp FEdge. A Sharp FEdge corresponds to an initial\n" @@ -39,288 +39,320 @@ static char FEdgeSharp___doc__[] = " :arg vA: The first SVertex object.\n" " :type vA: :class:`SVertex`\n" " :arg vB: The second SVertex object.\n" -" :type vB: :class:`SVertex`\n"; +" :type vB: :class:`SVertex`"); -static int FEdgeSharp___init__(BPy_FEdgeSharp *self, PyObject *args, PyObject *kwds) +static int FEdgeSharp_init(BPy_FEdgeSharp *self, PyObject *args, PyObject *kwds) { PyObject *obj1 = 0, *obj2 = 0; - if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) ) - return -1; + if (!PyArg_ParseTuple(args, "|OO", &obj1, &obj2)) + return -1; - if( !obj1 ){ + if (!obj1) { self->fes = new FEdgeSharp(); - - } else if( !obj2 && BPy_FEdgeSharp_Check(obj1) ) { - self->fes = new FEdgeSharp(*( ((BPy_FEdgeSharp *) obj1)->fes )); - - } else if( obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) { - self->fes = new FEdgeSharp( ((BPy_SVertex *) obj1)->sv, ((BPy_SVertex *) obj2)->sv ); + + } else if (!obj2 && BPy_FEdgeSharp_Check(obj1)) { + self->fes = new FEdgeSharp(*(((BPy_FEdgeSharp *)obj1)->fes)); + + } else if (obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2)) { + self->fes = new FEdgeSharp(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv); } else { PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); return -1; } - self->py_fe.fe = self->fes; self->py_fe.py_if1D.if1D = self->fes; self->py_fe.py_if1D.borrowed = 0; - return 0; } -static char FEdgeSharp_normalA___doc__[] = -".. method:: normalA()\n" -"\n" -" Returns the normal to the face lying on the right of the FEdge. If\n" -" this FEdge is a border, it has no Face on its right and therefore, no\n" -" normal.\n" -"\n" -" :return: The normal to the face lying on the right of the FEdge.\n" -" :rtype: :class:`mathutils.Vector`\n"; +static PyMethodDef BPy_FEdgeSharp_methods[] = { + {NULL, NULL, 0, NULL} +}; -static PyObject * FEdgeSharp_normalA( BPy_FEdgeSharp *self ) { - Vec3r v( self->fes->normalA() ); - return Vector_from_Vec3r( v ); -} +/*----------------------mathutils callbacks ----------------------------*/ -static char FEdgeSharp_normalB___doc__[] = -".. method:: normalB()\n" -"\n" -" Returns the normal to the face lying on the left of the FEdge.\n" -"\n" -" :return: The normal to the face lying on the left of the FEdge.\n" -" :rtype: :class:`mathutils.Vector`\n"; +/* subtype */ +#define MATHUTILS_SUBTYPE_NORMAL_A 1 +#define MATHUTILS_SUBTYPE_NORMAL_B 2 -static PyObject * FEdgeSharp_normalB( BPy_FEdgeSharp *self ) { - Vec3r v( self->fes->normalB() ); - return Vector_from_Vec3r( v ); +static int FEdgeSharp_mathutils_check(BaseMathObject *bmo) +{ + if (!BPy_FEdgeSharp_Check(bmo->cb_user)) + return -1; + return 0; } -static char FEdgeSharp_aMaterialIndex___doc__[] = -".. method:: aMaterialIndex()\n" -"\n" -" Returns the index of the material of the face lying on the right of\n" -" the FEdge. If this FEdge is a border, it has no Face on its right and\n" -" therefore, no material.\n" -"\n" -" :return: The index of the material of the face lying on the right of\n" -" the FEdge.\n" -" :rtype: int\n"; +static int FEdgeSharp_mathutils_get(BaseMathObject *bmo, int subtype) +{ + BPy_FEdgeSharp *self = (BPy_FEdgeSharp *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_NORMAL_A: + { + Vec3r p(self->fes->normalA()); + bmo->data[0] = p[0]; + bmo->data[1] = p[1]; + bmo->data[2] = p[2]; + } + break; + case MATHUTILS_SUBTYPE_NORMAL_B: + { + Vec3r p(self->fes->normalB()); + bmo->data[0] = p[0]; + bmo->data[1] = p[1]; + bmo->data[2] = p[2]; + } + break; + default: + return -1; + } + return 0; +} -static PyObject * FEdgeSharp_aMaterialIndex( BPy_FEdgeSharp *self ) { - return PyLong_FromLong( self->fes->aFrsMaterialIndex() ); +static int FEdgeSharp_mathutils_set(BaseMathObject *bmo, int subtype) +{ + BPy_FEdgeSharp *self = (BPy_FEdgeSharp *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_NORMAL_A: + { + Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]); + self->fes->setNormalA(p); + } + break; + case MATHUTILS_SUBTYPE_NORMAL_B: + { + Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]); + self->fes->setNormalB(p); + } + break; + default: + return -1; + } + return 0; } -static char FEdgeSharp_bMaterialIndex___doc__[] = -".. method:: bMaterialIndex()\n" -"\n" -" Returns the index of the material of the face lying on the left of\n" -" the FEdge.\n" -"\n" -" :return: The index of the material of the face lying on the left of\n" -" the FEdge.\n" -" :rtype: int\n"; +static int FEdgeSharp_mathutils_get_index(BaseMathObject *bmo, int subtype, int index) +{ + BPy_FEdgeSharp *self = (BPy_FEdgeSharp *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_NORMAL_A: + { + Vec3r p(self->fes->normalA()); + bmo->data[index] = p[index]; + } + break; + case MATHUTILS_SUBTYPE_NORMAL_B: + { + Vec3r p(self->fes->normalB()); + bmo->data[index] = p[index]; + } + break; + default: + return -1; + } + return 0; +} -static PyObject * FEdgeSharp_bMaterialIndex( BPy_FEdgeSharp *self ) { - return PyLong_FromLong( self->fes->bFrsMaterialIndex() ); +static int FEdgeSharp_mathutils_set_index(BaseMathObject *bmo, int subtype, int index) +{ + BPy_FEdgeSharp *self = (BPy_FEdgeSharp *)bmo->cb_user; + switch (subtype) { + case MATHUTILS_SUBTYPE_NORMAL_A: + { + Vec3r p(self->fes->normalA()); + p[index] = bmo->data[index]; + self->fes->setNormalA(p); + } + break; + case MATHUTILS_SUBTYPE_NORMAL_B: + { + Vec3r p(self->fes->normalB()); + p[index] = bmo->data[index]; + self->fes->setNormalB(p); + } + break; + default: + return -1; + } + return 0; } -static char FEdgeSharp_aMaterial___doc__[] = -".. method:: aMaterial()\n" -"\n" -" Returns the material of the face lying on the right of the FEdge. If\n" -" this FEdge is a border, it has no Face on its right and therefore, no\n" -" material.\n" -"\n" -" :return: The material of the face lying on the right of the FEdge.\n" -" :rtype: :class:`Material`\n"; +static Mathutils_Callback FEdgeSharp_mathutils_cb = { + FEdgeSharp_mathutils_check, + FEdgeSharp_mathutils_get, + FEdgeSharp_mathutils_set, + FEdgeSharp_mathutils_get_index, + FEdgeSharp_mathutils_set_index +}; -static PyObject * FEdgeSharp_aMaterial( BPy_FEdgeSharp *self ) { - FrsMaterial m( self->fes->aFrsMaterial() ); - return BPy_FrsMaterial_from_FrsMaterial(m); +static unsigned char FEdgeSharp_mathutils_cb_index = -1; + +void FEdgeSharp_mathutils_register_callback() +{ + FEdgeSharp_mathutils_cb_index = Mathutils_RegisterCallback(&FEdgeSharp_mathutils_cb); } -static char FEdgeSharp_bMaterial___doc__[] = -".. method:: bMaterial()\n" -"\n" -" Returns the material of the face lying on the left of the FEdge.\n" +/*----------------------FEdgeSharp get/setters ----------------------------*/ + +PyDoc_STRVAR(FEdgeSharp_normal_right_doc, +"The normal to the face lying on the right of the FEdge. If this FEdge\n" +"is a border, it has no Face on its right and therefore no normal.\n" "\n" -" :return: The material of the face lying on the left of the FEdge.\n" -" :rtype: :class:`Material`\n"; +":type: :class:`mathutils.Vector`"); -static PyObject * FEdgeSharp_bMaterial( BPy_FEdgeSharp *self ) { - FrsMaterial m( self->fes->aFrsMaterial() ); - return BPy_FrsMaterial_from_FrsMaterial(m); +static PyObject *FEdgeSharp_normal_right_get(BPy_FEdgeSharp *self, void *UNUSED(closure)) +{ + return Vector_CreatePyObject_cb((PyObject *)self, 3, FEdgeSharp_mathutils_cb_index, MATHUTILS_SUBTYPE_NORMAL_A); } -static char FEdgeSharp_aFaceMark___doc__[] = -".. method:: aFaceMark()\n" -"\n" -" Returns the face mark of the face lying on the right of the FEdge.\n" -" If this FEdge is a border, it has no face on the right, and thus\n" -" false is returned.\n" -"\n" -" :return: The face mark of the face lying on the right of the FEdge.\n" -" :rtype: bool\n"; - -static PyObject * FEdgeSharp_aFaceMark( BPy_FEdgeSharp *self ) { - return PyBool_from_bool( self->fes->aFaceMark() ); +static int FEdgeSharp_normal_right_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure)) +{ + float v[3]; + if (!float_array_from_PyObject(value, v, 3)) { + PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector"); + return -1; + } + Vec3r p(v[0], v[1], v[2]); + self->fes->setNormalA(p); + return 0; } -static char FEdgeSharp_bFaceMark___doc__[] = -".. method:: bFaceMark()\n" +PyDoc_STRVAR(FEdgeSharp_normal_left_doc, +"The normal to the face lying on the left of the FEdge.\n" "\n" -" Returns the face mark of the face lying on the left of the FEdge.\n" -"\n" -" :return: The face mark of the face lying on the left of the FEdge.\n" -" :rtype: bool\n"; +":type: :class:`mathutils.Vector`"); -static PyObject * FEdgeSharp_bFaceMark( BPy_FEdgeSharp *self ) { - return PyBool_from_bool( self->fes->bFaceMark() ); +static PyObject *FEdgeSharp_normal_left_get(BPy_FEdgeSharp *self, void *UNUSED(closure)) +{ + return Vector_CreatePyObject_cb((PyObject *)self, 3, FEdgeSharp_mathutils_cb_index, MATHUTILS_SUBTYPE_NORMAL_B); } -static char FEdgeSharp_setNormalA___doc__[] = -".. method:: setNormalA(iNormal)\n" -"\n" -" Sets the normal to the face lying on the right of the FEdge.\n" -"\n" -" :arg iNormal: A three-dimensional vector.\n" -" :type iNormal: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"; - -static PyObject * FEdgeSharp_setNormalA( BPy_FEdgeSharp *self, PyObject *args ) { - PyObject *obj = 0; - - if(!( PyArg_ParseTuple(args, "O", &obj) )) - return NULL; - Vec3r *v = Vec3r_ptr_from_PyObject(obj); - if( !v ) { - PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); - return NULL; +static int FEdgeSharp_normal_left_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure)) +{ + float v[3]; + if (!float_array_from_PyObject(value, v, 3)) { + PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector"); + return -1; } - self->fes->setNormalA( *v ); - delete v; - - Py_RETURN_NONE; + Vec3r p(v[0], v[1], v[2]); + self->fes->setNormalB(p); + return 0; } -static char FEdgeSharp_setNormalB___doc__[] = -".. method:: setNormalB(iNormal)\n" -"\n" -" Sets the normal to the face lying on the left of the FEdge.\n" +PyDoc_STRVAR(FEdgeSharp_material_index_right_doc, +"The index of the material of the face lying on the right of the FEdge.\n" +"If this FEdge is a border, it has no Face on its right and therefore\n" +"no material.\n" "\n" -" :arg iNormal: A three-dimensional vector.\n" -" :type iNormal: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"; - -static PyObject * FEdgeSharp_setNormalB( BPy_FEdgeSharp *self, PyObject *args ) { - PyObject *obj = 0; - - if(!( PyArg_ParseTuple(args, "O", &obj) )) - return NULL; - Vec3r *v = Vec3r_ptr_from_PyObject(obj); - if( !v ) { - PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); - return NULL; - } - self->fes->setNormalB( *v ); - delete v; +":type: int"); - Py_RETURN_NONE; +static PyObject *FEdgeSharp_material_index_right_get(BPy_FEdgeSharp *self, void *UNUSED(closure)) +{ + return PyLong_FromLong(self->fes->aFrsMaterialIndex()); } -static char FEdgeSharp_setaMaterialIndex___doc__[] = -".. method:: setaMaterialIndex(i)\n" -"\n" -" Sets the index of the material lying on the right of the FEdge.\n" -"\n" -" :arg i: A material index.\n" -" :type i: int\n"; +static int FEdgeSharp_material_index_right_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure)) +{ + unsigned int i = PyLong_AsUnsignedLong(value); + if(PyErr_Occurred()) + return -1; + self->fes->setaFrsMaterialIndex(i); + return 0; +} -static PyObject * FEdgeSharp_setaMaterialIndex( BPy_FEdgeSharp *self, PyObject *args ) { - unsigned int i; +PyDoc_STRVAR(FEdgeSharp_material_index_left_doc, +"The index of the material of the face lying on the left of the FEdge.\n" +"\n" +":type: int"); - if(!( PyArg_ParseTuple(args, "I", &i) )) - return NULL; - - self->fes->setaFrsMaterialIndex( i ); +static PyObject *FEdgeSharp_material_index_left_get(BPy_FEdgeSharp *self, void *UNUSED(closure)) +{ + return PyLong_FromLong(self->fes->aFrsMaterialIndex()); +} - Py_RETURN_NONE; +static int FEdgeSharp_material_index_left_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure)) +{ + unsigned int i = PyLong_AsUnsignedLong(value); + if(PyErr_Occurred()) + return -1; + self->fes->setbFrsMaterialIndex(i); + return 0; } -static char FEdgeSharp_setbMaterialIndex___doc__[] = -".. method:: setbMaterialIndex(i)\n" +PyDoc_STRVAR(FEdgeSharp_material_right_doc, +"The material of the face lying on the right of the FEdge. If this FEdge\n" +"is a border, it has no Face on its right and therefore no material.\n" "\n" -" Sets the index of the material lying on the left of the FEdge.\n" -"\n" -" :arg i: A material index.\n" -" :type i: int\n"; +":type: :class:`Material`"); -static PyObject * FEdgeSharp_setbMaterialIndex( BPy_FEdgeSharp *self, PyObject *args ) { - unsigned int i; +static PyObject *FEdgeSharp_material_right_get(BPy_FEdgeSharp *self, void *UNUSED(closure)) +{ + // FIXME aFrsMaterial() returns a const reference. + FrsMaterial m(self->fes->aFrsMaterial()); + return BPy_FrsMaterial_from_FrsMaterial(m); +} - if(!( PyArg_ParseTuple(args, "I", &i) )) - return NULL; - - self->fes->setbFrsMaterialIndex( i ); +PyDoc_STRVAR(FEdgeSharp_material_left_doc, +"The material of the face lying on the left of the FEdge.\n" +"\n" +":type: :class:`Material`"); - Py_RETURN_NONE; +static PyObject *FEdgeSharp_material_left_get(BPy_FEdgeSharp *self, void *UNUSED(closure)) +{ + // FIXME bFrsMaterial() returns a const reference. + FrsMaterial m(self->fes->bFrsMaterial()); + return BPy_FrsMaterial_from_FrsMaterial(m); } -static char FEdgeSharp_setaFaceMark___doc__[] = -".. method:: setaFaceMark(i)\n" -"\n" -" Sets the face mark of the face lying on the right of the FEdge.\n" +PyDoc_STRVAR(FEdgeSharp_face_mark_right_doc, +"The face mark of the face lying on the right of the FEdge. If this FEdge\n" +"is a border, it has no face on the right and thus this property is set to\n" +"false.\n" "\n" -" :arg i: A face mark.\n" -" :type i: bool\n"; +":type: bool"); -static PyObject * FEdgeSharp_setaFaceMark( BPy_FEdgeSharp *self, PyObject *args ) { - PyObject *obj; - - if(!( PyArg_ParseTuple(args, "O", &obj) )) - return NULL; - - self->fes->setaFaceMark( bool_from_PyBool(obj) ); +static PyObject *FEdgeSharp_face_mark_right_get(BPy_FEdgeSharp *self, void *UNUSED(closure)) +{ + return PyBool_from_bool(self->fes->aFaceMark()); +} - Py_RETURN_NONE; +static int FEdgeSharp_face_mark_right_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure)) +{ + if(!PyBool_Check(value)) + return -1; + self->fes->setaFaceMark(bool_from_PyBool(value)); + return 0; } -static char FEdgeSharp_setbFaceMark___doc__[] = -".. method:: setbFaceMark(i)\n" +PyDoc_STRVAR(FEdgeSharp_face_mark_left_doc, +"The face mark of the face lying on the left of the FEdge.\n" "\n" -" Sets the face mark of the face lying on the left of the FEdge.\n" -"\n" -" :arg i: A face mark.\n" -" :type i: bool\n"; - -static PyObject * FEdgeSharp_setbFaceMark( BPy_FEdgeSharp *self, PyObject *args ) { - PyObject *obj; +":type: bool"); - if(!( PyArg_ParseTuple(args, "O", &obj) )) - return NULL; - - self->fes->setbFaceMark( bool_from_PyBool(obj) ); +static PyObject *FEdgeSharp_face_mark_left_get(BPy_FEdgeSharp *self, void *UNUSED(closure)) +{ + return PyBool_from_bool(self->fes->bFaceMark()); +} - Py_RETURN_NONE; +static int FEdgeSharp_face_mark_left_set(BPy_FEdgeSharp *self, PyObject *value, void *UNUSED(closure)) +{ + if(!PyBool_Check(value)) + return -1; + self->fes->setbFaceMark(bool_from_PyBool(value)); + return 0; } -/*----------------------FEdgeSharp instance definitions ----------------------------*/ -static PyMethodDef BPy_FEdgeSharp_methods[] = { - {"normalA", ( PyCFunction ) FEdgeSharp_normalA, METH_NOARGS, FEdgeSharp_normalA___doc__}, - {"normalB", ( PyCFunction ) FEdgeSharp_normalB, METH_NOARGS, FEdgeSharp_normalB___doc__}, - {"aMaterialIndex", ( PyCFunction ) FEdgeSharp_aMaterialIndex, METH_NOARGS, FEdgeSharp_aMaterialIndex___doc__}, - {"bMaterialIndex", ( PyCFunction ) FEdgeSharp_bMaterialIndex, METH_NOARGS, FEdgeSharp_bMaterialIndex___doc__}, - {"aMaterial", ( PyCFunction ) FEdgeSharp_aMaterial, METH_NOARGS, FEdgeSharp_aMaterial___doc__}, - {"bMaterial", ( PyCFunction ) FEdgeSharp_bMaterial, METH_NOARGS, FEdgeSharp_bMaterial___doc__}, - {"aFaceMark", ( PyCFunction ) FEdgeSharp_aFaceMark, METH_NOARGS, FEdgeSharp_aFaceMark___doc__}, - {"bFaceMark", ( PyCFunction ) FEdgeSharp_bFaceMark, METH_NOARGS, FEdgeSharp_bFaceMark___doc__}, - {"setNormalA", ( PyCFunction ) FEdgeSharp_setNormalA, METH_VARARGS, FEdgeSharp_setNormalA___doc__}, - {"setNormalB", ( PyCFunction ) FEdgeSharp_setNormalB, METH_VARARGS, FEdgeSharp_setNormalB___doc__}, - {"setaMaterialIndex", ( PyCFunction ) FEdgeSharp_setaMaterialIndex, METH_VARARGS, FEdgeSharp_setaMaterialIndex___doc__}, - {"setbMaterialIndex", ( PyCFunction ) FEdgeSharp_setbMaterialIndex, METH_VARARGS, FEdgeSharp_setbMaterialIndex___doc__}, - {"setaFaceMark", ( PyCFunction ) FEdgeSharp_setaFaceMark, METH_NOARGS, FEdgeSharp_setaFaceMark___doc__}, - {"setbFaceMark", ( PyCFunction ) FEdgeSharp_setbFaceMark, METH_NOARGS, FEdgeSharp_setbFaceMark___doc__}, - {NULL, NULL, 0, NULL} +static PyGetSetDef BPy_FEdgeSharp_getseters[] = { + {(char *)"normal_right", (getter)FEdgeSharp_normal_right_get, (setter)FEdgeSharp_normal_right_set, (char *)FEdgeSharp_normal_right_doc, NULL}, + {(char *)"normal_left", (getter)FEdgeSharp_normal_left_get, (setter)FEdgeSharp_normal_left_set, (char *)FEdgeSharp_normal_left_doc, NULL}, + {(char *)"material_index_right", (getter)FEdgeSharp_material_index_right_get, (setter)FEdgeSharp_material_index_right_set, (char *)FEdgeSharp_material_index_right_doc, NULL}, + {(char *)"material_index_left", (getter)FEdgeSharp_material_index_left_get, (setter)FEdgeSharp_material_index_left_set, (char *)FEdgeSharp_material_index_left_doc, NULL}, + {(char *)"material_right", (getter)FEdgeSharp_material_right_get, (setter)NULL, (char *)FEdgeSharp_material_right_doc, NULL}, + {(char *)"material_left", (getter)FEdgeSharp_material_left_get, (setter)NULL, (char *)FEdgeSharp_material_left_doc, NULL}, + {(char *)"face_mark_right", (getter)FEdgeSharp_face_mark_right_get, (setter)FEdgeSharp_face_mark_right_set, (char *)FEdgeSharp_face_mark_right_doc, NULL}, + {(char *)"face_mark_left", (getter)FEdgeSharp_face_mark_left_get, (setter)FEdgeSharp_face_mark_left_set, (char *)FEdgeSharp_face_mark_left_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_FEdgeSharp type definition ------------------------------*/ @@ -346,7 +378,7 @@ PyTypeObject FEdgeSharp_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - FEdgeSharp___doc__, /* tp_doc */ + FEdgeSharp_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -355,13 +387,13 @@ PyTypeObject FEdgeSharp_Type = { 0, /* tp_iternext */ BPy_FEdgeSharp_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_FEdgeSharp_getseters, /* tp_getset */ &FEdge_Type, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)FEdgeSharp___init__, /* tp_init */ + (initproc)FEdgeSharp_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.h b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.h index 84b01e27c21..b0e35395b66 100644 --- a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.h +++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.h @@ -22,6 +22,10 @@ typedef struct { FEdgeSharp *fes; } BPy_FEdgeSharp; +/*---------------------------Python BPy_FEdgeSharp visible prototypes-----------*/ + +void FEdgeSharp_mathutils_register_callback(); + /////////////////////////////////////////////////////////////////////////////////////////// #ifdef __cplusplus diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp index 3ddb4d060de..abda2ca1179 100644 --- a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp +++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp @@ -9,9 +9,9 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////////////////// -//------------------------INSTANCE METHODS ---------------------------------- +/*----------------------FEdgeSmooth methods ----------------------------*/ -static char FEdgeSmooth___doc__[] = +PyDoc_STRVAR(FEdgeSmooth_doc, "Class hierarchy: :class:`Interface1D` > :class:`FEdge` > :class:`FEdgeSmooth`\n" "\n" "Class defining a smooth edge. This kind of edge typically runs across\n" @@ -36,23 +36,23 @@ static char FEdgeSmooth___doc__[] = " :arg vA: The first SVertex object.\n" " :type vA: :class:`SVertex`\n" " :arg vB: The second SVertex object.\n" -" :type vB: :class:`SVertex`\n"; +" :type vB: :class:`SVertex`"); -static int FEdgeSmooth___init__(BPy_FEdgeSmooth *self, PyObject *args, PyObject *kwds) +static int FEdgeSmooth_init(BPy_FEdgeSmooth *self, PyObject *args, PyObject *kwds) { PyObject *obj1 = 0, *obj2 = 0; - if (! PyArg_ParseTuple(args, "|OO", &obj1, &obj2) ) - return -1; + if (!PyArg_ParseTuple(args, "|OO", &obj1, &obj2)) + return -1; - if( !obj1 ){ + if (!obj1) { self->fes = new FEdgeSmooth(); - - } else if( !obj2 && BPy_FEdgeSmooth_Check(obj1) ) { - self->fes = new FEdgeSmooth(*( ((BPy_FEdgeSmooth *) obj1)->fes )); - - } else if( obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2) ) { - self->fes = new FEdgeSmooth( ((BPy_SVertex *) obj1)->sv, ((BPy_SVertex *) obj2)->sv ); + + } else if (!obj2 && BPy_FEdgeSmooth_Check(obj1)) { + self->fes = new FEdgeSmooth(*(((BPy_FEdgeSmooth *)obj1)->fes)); + + } else if (obj2 && BPy_SVertex_Check(obj1) && BPy_SVertex_Check(obj2)) { + self->fes = new FEdgeSmooth(((BPy_SVertex *)obj1)->sv, ((BPy_SVertex *)obj2)->sv); } else { PyErr_SetString(PyExc_TypeError, "invalid argument(s)"); @@ -66,128 +66,148 @@ static int FEdgeSmooth___init__(BPy_FEdgeSmooth *self, PyObject *args, PyObject return 0; } -static char FEdgeSmooth_normal___doc__[] = -".. method:: normal()\n" -"\n" -" Returns the normal to the Face it is running accross.\n" -"\n" -" :return: The normal to the Face it is running accross.\n" -" :rtype: :class:`mathutils.Vector`\n"; +static PyMethodDef BPy_FEdgeSmooth_methods[] = { + {NULL, NULL, 0, NULL} +}; + +/*----------------------mathutils callbacks ----------------------------*/ -static PyObject * FEdgeSmooth_normal( BPy_FEdgeSmooth *self ) { - Vec3r v( self->fes->normal() ); - return Vector_from_Vec3r( v ); +static int FEdgeSmooth_mathutils_check(BaseMathObject *bmo) +{ + if (!BPy_FEdgeSmooth_Check(bmo->cb_user)) + return -1; + return 0; } -static char FEdgeSmooth_materialIndex___doc__[] = -".. method:: materialIndex()\n" -"\n" -" Returns the index of the material of the face it is running accross.\n" -"\n" -" :return: The index of the material of the face it is running accross.\n" -" :rtype: int\n"; +static int FEdgeSmooth_mathutils_get(BaseMathObject *bmo, int subtype) +{ + BPy_FEdgeSmooth *self = (BPy_FEdgeSmooth *)bmo->cb_user; + Vec3r p(self->fes->normal()); + bmo->data[0] = p[0]; + bmo->data[1] = p[1]; + bmo->data[2] = p[2]; + return 0; +} -static PyObject * FEdgeSmooth_materialIndex( BPy_FEdgeSmooth *self ) { - return PyLong_FromLong( self->fes->frs_materialIndex() ); +static int FEdgeSmooth_mathutils_set(BaseMathObject *bmo, int subtype) +{ + BPy_FEdgeSmooth *self = (BPy_FEdgeSmooth *)bmo->cb_user; + Vec3r p(bmo->data[0], bmo->data[1], bmo->data[2]); + self->fes->setNormal(p); + return 0; } -static char FEdgeSmooth_material___doc__[] = -".. method:: material()\n" -"\n" -" Returns the material of the face it is running accross.\n" -"\n" -" :return: The material of the face it is running accross.\n" -" :rtype: :class:`Material`\n"; +static int FEdgeSmooth_mathutils_get_index(BaseMathObject *bmo, int subtype, int index) +{ + BPy_FEdgeSmooth *self = (BPy_FEdgeSmooth *)bmo->cb_user; + Vec3r p(self->fes->normal()); + bmo->data[index] = p[index]; + return 0; +} -static PyObject * FEdgeSmooth_material( BPy_FEdgeSmooth *self ) { - FrsMaterial m( self->fes->frs_material() ); - return BPy_FrsMaterial_from_FrsMaterial(m); +static int FEdgeSmooth_mathutils_set_index(BaseMathObject *bmo, int subtype, int index) +{ + BPy_FEdgeSmooth *self = (BPy_FEdgeSmooth *)bmo->cb_user; + Vec3r p(self->fes->normal()); + p[index] = bmo->data[index]; + self->fes->setNormal(p); + return 0; } -static char FEdgeSmooth_faceMark___doc__[] = -".. method:: faceMark()\n" -"\n" -" Returns the face mark of the face it is running across.\n" -"\n" -" :return: The face mark of the face it is running across.\n" -" :rtype: bool\n"; +static Mathutils_Callback FEdgeSmooth_mathutils_cb = { + FEdgeSmooth_mathutils_check, + FEdgeSmooth_mathutils_get, + FEdgeSmooth_mathutils_set, + FEdgeSmooth_mathutils_get_index, + FEdgeSmooth_mathutils_set_index +}; + +static unsigned char FEdgeSmooth_mathutils_cb_index = -1; -static PyObject * FEdgeSmooth_faceMark( BPy_FEdgeSmooth *self ) { - return PyBool_from_bool( self->fes->faceMark() ); +void FEdgeSmooth_mathutils_register_callback() +{ + FEdgeSmooth_mathutils_cb_index = Mathutils_RegisterCallback(&FEdgeSmooth_mathutils_cb); } -static char FEdgeSmooth_setNormal___doc__[] = -".. method:: setNormal(iNormal)\n" -"\n" -" Sets the normal to the Face it is running accross.\n" +/*----------------------FEdgeSmooth get/setters ----------------------------*/ + +PyDoc_STRVAR(FEdgeSmooth_normal_doc, +"The normal of the face that this FEdge is running across.\n" "\n" -" :arg iNormal: A three-dimensional vector.\n" -" :type iNormal: :class:`mathutils.Vector`, list or tuple of 3 real numbers\n"; - -static PyObject * FEdgeSmooth_setNormal( BPy_FEdgeSmooth *self, PyObject *args ) { - PyObject *obj = 0; - - if(!( PyArg_ParseTuple(args, "O", &obj) )) - return NULL; - Vec3r *v = Vec3r_ptr_from_PyObject(obj); - if( !v ) { - PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)"); - return NULL; - } - self->fes->setNormal( *v ); - delete v; +":type: :class:`mathutils.Vector`"); - Py_RETURN_NONE; +static PyObject *FEdgeSmooth_normal_get(BPy_FEdgeSmooth *self, void *UNUSED(closure)) +{ + return Vector_CreatePyObject_cb((PyObject *)self, 3, FEdgeSmooth_mathutils_cb_index, 0); } -static char FEdgeSmooth_setMaterialIndex___doc__[] = -".. method:: setMaterialIndex(i)\n" -"\n" -" Sets the index of the material of the face it is running accross.\n" -"\n" -" :arg i: The index of the material of the face it is running accross.\n" -" :type i: int\n"; +static int FEdgeSmooth_normal_set(BPy_FEdgeSmooth *self, PyObject *value, void *UNUSED(closure)) +{ + float v[3]; + if (!float_array_from_PyObject(value, v, 3)) { + PyErr_SetString(PyExc_ValueError, "value must be a 3-dimensional vector"); + return -1; + } + Vec3r p(v[0], v[1], v[2]); + self->fes->setNormal(p); + return 0; +} -static PyObject * FEdgeSmooth_setMaterialIndex( BPy_FEdgeSmooth *self, PyObject *args ) { - unsigned int i; +PyDoc_STRVAR(FEdgeSmooth_material_index_doc, +"The index of the material of the face that this FEdge is running across.\n" +"\n" +":type: int"); - if(!( PyArg_ParseTuple(args, "I", &i) )) - return NULL; - - self->fes->setFrsMaterialIndex( i ); +static PyObject *FEdgeSmooth_material_index_get(BPy_FEdgeSmooth *self, void *UNUSED(closure)) +{ + return PyLong_FromLong(self->fes->frs_materialIndex()); +} - Py_RETURN_NONE; +static int FEdgeSmooth_material_index_set(BPy_FEdgeSmooth *self, PyObject *value, void *UNUSED(closure)) +{ + unsigned int i = PyLong_AsUnsignedLong(value); + if(PyErr_Occurred()) + return -1; + self->fes->setFrsMaterialIndex(i); + return 0; } -static char FEdgeSmooth_setFaceMark___doc__[] = -".. method:: setFaceMark(i)\n" -"\n" -" Sets the face mark of the face it is running across.\n" +PyDoc_STRVAR(FEdgeSmooth_material_doc, +"The material of the face that this FEdge is running across.\n" "\n" -" :arg i: A face mark.\n" -" :type i: bool\n"; +":type: :class:`Material`"); -static PyObject * FEdgeSmooth_setFaceMark( BPy_FEdgeSmooth *self, PyObject *args ) { - PyObject *obj; +static PyObject *FEdgeSmooth_material_get(BPy_FEdgeSmooth *self, void *UNUSED(closure)) +{ + // FIXME frs_material() returns a const reference. + FrsMaterial m(self->fes->frs_material()); + return BPy_FrsMaterial_from_FrsMaterial(m); +} - if(!( PyArg_ParseTuple(args, "O", &obj) )) - return NULL; - - self->fes->setFaceMark( bool_from_PyBool(obj) ); +PyDoc_STRVAR(FEdgeSmooth_face_mark_doc, +"The face mark of the face that this FEdge is running across.\n" +"\n" +":type: bool"); - Py_RETURN_NONE; +static PyObject *FEdgeSmooth_face_mark_get(BPy_FEdgeSmooth *self, void *UNUSED(closure)) +{ + return PyBool_from_bool(self->fes->faceMark()); } -/*----------------------FEdgeSmooth instance definitions ----------------------------*/ -static PyMethodDef BPy_FEdgeSmooth_methods[] = { - {"normal", ( PyCFunction ) FEdgeSmooth_normal, METH_NOARGS, FEdgeSmooth_normal___doc__}, - {"materialIndex", ( PyCFunction ) FEdgeSmooth_materialIndex, METH_NOARGS, FEdgeSmooth_materialIndex___doc__}, - {"material", ( PyCFunction ) FEdgeSmooth_material, METH_NOARGS, FEdgeSmooth_material___doc__}, - {"faceMark", ( PyCFunction ) FEdgeSmooth_faceMark, METH_NOARGS, FEdgeSmooth_faceMark___doc__}, - {"setNormal", ( PyCFunction ) FEdgeSmooth_setNormal, METH_VARARGS, FEdgeSmooth_setNormal___doc__}, - {"setMaterialIndex", ( PyCFunction ) FEdgeSmooth_setMaterialIndex, METH_VARARGS, FEdgeSmooth_setMaterialIndex___doc__}, - {"setFaceMark", ( PyCFunction ) FEdgeSmooth_setFaceMark, METH_VARARGS, FEdgeSmooth_setFaceMark___doc__}, - {NULL, NULL, 0, NULL} +static int FEdgeSmooth_face_mark_set(BPy_FEdgeSmooth *self, PyObject *value, void *UNUSED(closure)) +{ + if(!PyBool_Check(value)) + return -1; + self->fes->setFaceMark(bool_from_PyBool(value)); + return 0; +} + +static PyGetSetDef BPy_FEdgeSmooth_getseters[] = { + {(char *)"normal", (getter)FEdgeSmooth_normal_get, (setter)FEdgeSmooth_normal_set, (char *)FEdgeSmooth_normal_doc, NULL}, + {(char *)"material_index", (getter)FEdgeSmooth_material_index_get, (setter)FEdgeSmooth_material_index_set, (char *)FEdgeSmooth_material_index_doc, NULL}, + {(char *)"material", (getter)FEdgeSmooth_material_get, (setter)NULL, (char *)FEdgeSmooth_material_doc, NULL}, + {(char *)"face_mark", (getter)FEdgeSmooth_face_mark_get, (setter)FEdgeSmooth_face_mark_set, (char *)FEdgeSmooth_face_mark_doc, NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ }; /*-----------------------BPy_FEdgeSmooth type definition ------------------------------*/ @@ -213,7 +233,7 @@ PyTypeObject FEdgeSmooth_Type = { 0, /* tp_setattro */ 0, /* tp_as_buffer */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ - FEdgeSmooth___doc__, /* tp_doc */ + FEdgeSmooth_doc, /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ @@ -222,13 +242,13 @@ PyTypeObject FEdgeSmooth_Type = { 0, /* tp_iternext */ BPy_FEdgeSmooth_methods, /* tp_methods */ 0, /* tp_members */ - 0, /* tp_getset */ + BPy_FEdgeSmooth_getseters, /* tp_getset */ &FEdge_Type, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ - (initproc)FEdgeSmooth___init__, /* tp_init */ + (initproc)FEdgeSmooth_init, /* tp_init */ 0, /* tp_alloc */ 0, /* tp_new */ }; diff --git a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.h b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.h index d7b44bb1da7..7f7d0aaa3b7 100644 --- a/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.h +++ b/source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.h @@ -22,6 +22,10 @@ typedef struct { FEdgeSmooth *fes; } BPy_FEdgeSmooth; +/*---------------------------Python BPy_FEdgeSmooth visible prototypes-----------*/ + +void FEdgeSmooth_mathutils_register_callback(); + /////////////////////////////////////////////////////////////////////////////////////////// #ifdef __cplusplus |