Made the Freestyle Python API compatible with Python 3.
[blender.git] / source / blender / freestyle / intern / python / BPy_StrokeAttribute.cpp
1 #include "BPy_StrokeAttribute.h"
2
3 #include "BPy_Convert.h"
4
5 #ifdef __cplusplus
6 extern "C" {
7 #endif
8
9 ///////////////////////////////////////////////////////////////////////////////////////////
10
11 /*---------------  Python API function prototypes for StrokeAttribute instance  -----------*/
12 static int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds);
13 static void StrokeAttribute___dealloc__(BPy_StrokeAttribute *self);
14 static PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute *self);
15
16 static PyObject * StrokeAttribute_getColorR( BPy_StrokeAttribute *self );
17 static PyObject * StrokeAttribute_getColorG( BPy_StrokeAttribute *self );
18 static PyObject * StrokeAttribute_getColorB( BPy_StrokeAttribute *self );
19 static PyObject * StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self );
20 static PyObject * StrokeAttribute_getAlpha( BPy_StrokeAttribute *self );
21 static PyObject * StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self );
22 static PyObject * StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self );
23 static PyObject * StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self );
24 static PyObject * StrokeAttribute_isVisible( BPy_StrokeAttribute *self );
25 static PyObject * StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args );
26 static PyObject * StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args );
27 static PyObject * StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args );
28 static PyObject * StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args );
29 static PyObject * StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args );
30 static PyObject * StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args );
31 static PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args );
32 static PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args );
33 static PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args );
34 static PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args );
35 static PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args );
36 static PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args );
37 static PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args );
38
39
40 /*----------------------StrokeAttribute instance definitions ----------------------------*/
41 static PyMethodDef BPy_StrokeAttribute_methods[] = {
42         {"getColorR", ( PyCFunction ) StrokeAttribute_getColorR, METH_NOARGS, "Returns the R color component. "},
43         {"getColorG", ( PyCFunction ) StrokeAttribute_getColorG, METH_NOARGS, "Returns the G color component. "},
44         {"getColorB", ( PyCFunction ) StrokeAttribute_getColorB, METH_NOARGS, "Returns the B color component. "},
45         {"getColorRGB", ( PyCFunction ) StrokeAttribute_getColorRGB, METH_NOARGS, "Returns the RGB color components."},
46         {"getAlpha", ( PyCFunction ) StrokeAttribute_getAlpha, METH_NOARGS, "Returns the alpha color component."},
47         {"getThicknessR", ( PyCFunction ) StrokeAttribute_getThicknessR, METH_NOARGS, "Returns the thickness on the right of the vertex when following the stroke. "},
48         {"getThicknessL", ( PyCFunction ) StrokeAttribute_getThicknessL, METH_NOARGS, "Returns the thickness on the left of the vertex when following the stroke."},
49         {"getThicknessRL", ( PyCFunction ) StrokeAttribute_getThicknessRL, METH_NOARGS, "Returns the thickness on the right and on the left of the vertex when following the stroke. "},
50         {"isVisible", ( PyCFunction ) StrokeAttribute_isVisible, METH_NOARGS, "Returns true if the strokevertex is visible, false otherwise"},
51         {"getAttributeReal", ( PyCFunction ) StrokeAttribute_getAttributeReal, METH_VARARGS, "(name) Returns an attribute of type real specified by name."},
52         {"getAttributeVec2f", ( PyCFunction ) StrokeAttribute_getAttributeVec2f, METH_VARARGS, "(name) Returns an attribute of type Vec2f specified by name."},
53         {"getAttributeVec3f", ( PyCFunction ) StrokeAttribute_getAttributeVec3f, METH_VARARGS, "(name) Returns an attribute of type Vec3f specified by name."},
54         {"isAttributeAvailableReal", ( PyCFunction ) StrokeAttribute_isAttributeAvailableReal, METH_VARARGS, "(name) Checks whether the real attribute specified by name is available"},
55         {"isAttributeAvailableVec2f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec2f, METH_VARARGS, "(name) Checks whether the Vec2f attribute specified by name is available"},
56         {"isAttributeAvailableVec3f", ( PyCFunction ) StrokeAttribute_isAttributeAvailableVec3f, METH_VARARGS, "(name) Checks whether the Vec3f attribute specified by name is available"},
57         {"setColor", ( PyCFunction ) StrokeAttribute_setColor, METH_VARARGS, "(float a)Sets the attribute's alpha value. "},
58         {"setAlpha", ( PyCFunction ) StrokeAttribute_setAlpha, METH_VARARGS, "(float a) Sets the attribute's alpha value."},
59         {"setThickness", ( PyCFunction ) StrokeAttribute_setThickness, METH_VARARGS, ""},
60         {"setVisible", ( PyCFunction ) StrokeAttribute_setVisible, METH_VARARGS, ""},
61         {"setAttributeReal", ( PyCFunction ) StrokeAttribute_setAttributeReal, METH_VARARGS, "(name, float att) Adds a user defined attribute of type real. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
62         {"setAttributeVec2f", ( PyCFunction ) StrokeAttribute_setAttributeVec2f, METH_VARARGS, "(name, float att) Adds a user defined attribute of type Vec2f. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
63         {"setAttributeVec3f", ( PyCFunction ) StrokeAttribute_setAttributeVec3f, METH_VARARGS, "(name, float att) Adds a user defined attribute of type Vec4f. If there is no attribute of specified by name, it is added. Otherwise, the new value replaces the old one."},
64         {NULL, NULL, 0, NULL}
65 };
66
67
68
69 /*-----------------------BPy_StrokeAttribute type definition ------------------------------*/
70
71 PyTypeObject StrokeAttribute_Type = {
72         PyVarObject_HEAD_INIT(NULL, 0)
73         "StrokeAttribute",              /* tp_name */
74         sizeof(BPy_StrokeAttribute),    /* tp_basicsize */
75         0,                              /* tp_itemsize */
76         (destructor)StrokeAttribute___dealloc__, /* tp_dealloc */
77         0,                              /* tp_print */
78         0,                              /* tp_getattr */
79         0,                              /* tp_setattr */
80         0,                              /* tp_reserved */
81         (reprfunc)StrokeAttribute___repr__, /* tp_repr */
82         0,                              /* tp_as_number */
83         0,                              /* tp_as_sequence */
84         0,                              /* tp_as_mapping */
85         0,                              /* tp_hash  */
86         0,                              /* tp_call */
87         0,                              /* tp_str */
88         0,                              /* tp_getattro */
89         0,                              /* tp_setattro */
90         0,                              /* tp_as_buffer */
91         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
92         "StrokeAttribute objects",      /* tp_doc */
93         0,                              /* tp_traverse */
94         0,                              /* tp_clear */
95         0,                              /* tp_richcompare */
96         0,                              /* tp_weaklistoffset */
97         0,                              /* tp_iter */
98         0,                              /* tp_iternext */
99         BPy_StrokeAttribute_methods,    /* tp_methods */
100         0,                              /* tp_members */
101         0,                              /* tp_getset */
102         0,                              /* tp_base */
103         0,                              /* tp_dict */
104         0,                              /* tp_descr_get */
105         0,                              /* tp_descr_set */
106         0,                              /* tp_dictoffset */
107         (initproc)StrokeAttribute___init__, /* tp_init */
108         0,                              /* tp_alloc */
109         PyType_GenericNew,              /* tp_new */
110 };
111
112 //-------------------MODULE INITIALIZATION--------------------------------
113 int StrokeAttribute_Init( PyObject *module )
114 {
115         if( module == NULL )
116                 return -1;
117
118         if( PyType_Ready( &StrokeAttribute_Type ) < 0 )
119                 return -1;
120         Py_INCREF( &StrokeAttribute_Type );
121         PyModule_AddObject(module, "StrokeAttribute", (PyObject *)&StrokeAttribute_Type);
122         return 0;
123 }
124
125 //------------------------INSTANCE METHODS ----------------------------------
126
127 int StrokeAttribute___init__(BPy_StrokeAttribute *self, PyObject *args, PyObject *kwds)
128 {
129
130         PyObject *obj1 = 0, *obj2 = 0 , *obj3 = 0, *obj4 = 0, *obj5 = 0 , *obj6 = 0;
131
132     if (! PyArg_ParseTuple(args, "|OOOOOO", &obj1, &obj2, &obj3, &obj4, &obj5, &obj6) )
133         return -1;
134
135         if( !obj1 || !obj2 || !obj3 ){
136                 
137                 self->sa = new StrokeAttribute();
138                 
139         } else if(      BPy_StrokeAttribute_Check(obj1) && 
140                                 BPy_StrokeAttribute_Check(obj2) &&
141                                 PyFloat_Check(obj3) ) { 
142                 
143                         self->sa = new StrokeAttribute( *( ((BPy_StrokeAttribute *) obj1)->sa ),
144                                                                                         *( ((BPy_StrokeAttribute *) obj2)->sa ),
145                                                                                         PyFloat_AsDouble( obj3 ) );     
146                                                                                 
147         } else if(      obj4 && obj5 && obj6 ) {
148         
149                         self->sa = new StrokeAttribute( PyFloat_AsDouble( obj1 ),
150                                                                                         PyFloat_AsDouble( obj2 ),
151                                                                                         PyFloat_AsDouble( obj3 ),
152                                                                                         PyFloat_AsDouble( obj4 ),
153                                                                                         PyFloat_AsDouble( obj5 ),
154                                                                                         PyFloat_AsDouble( obj6 ) );
155
156         } else {
157                 PyErr_SetString(PyExc_TypeError, "invalid arguments");
158                 return -1;
159         }
160
161         self->borrowed = 0;
162
163         return 0;
164
165 }
166
167 void StrokeAttribute___dealloc__(BPy_StrokeAttribute* self)
168 {
169         if( self->sa && !self->borrowed )
170                 delete self->sa;
171     Py_TYPE(self)->tp_free((PyObject*)self);
172 }
173
174 PyObject * StrokeAttribute___repr__(BPy_StrokeAttribute* self)
175 {
176         stringstream repr("StrokeAttribute:");
177         repr << " r: " << self->sa->getColorR()
178                  << " g: " << self->sa->getColorG()
179                  << " b: " << self->sa->getColorB()
180                  << " a: " << self->sa->getAlpha()
181                  << " - R: " << self->sa->getThicknessR() 
182                  << " L: " << self->sa->getThicknessL();
183
184         return PyUnicode_FromFormat( repr.str().c_str() );
185 }
186
187
188 PyObject *StrokeAttribute_getColorR( BPy_StrokeAttribute *self ) {
189         return PyFloat_FromDouble( self->sa->getColorR() );     
190 }
191
192 PyObject *StrokeAttribute_getColorG( BPy_StrokeAttribute *self ) {
193         return PyFloat_FromDouble( self->sa->getColorG() );     
194 }
195
196 PyObject *StrokeAttribute_getColorB( BPy_StrokeAttribute *self ) {
197         return PyFloat_FromDouble( self->sa->getColorB() );     
198 }
199
200 PyObject *StrokeAttribute_getColorRGB( BPy_StrokeAttribute *self ) {
201         Vec3f v( self->sa->getColorRGB() );
202         return Vector_from_Vec3f( v );  
203 }
204
205 PyObject *StrokeAttribute_getAlpha( BPy_StrokeAttribute *self ) {
206         return PyFloat_FromDouble( self->sa->getAlpha() );      
207 }
208
209 PyObject *StrokeAttribute_getThicknessR( BPy_StrokeAttribute *self ) {
210         return PyFloat_FromDouble( self->sa->getThicknessR() ); 
211 }
212 PyObject *StrokeAttribute_getThicknessL( BPy_StrokeAttribute *self ) {
213         return PyFloat_FromDouble( self->sa->getThicknessL() ); 
214 }
215 PyObject *StrokeAttribute_getThicknessRL( BPy_StrokeAttribute *self ) {
216         Vec2f v( self->sa->getThicknessRL() );
217         return Vector_from_Vec2f( v );
218 }
219
220 PyObject *StrokeAttribute_isVisible( BPy_StrokeAttribute *self ) {
221         return PyBool_from_bool( self->sa->isVisible() );       
222 }
223
224
225 PyObject *StrokeAttribute_getAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
226         char *attr;
227
228         if(!( PyArg_ParseTuple(args, "s", &attr) ))
229                 return NULL;
230
231         double a = self->sa->getAttributeReal( attr );
232         return PyFloat_FromDouble( a );
233 }
234
235 PyObject *StrokeAttribute_getAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
236         char *attr;
237
238         if(!( PyArg_ParseTuple(args, "s", &attr) ))
239                 return NULL;
240
241         Vec2f a = self->sa->getAttributeVec2f( attr );
242         return Vector_from_Vec2f( a );
243 }
244
245
246 PyObject *StrokeAttribute_getAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
247         char *attr;
248
249         if(!( PyArg_ParseTuple(args, "s", &attr) ))
250                 return NULL;
251
252         Vec3f a = self->sa->getAttributeVec3f( attr );
253         return Vector_from_Vec3f( a );
254 }
255
256 PyObject *StrokeAttribute_isAttributeAvailableReal( BPy_StrokeAttribute *self, PyObject *args ) {
257         char *attr;
258
259         if(!( PyArg_ParseTuple(args, "s", &attr) ))
260                 return NULL;
261
262         return PyBool_from_bool( self->sa->isAttributeAvailableReal( attr ) );
263 }
264
265 PyObject *StrokeAttribute_isAttributeAvailableVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
266         char *attr;
267
268         if(!( PyArg_ParseTuple(args, "s", &attr) ))
269                 return NULL;
270
271         return PyBool_from_bool( self->sa->isAttributeAvailableVec2f( attr ) );
272 }
273
274 PyObject *StrokeAttribute_isAttributeAvailableVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
275         char *attr;
276
277         if(!( PyArg_ParseTuple(args, "s", &attr) ))
278                 return NULL;
279
280         return PyBool_from_bool( self->sa->isAttributeAvailableVec3f( attr ) );
281 }
282
283
284 PyObject * StrokeAttribute_setColor( BPy_StrokeAttribute *self, PyObject *args ) {
285         PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0 ;
286
287         if(!( PyArg_ParseTuple(args, "O|OO", &obj1, &obj2, &obj3) ))
288                 return NULL;
289
290         if( obj1 && !obj2 && !obj3 ){
291
292                 Vec3f *v = Vec3f_ptr_from_PyObject(obj1);
293                 if( !v ) {
294                         PyErr_SetString(PyExc_TypeError, "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
295                         return NULL;
296                 }
297                 self->sa->setColor( *v );
298                 delete v;
299                 
300         } else if(      obj1 && obj2 && obj3 ){
301
302                 self->sa->setColor(     PyFloat_AsDouble(obj1),
303                                                         PyFloat_AsDouble(obj2),
304                                                         PyFloat_AsDouble(obj3) );
305
306         } else {
307                 PyErr_SetString(PyExc_TypeError, "invalid arguments");
308                 return NULL;
309         }
310         
311         Py_RETURN_NONE;
312 }
313
314 PyObject * StrokeAttribute_setAlpha( BPy_StrokeAttribute *self, PyObject *args ){
315         float f = 0;
316
317         if(!( PyArg_ParseTuple(args, "f", &f) ))
318                 return NULL;
319         
320         self->sa->setAlpha( f );
321         Py_RETURN_NONE;
322 }
323
324 PyObject * StrokeAttribute_setThickness( BPy_StrokeAttribute *self, PyObject *args )  {
325         PyObject *obj1 = 0, *obj2 = 0;
326
327         if(!( PyArg_ParseTuple(args, "O|O", &obj1, &obj2) ))
328                 return NULL;
329
330         if( obj1 && !obj2 ){
331                 
332                 Vec2f *v = Vec2f_ptr_from_PyObject(obj1);
333                 if( !v ) {
334                         PyErr_SetString(PyExc_TypeError, "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
335                         return NULL;
336                 }
337                 self->sa->setThickness( *v );
338                 delete v;
339                                 
340         } else if(      obj1 && obj2 ){
341                                         
342                 self->sa->setThickness( PyFloat_AsDouble(obj1),
343                                                                 PyFloat_AsDouble(obj2) );
344
345         } else {
346                 PyErr_SetString(PyExc_TypeError, "invalid arguments");
347                 return NULL;
348         }
349         
350         Py_RETURN_NONE;
351 }
352
353 PyObject * StrokeAttribute_setVisible( BPy_StrokeAttribute *self, PyObject *args ) {
354         PyObject *py_b;
355
356         if(!( PyArg_ParseTuple(args, "O", &py_b) ))
357                 return NULL;
358
359         self->sa->setVisible( bool_from_PyBool(py_b) );
360
361         Py_RETURN_NONE;
362 }
363
364
365 PyObject * StrokeAttribute_setAttributeReal( BPy_StrokeAttribute *self, PyObject *args ) {
366         char *s = 0;
367         double d = 0;
368
369         if(!( PyArg_ParseTuple(args, "sd", &s, &d) ))
370                 return NULL;
371
372         self->sa->setAttributeReal( s, d );
373         Py_RETURN_NONE;
374 }
375
376 PyObject * StrokeAttribute_setAttributeVec2f( BPy_StrokeAttribute *self, PyObject *args ) {
377         char *s;
378         PyObject *obj = 0;
379
380         if(!( PyArg_ParseTuple(args, "sO", &s, &obj) ))
381                 return NULL;
382         Vec2f *v = Vec2f_ptr_from_PyObject(obj);
383         if( !v ) {
384                 PyErr_SetString(PyExc_TypeError, "argument 2 must be a 2D vector (either a list of 2 elements or Vector)");
385                 return NULL;
386         }
387         self->sa->setAttributeVec2f( s, *v );
388         delete v;
389
390         Py_RETURN_NONE;
391 }
392
393 PyObject * StrokeAttribute_setAttributeVec3f( BPy_StrokeAttribute *self, PyObject *args ) {
394         char *s;
395         PyObject *obj = 0;
396
397         if(!( PyArg_ParseTuple(args, "sO", &s, &obj) ))
398                 return NULL;
399         Vec3f *v = Vec3f_ptr_from_PyObject(obj);
400         if( !v ) {
401                 PyErr_SetString(PyExc_TypeError, "argument 2 must be a 3D vector (either a list of 3 elements or Vector)");
402                 return NULL;
403         }
404         self->sa->setAttributeVec3f( s, *v );
405         delete v;
406
407         Py_RETURN_NONE;
408 }
409
410 ///////////////////////////////////////////////////////////////////////////////////////////
411
412 #ifdef __cplusplus
413 }
414 #endif
415