33
34
#include "Effect.h"
36
/******* prototypes **********/
37
PyObject *Wave_Init( void );
36
39
/*****************************************************************************/
37
/* Python BPy_Wave methods table: */
40
/* Python BPy_Wave methods table: */
38
41
/*****************************************************************************/
39
42
static PyMethodDef BPy_Wave_methods[] = {
40
{"getType", (PyCFunction)Effect_getType,
41
METH_NOARGS,"() - Return Effect type"},
42
{"setType", (PyCFunction)Effect_setType,
43
METH_VARARGS,"() - Set Effect type"},
44
{"getFlag", (PyCFunction)Effect_getFlag,
45
METH_NOARGS,"() - Return Effect flag"},
46
{"setFlag", (PyCFunction)Effect_setFlag,
47
METH_VARARGS,"() - Set Effect flag"},
48
{"getStartx",(PyCFunction)Wave_getStartx,
49
METH_NOARGS,"()-Return Wave startx"},
50
{"setStartx",(PyCFunction)Wave_setStartx, METH_VARARGS,
43
{"getType", ( PyCFunction ) Effect_getType,
44
METH_NOARGS, "() - Return Effect type"},
45
{"setType", ( PyCFunction ) Effect_setType,
46
METH_VARARGS, "() - Set Effect type"},
47
{"getFlag", ( PyCFunction ) Effect_getFlag,
48
METH_NOARGS, "() - Return Effect flag"},
49
{"setFlag", ( PyCFunction ) Effect_setFlag,
50
METH_VARARGS, "() - Set Effect flag"},
51
{"getStartx", ( PyCFunction ) Wave_getStartx,
52
METH_NOARGS, "()-Return Wave startx"},
53
{"setStartx", ( PyCFunction ) Wave_setStartx, METH_VARARGS,
51
54
"()- Sets Wave startx"},
52
{"getStarty",(PyCFunction)Wave_getStarty,
53
METH_NOARGS,"()-Return Wave starty"},
54
{"setStarty",(PyCFunction)Wave_setStarty, METH_VARARGS,
55
{"getStarty", ( PyCFunction ) Wave_getStarty,
56
METH_NOARGS, "()-Return Wave starty"},
57
{"setStarty", ( PyCFunction ) Wave_setStarty, METH_VARARGS,
55
58
"()- Sets Wave starty"},
56
{"getHeight",(PyCFunction)Wave_getHeight,
57
METH_NOARGS,"()-Return Wave height"},
58
{"setHeight",(PyCFunction)Wave_setHeight, METH_VARARGS,
59
{"getHeight", ( PyCFunction ) Wave_getHeight,
60
METH_NOARGS, "()-Return Wave height"},
61
{"setHeight", ( PyCFunction ) Wave_setHeight, METH_VARARGS,
59
62
"()- Sets Wave height"},
60
{"getWidth",(PyCFunction)Wave_getWidth,
61
METH_NOARGS,"()-Return Wave width"},
62
{"setWidth",(PyCFunction)Wave_setWidth, METH_VARARGS,
63
{"getWidth", ( PyCFunction ) Wave_getWidth,
64
METH_NOARGS, "()-Return Wave width"},
65
{"setWidth", ( PyCFunction ) Wave_setWidth, METH_VARARGS,
63
66
"()- Sets Wave width"},
64
{"getNarrow",(PyCFunction)Wave_getNarrow,
65
METH_NOARGS,"()-Return Wave narrow"},
66
{"setNarrow",(PyCFunction)Wave_setNarrow, METH_VARARGS,
67
{"getNarrow", ( PyCFunction ) Wave_getNarrow,
68
METH_NOARGS, "()-Return Wave narrow"},
69
{"setNarrow", ( PyCFunction ) Wave_setNarrow, METH_VARARGS,
67
70
"()- Sets Wave narrow"},
68
{"getSpeed",(PyCFunction)Wave_getSpeed,
69
METH_NOARGS,"()-Return Wave speed"},
70
{"setSpeed",(PyCFunction)Wave_setSpeed, METH_VARARGS,
71
{"getSpeed", ( PyCFunction ) Wave_getSpeed,
72
METH_NOARGS, "()-Return Wave speed"},
73
{"setSpeed", ( PyCFunction ) Wave_setSpeed, METH_VARARGS,
71
74
"()- Sets Wave speed"},
72
{"getMinfac",(PyCFunction)Wave_getMinfac,
73
METH_NOARGS,"()-Return Wave minfac"},
74
{"setMinfac",(PyCFunction)Wave_setMinfac, METH_VARARGS,
75
{"getMinfac", ( PyCFunction ) Wave_getMinfac,
76
METH_NOARGS, "()-Return Wave minfac"},
77
{"setMinfac", ( PyCFunction ) Wave_setMinfac, METH_VARARGS,
75
78
"()- Sets Wave minfac"},
76
{"getDamp",(PyCFunction)Wave_getDamp,
77
METH_NOARGS,"()-Return Wave damp"},
78
{"setDamp",(PyCFunction)Wave_setDamp, METH_VARARGS,
79
{"getDamp", ( PyCFunction ) Wave_getDamp,
80
METH_NOARGS, "()-Return Wave damp"},
81
{"setDamp", ( PyCFunction ) Wave_setDamp, METH_VARARGS,
79
82
"()- Sets Wave damp"},
80
{"getTimeoffs",(PyCFunction)Wave_getTimeoffs,
81
METH_NOARGS,"()-Return Wave timeoffs"},
82
{"setTimeoffs",(PyCFunction)Wave_setTimeoffs, METH_VARARGS,
83
{"getTimeoffs", ( PyCFunction ) Wave_getTimeoffs,
84
METH_NOARGS, "()-Return Wave timeoffs"},
85
{"setTimeoffs", ( PyCFunction ) Wave_setTimeoffs, METH_VARARGS,
83
86
"()- Sets Wave timeoffs"},
84
{"getLifetime",(PyCFunction)Wave_getLifetime,
85
METH_NOARGS,"()-Return Wave lifetime"},
86
{"setLifetime",(PyCFunction)Wave_setLifetime, METH_VARARGS,
87
{"getLifetime", ( PyCFunction ) Wave_getLifetime,
88
METH_NOARGS, "()-Return Wave lifetime"},
89
{"setLifetime", ( PyCFunction ) Wave_setLifetime, METH_VARARGS,
87
90
"()- Sets Wave lifetime"},
160
162
/* Function: M_Wave_New */
161
163
/* Python equivalent: Blender.Effect.Wave.New */
162
164
/*****************************************************************************/
163
PyObject *M_Wave_New(PyObject *self, PyObject *args)
165
PyObject *M_Wave_New( PyObject * self, PyObject * args )
166
BPy_Effect *pyeffect;
167
Effect *bleffect = 0;
169
bleffect = add_effect(type);
170
if (bleffect == NULL)
171
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
172
"couldn't create Effect Data in Blender"));
174
pyeffect = (BPy_Effect *)PyObject_NEW(BPy_Effect, &Effect_Type);
177
if (pyeffect == NULL) return (EXPP_ReturnPyObjError (PyExc_MemoryError,
178
"couldn't create Effect Data object"));
180
pyeffect->effect = bleffect;
182
return (PyObject *)pyeffect;
168
BPy_Effect *pyeffect;
169
Effect *bleffect = 0;
171
bleffect = add_effect( type );
172
if( bleffect == NULL )
173
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
174
"couldn't create Effect Data in Blender" ) );
176
pyeffect = ( BPy_Effect * ) PyObject_NEW( BPy_Effect, &Effect_Type );
179
if( pyeffect == NULL )
180
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
181
"couldn't create Effect Data object" ) );
183
pyeffect->effect = bleffect;
185
return ( PyObject * ) pyeffect;
186
189
/*****************************************************************************/
187
190
/* Function: M_Wave_Get */
188
191
/* Python equivalent: Blender.Effect.Wave.Get */
189
192
/*****************************************************************************/
190
PyObject *M_Wave_Get(PyObject *self, PyObject *args)
193
PyObject *M_Wave_Get( PyObject * self, PyObject * args )
192
/*arguments : string object name
193
int : position of effect in the obj's effect list */
197
BPy_Wave *wanted_eff;
200
if (!PyArg_ParseTuple(args, "si", &name, &num ))
201
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
202
"expected string int argument"));
204
object_iter = G.main->object.first;
205
if (!object_iter)return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
206
"Scene contains no object"));
210
if (strcmp(name,object_iter->id.name+2))
212
object_iter = object_iter->id.next;
217
if (object_iter->effect.first != NULL)
219
eff = object_iter->effect.first;
222
if (eff->type != EFF_WAVE)continue;
225
return(EXPP_ReturnPyObjError(PyExc_AttributeError,"bject"));
227
wanted_eff = (BPy_Wave *)PyObject_NEW(BPy_Wave, &Wave_Type);
228
wanted_eff->wave = eff;
229
return (PyObject*)wanted_eff;
231
object_iter = object_iter->id.next;
195
/*arguments : string object name
196
int : position of effect in the obj's effect list */
200
BPy_Wave *wanted_eff;
203
if( !PyArg_ParseTuple( args, "si", &name, &num ) )
204
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
205
"expected string int argument" ) );
207
object_iter = G.main->object.first;
209
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
210
"Scene contains no object" ) );
212
while( object_iter ) {
213
if( strcmp( name, object_iter->id.name + 2 ) ) {
214
object_iter = object_iter->id.next;
219
if( object_iter->effect.first != NULL ) {
220
eff = object_iter->effect.first;
221
for( i = 0; i < num; i++ ) {
222
if( eff->type != EFF_WAVE )
226
return ( EXPP_ReturnPyObjError
227
( PyExc_AttributeError,
231
( BPy_Wave * ) PyObject_NEW( BPy_Wave,
233
wanted_eff->wave = eff;
234
return ( PyObject * ) wanted_eff;
236
object_iter = object_iter->id.next;
238
Py_INCREF( Py_None );
237
242
/*****************************************************************************/
238
243
/* Function: Wave_Init */
239
244
/*****************************************************************************/
240
PyObject *Wave_Init (void)
244
Wave_Type.ob_type = &PyType_Type;
245
submodule = Py_InitModule3("Blender.Wave",M_Wave_methods, M_Wave_doc);
249
/*****************************************************************************/
250
/* Python BPy_Wave methods: */
251
/*****************************************************************************/
253
PyObject *Wave_getStartx(BPy_Wave *self)
255
WaveEff*ptr = (WaveEff*)self->wave;
256
return PyFloat_FromDouble(ptr->startx);
259
PyObject *Wave_setStartx(BPy_Wave *self,PyObject *args)
261
WaveEff*ptr = (WaveEff*)self->wave;
263
if (!PyArg_ParseTuple(args, "f", &val ))
264
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
265
"expected float argument"));
271
PyObject *Wave_getStarty(BPy_Wave *self)
273
WaveEff*ptr = (WaveEff*)self->wave;
274
return PyFloat_FromDouble(ptr->starty);
277
PyObject *Wave_setStarty(BPy_Wave *self,PyObject *args)
279
WaveEff*ptr = (WaveEff*)self->wave;
281
if (!PyArg_ParseTuple(args, "f", &val ))
282
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
283
"expected float argument"));
289
PyObject *Wave_getHeight(BPy_Wave *self)
291
WaveEff*ptr = (WaveEff*)self->wave;
292
return PyFloat_FromDouble(ptr->height);
295
PyObject *Wave_setHeight(BPy_Wave *self,PyObject *args)
297
WaveEff*ptr = (WaveEff*)self->wave;
299
if (!PyArg_ParseTuple(args, "f", &val ))
300
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
301
"expected float argument"));
307
PyObject *Wave_getWidth(BPy_Wave *self)
309
WaveEff*ptr = (WaveEff*)self->wave;
310
return PyFloat_FromDouble(ptr->width);
313
PyObject *Wave_setWidth(BPy_Wave *self,PyObject *args)
317
if (!PyArg_ParseTuple(args, "f", &val ))
318
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
319
"expected float argument"));
320
ptr = (WaveEff*)self->wave;
326
PyObject *Wave_getNarrow(BPy_Wave *self)
328
WaveEff*ptr = (WaveEff*)self->wave;
329
return PyFloat_FromDouble(ptr->narrow);
332
PyObject *Wave_setNarrow(BPy_Wave *self,PyObject *args)
336
if (!PyArg_ParseTuple(args, "f", &val ))
337
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
338
"expected float argument"));
339
ptr = (WaveEff*)self->wave;
345
PyObject *Wave_getSpeed(BPy_Wave *self)
347
WaveEff*ptr = (WaveEff*)self->wave;
348
return PyFloat_FromDouble(ptr->speed);
351
PyObject *Wave_setSpeed(BPy_Wave *self,PyObject *args)
355
if (!PyArg_ParseTuple(args, "f", &val ))
356
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
357
"expected float argument"));
358
ptr = (WaveEff*)self->wave;
364
PyObject *Wave_getMinfac(BPy_Wave *self)
366
WaveEff*ptr = (WaveEff*)self->wave;
367
return PyFloat_FromDouble(ptr->minfac);
370
PyObject *Wave_setMinfac(BPy_Wave *self,PyObject *args)
374
if (!PyArg_ParseTuple(args, "f", &val ))
375
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
376
"expected float argument"));
377
ptr = (WaveEff*)self->wave;
385
PyObject *Wave_getDamp(BPy_Wave *self)
387
WaveEff*ptr = (WaveEff*)self->wave;
388
return PyFloat_FromDouble(ptr->damp);
391
PyObject *Wave_setDamp(BPy_Wave *self,PyObject *args)
395
if (!PyArg_ParseTuple(args, "f", &val ))
396
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
397
"expected float argument"));
398
ptr = (WaveEff*)self->wave;
404
PyObject *Wave_getTimeoffs(BPy_Wave *self)
406
WaveEff*ptr = (WaveEff*)self->wave;
407
return PyFloat_FromDouble(ptr->timeoffs);
410
PyObject *Wave_setTimeoffs(BPy_Wave *self,PyObject *args)
414
if (!PyArg_ParseTuple(args, "f", &val ))
415
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
416
"expected float argument"));
417
ptr = (WaveEff*)self->wave;
423
PyObject *Wave_getLifetime(BPy_Wave *self)
425
WaveEff*ptr = (WaveEff*)self->wave;
426
return PyFloat_FromDouble(ptr->lifetime);
429
PyObject *Wave_setLifetime(BPy_Wave *self,PyObject *args)
433
if (!PyArg_ParseTuple(args, "f", &val ))
434
return(EXPP_ReturnPyObjError(PyExc_AttributeError,\
435
"expected float argument"));
436
ptr = (WaveEff*)self->wave;
245
PyObject *Wave_Init( void )
249
Wave_Type.ob_type = &PyType_Type;
251
Py_InitModule3( "Blender.Wave", M_Wave_methods, M_Wave_doc );
252
return ( submodule );
255
/*****************************************************************************/
256
/* Python BPy_Wave methods: */
257
/*****************************************************************************/
259
PyObject *Wave_getStartx( BPy_Wave * self )
261
WaveEff *ptr = ( WaveEff * ) self->wave;
262
return PyFloat_FromDouble( ptr->startx );
265
PyObject *Wave_setStartx( BPy_Wave * self, PyObject * args )
267
WaveEff *ptr = ( WaveEff * ) self->wave;
269
if( !PyArg_ParseTuple( args, "f", &val ) )
270
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
271
"expected float argument" ) );
273
Py_INCREF( Py_None );
277
PyObject *Wave_getStarty( BPy_Wave * self )
279
WaveEff *ptr = ( WaveEff * ) self->wave;
280
return PyFloat_FromDouble( ptr->starty );
283
PyObject *Wave_setStarty( BPy_Wave * self, PyObject * args )
285
WaveEff *ptr = ( WaveEff * ) self->wave;
287
if( !PyArg_ParseTuple( args, "f", &val ) )
288
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
289
"expected float argument" ) );
291
Py_INCREF( Py_None );
295
PyObject *Wave_getHeight( BPy_Wave * self )
297
WaveEff *ptr = ( WaveEff * ) self->wave;
298
return PyFloat_FromDouble( ptr->height );
301
PyObject *Wave_setHeight( BPy_Wave * self, PyObject * args )
303
WaveEff *ptr = ( WaveEff * ) self->wave;
305
if( !PyArg_ParseTuple( args, "f", &val ) )
306
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
307
"expected float argument" ) );
309
Py_INCREF( Py_None );
313
PyObject *Wave_getWidth( BPy_Wave * self )
315
WaveEff *ptr = ( WaveEff * ) self->wave;
316
return PyFloat_FromDouble( ptr->width );
319
PyObject *Wave_setWidth( BPy_Wave * self, PyObject * args )
323
if( !PyArg_ParseTuple( args, "f", &val ) )
324
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
325
"expected float argument" ) );
326
ptr = ( WaveEff * ) self->wave;
328
Py_INCREF( Py_None );
332
PyObject *Wave_getNarrow( BPy_Wave * self )
334
WaveEff *ptr = ( WaveEff * ) self->wave;
335
return PyFloat_FromDouble( ptr->narrow );
338
PyObject *Wave_setNarrow( BPy_Wave * self, PyObject * args )
342
if( !PyArg_ParseTuple( args, "f", &val ) )
343
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
344
"expected float argument" ) );
345
ptr = ( WaveEff * ) self->wave;
347
Py_INCREF( Py_None );
351
PyObject *Wave_getSpeed( BPy_Wave * self )
353
WaveEff *ptr = ( WaveEff * ) self->wave;
354
return PyFloat_FromDouble( ptr->speed );
357
PyObject *Wave_setSpeed( BPy_Wave * self, PyObject * args )
361
if( !PyArg_ParseTuple( args, "f", &val ) )
362
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
363
"expected float argument" ) );
364
ptr = ( WaveEff * ) self->wave;
366
Py_INCREF( Py_None );
370
PyObject *Wave_getMinfac( BPy_Wave * self )
372
WaveEff *ptr = ( WaveEff * ) self->wave;
373
return PyFloat_FromDouble( ptr->minfac );
376
PyObject *Wave_setMinfac( BPy_Wave * self, PyObject * args )
380
if( !PyArg_ParseTuple( args, "f", &val ) )
381
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
382
"expected float argument" ) );
383
ptr = ( WaveEff * ) self->wave;
385
Py_INCREF( Py_None );
391
PyObject *Wave_getDamp( BPy_Wave * self )
393
WaveEff *ptr = ( WaveEff * ) self->wave;
394
return PyFloat_FromDouble( ptr->damp );
397
PyObject *Wave_setDamp( BPy_Wave * self, PyObject * args )
401
if( !PyArg_ParseTuple( args, "f", &val ) )
402
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
403
"expected float argument" ) );
404
ptr = ( WaveEff * ) self->wave;
406
Py_INCREF( Py_None );
410
PyObject *Wave_getTimeoffs( BPy_Wave * self )
412
WaveEff *ptr = ( WaveEff * ) self->wave;
413
return PyFloat_FromDouble( ptr->timeoffs );
416
PyObject *Wave_setTimeoffs( BPy_Wave * self, PyObject * args )
420
if( !PyArg_ParseTuple( args, "f", &val ) )
421
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
422
"expected float argument" ) );
423
ptr = ( WaveEff * ) self->wave;
425
Py_INCREF( Py_None );
429
PyObject *Wave_getLifetime( BPy_Wave * self )
431
WaveEff *ptr = ( WaveEff * ) self->wave;
432
return PyFloat_FromDouble( ptr->lifetime );
435
PyObject *Wave_setLifetime( BPy_Wave * self, PyObject * args )
439
if( !PyArg_ParseTuple( args, "f", &val ) )
440
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
441
"expected float argument" ) );
442
ptr = ( WaveEff * ) self->wave;
444
Py_INCREF( Py_None );
441
448
/*****************************************************************************/
442
449
/* Function: WaveDeAlloc */
443
/* Description: This is a callback function for the BPy_Wave type. It is */
450
/* Description: This is a callback function for the BPy_Wave type. It is */
444
451
/* the destructor function. */
445
452
/*****************************************************************************/
446
void WaveDeAlloc (BPy_Wave *self)
453
void WaveDeAlloc( BPy_Wave * self )
448
WaveEff*ptr = (WaveEff*)self->wave;
455
WaveEff *ptr = ( WaveEff * ) self->wave;
452
459
/*****************************************************************************/
453
460
/* Function: WaveGetAttr */
454
/* Description: This is a callback function for the BPy_Wave type. It is */
455
/* the function that accesses BPy_Wave "member variables" and */
461
/* Description: This is a callback function for the BPy_Wave type. It is */
462
/* the function that accesses BPy_Wave "member variables" and */
457
464
/*****************************************************************************/
459
PyObject *WaveGetAttr (BPy_Wave *self, char *name)
466
PyObject *WaveGetAttr( BPy_Wave * self, char *name )
461
if (!strcmp(name,"lifetime"))return Wave_getLifetime( self);
462
else if (!strcmp(name,"timeoffs"))return Wave_getTimeoffs( self);
463
else if (!strcmp(name,"damp"))return Wave_getDamp( self);
464
else if (!strcmp(name,"minfac"))return Wave_getMinfac( self);
465
else if (!strcmp(name,"speed"))return Wave_getSpeed( self);
466
else if (!strcmp(name,"narrow"))return Wave_getNarrow( self);
467
else if (!strcmp(name,"width"))return Wave_getWidth( self);
468
else if (!strcmp(name,"height"))return Wave_getHeight( self);
469
else if (!strcmp(name,"startx"))return Wave_getStartx( self);
470
else if (!strcmp(name,"starty"))return Wave_getStarty( self);
471
return Py_FindMethod(BPy_Wave_methods, (PyObject *)self, name);
468
if( !strcmp( name, "lifetime" ) )
469
return Wave_getLifetime( self );
470
else if( !strcmp( name, "timeoffs" ) )
471
return Wave_getTimeoffs( self );
472
else if( !strcmp( name, "damp" ) )
473
return Wave_getDamp( self );
474
else if( !strcmp( name, "minfac" ) )
475
return Wave_getMinfac( self );
476
else if( !strcmp( name, "speed" ) )
477
return Wave_getSpeed( self );
478
else if( !strcmp( name, "narrow" ) )
479
return Wave_getNarrow( self );
480
else if( !strcmp( name, "width" ) )
481
return Wave_getWidth( self );
482
else if( !strcmp( name, "height" ) )
483
return Wave_getHeight( self );
484
else if( !strcmp( name, "startx" ) )
485
return Wave_getStartx( self );
486
else if( !strcmp( name, "starty" ) )
487
return Wave_getStarty( self );
488
return Py_FindMethod( BPy_Wave_methods, ( PyObject * ) self, name );
474
491
/*****************************************************************************/
475
492
/* Function: WaveSetAttr */
476
/* Description: This is a callback function for the BPy_Wave type. It is the */
493
/* Description: This is a callback function for the BPy_Wave type. It is the */
477
494
/* function that sets Wave Data attributes (member variables). */
478
495
/*****************************************************************************/
479
int WaveSetAttr (BPy_Wave *self, char *name, PyObject *value)
496
int WaveSetAttr( BPy_Wave * self, char *name, PyObject * value )
482
PyObject *error = NULL;
484
valtuple = Py_BuildValue("(N)", value);
487
return EXPP_ReturnIntError(PyExc_MemoryError,
488
"ParticleSetAttr: couldn't create PyTuple");
490
if (!strcmp(name,"lifetime"))error = Wave_setLifetime( self,valtuple);
491
else if (!strcmp(name,"timeoffs"))error = Wave_setTimeoffs( self,valtuple);
492
else if (!strcmp(name,"damp")) error = Wave_setDamp( self,valtuple);
493
else if (!strcmp(name,"minfac")) error = Wave_setMinfac( self,valtuple);
494
else if (!strcmp(name,"speed")) error = Wave_setSpeed( self,valtuple);
495
else if (!strcmp(name,"narrow")) error = Wave_setNarrow( self,valtuple);
496
else if (!strcmp(name,"width")) error = Wave_setWidth( self,valtuple);
497
else if (!strcmp(name,"height")) error = Wave_setHeight( self,valtuple);
498
else if (!strcmp(name,"startx")) error = Wave_setStartx( self,valtuple);
499
else if (!strcmp(name,"starty")) error = Wave_setStarty( self,valtuple);
505
if ((strcmp (name, "Types") == 0) ||
506
(strcmp (name, "Modes") == 0))
507
return (EXPP_ReturnIntError (PyExc_AttributeError,
508
"constant dictionary -- cannot be changed"));
511
return (EXPP_ReturnIntError (PyExc_KeyError,
512
"attribute not found"));
515
/*Py_DECREF(valtuple);*/
517
if (error != Py_None) return -1;
499
PyObject *error = NULL;
501
valtuple = Py_BuildValue( "(N)", value );
504
return EXPP_ReturnIntError( PyExc_MemoryError,
505
"ParticleSetAttr: couldn't create PyTuple" );
507
if( !strcmp( name, "lifetime" ) )
508
error = Wave_setLifetime( self, valtuple );
509
else if( !strcmp( name, "timeoffs" ) )
510
error = Wave_setTimeoffs( self, valtuple );
511
else if( !strcmp( name, "damp" ) )
512
error = Wave_setDamp( self, valtuple );
513
else if( !strcmp( name, "minfac" ) )
514
error = Wave_setMinfac( self, valtuple );
515
else if( !strcmp( name, "speed" ) )
516
error = Wave_setSpeed( self, valtuple );
517
else if( !strcmp( name, "narrow" ) )
518
error = Wave_setNarrow( self, valtuple );
519
else if( !strcmp( name, "width" ) )
520
error = Wave_setWidth( self, valtuple );
521
else if( !strcmp( name, "height" ) )
522
error = Wave_setHeight( self, valtuple );
523
else if( !strcmp( name, "startx" ) )
524
error = Wave_setStartx( self, valtuple );
525
else if( !strcmp( name, "starty" ) )
526
error = Wave_setStarty( self, valtuple );
530
Py_DECREF( valtuple );
532
if( ( strcmp( name, "Types" ) == 0 ) ||
533
( strcmp( name, "Modes" ) == 0 ) )
534
return ( EXPP_ReturnIntError( PyExc_AttributeError,
535
"constant dictionary -- cannot be changed" ) );
538
return ( EXPP_ReturnIntError( PyExc_KeyError,
539
"attribute not found" ) );
542
/*Py_DECREF(valtuple); */
544
if( error != Py_None )
547
Py_DECREF( Py_None );
523
551
/*****************************************************************************/
524
552
/* Function: WavePrint */
525
/* Description: This is a callback function for the BPy_Wave type. It */
553
/* Description: This is a callback function for the BPy_Wave type. It */
526
554
/* builds a meaninful string to 'print' wave objects. */
527
555
/*****************************************************************************/
528
int WavePrint(BPy_Wave *self, FILE *fp, int flags)
556
int WavePrint( BPy_Wave * self, FILE * fp, int flags )
531
printf("I'm a wave...Cool, no?");
559
printf( "I'm a wave...Cool, no?" );
535
563
/*****************************************************************************/
536
564
/* Function: WaveRepr */
537
/* Description: This is a callback function for the BPy_Wave type. It */
565
/* Description: This is a callback function for the BPy_Wave type. It */
538
566
/* builds a meaninful string to represent wave objects. */
539
567
/*****************************************************************************/
540
PyObject *WaveRepr (BPy_Wave *self)
545
PyObject* WaveCreatePyObject (struct Effect *wave)
547
BPy_Wave * blen_object;
550
blen_object = (BPy_Wave*)PyObject_NEW (BPy_Wave, &Wave_Type);
552
if (blen_object == NULL)
556
blen_object->wave = wave;
557
return ((PyObject*)blen_object);
561
int WaveCheckPyObject (PyObject *py_obj)
563
return (py_obj->ob_type == &Wave_Type);
567
struct Wave* WaveFromPyObject (PyObject *py_obj)
571
blen_obj = (BPy_Wave*)py_obj;
572
return ((struct Wave*)blen_obj->wave);
568
PyObject *WaveRepr( BPy_Wave * self )
573
PyObject *WaveCreatePyObject( struct Effect * wave )
575
BPy_Wave *blen_object;
578
blen_object = ( BPy_Wave * ) PyObject_NEW( BPy_Wave, &Wave_Type );
580
if( blen_object == NULL ) {
583
blen_object->wave = wave;
584
return ( ( PyObject * ) blen_object );
588
int WaveCheckPyObject( PyObject * py_obj )
590
return ( py_obj->ob_type == &Wave_Type );
594
struct Wave *WaveFromPyObject( PyObject * py_obj )
598
blen_obj = ( BPy_Wave * ) py_obj;
599
return ( ( struct Wave * ) blen_obj->wave );
added
removed
source/blender/python/api2_2x/Wave.c
