b7b94dc93e12a4080a6130e2a3576eb4fc9bd6a3
[blender.git] / source / blender / python / api2_2x / BezTriple.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * This is a new part of Blender.
24  *
25  * Contributor(s): Jacques Guignot RIP 2005,
26  *    Stephen Swaney, Ken Hughes
27  *
28  * ***** END GPL LICENSE BLOCK *****
29  */
30
31 #include "BezTriple.h" /*This must come first */
32 #include "DNA_ipo_types.h"
33
34 #include "MEM_guardedalloc.h"
35 #include "gen_utils.h"
36
37
38 /***************************************************************************
39   Python API function prototypes for the BezTriple module.                  
40 ***************************************************************************/
41 static PyObject *M_BezTriple_New( PyObject * self, PyObject * args );
42 static PyObject *M_BezTriple_Get( PyObject * self, PyObject * args );
43
44 /*************************************
45  Doc strings for the BezTriple module
46 *************************************/
47
48 static char M_BezTriple_doc[] = "The Blender BezTriple module\n";
49
50 /****************************************************************************
51   Python BPy_BezTriple instance methods declarations:                        
52 ****************************************************************************/
53 static PyObject *BezTriple_oldsetPoints( BPy_BezTriple * self, PyObject * args );
54 static int BezTriple_setPoints( BPy_BezTriple * self, PyObject * args );
55 static PyObject *BezTriple_getPoints( BPy_BezTriple * self );
56 static PyObject *BezTriple_getTriple( BPy_BezTriple * self );
57
58 /****************************************************************************
59  Python method structure definition for Blender.BezTriple module:          
60 ****************************************************************************/
61
62 struct PyMethodDef M_BezTriple_methods[] = {
63         {"New", ( PyCFunction ) M_BezTriple_New, METH_VARARGS | METH_KEYWORDS,
64          0},
65 /*      {"New", ( PyCFunction ) M_BezTriple_New, METH_O, 0}, */
66         {"Get", M_BezTriple_Get, METH_VARARGS, 0},
67         {"get", M_BezTriple_Get, METH_VARARGS, 0},
68         {NULL, NULL, 0, NULL}
69 };
70
71 /*****************************************************************************/
72 /* Python BPy_BezTriple methods table:                                        */
73 /*****************************************************************************/
74 static PyMethodDef BPy_BezTriple_methods[] = {
75         /* name, method, flags, doc */
76         {"setPoints", ( PyCFunction ) BezTriple_oldsetPoints, METH_VARARGS,
77          "(str) - Change BezTriple point coordinates"},
78         {"getPoints", ( PyCFunction ) BezTriple_getPoints, METH_NOARGS,
79          "() - return BezTriple knot point x and y coordinates"},
80         {"getTriple", ( PyCFunction ) BezTriple_getTriple, METH_NOARGS,
81          "() - return list of 3 floating point triplets.  order is H1, knot, H2"},
82         {NULL, NULL, 0, NULL}
83 };
84
85 /****************************************************************************
86  Function:              M_BezTriple_New                                   
87  Python equivalent:     Blender.BezTriple.New                             
88 ****************************************************************************/
89
90 static PyObject *M_BezTriple_New( PyObject* self, PyObject * args )
91 {
92         float numbuf[9];
93         PyObject* in_args = NULL;
94         int length;
95
96         /* accept list, tuple, or 3 or 9 args (which better be floats) */
97
98         length = PyTuple_Size( args );
99         if( length == 3 || length == 9 )
100                 in_args = args;
101         else if( !PyArg_ParseTuple( args, "|O", &in_args) )
102                 goto TypeError;
103
104         if( !in_args ) {
105                 numbuf[0] = 0.0f; numbuf[1] = 0.0f; numbuf[2] = 0.0f;
106                 numbuf[3] = 0.0f; numbuf[4] = 0.0f; numbuf[5] = 0.0f;
107                 numbuf[6] = 0.0f; numbuf[7] = 0.0f; numbuf[8] = 0.0f;
108         } else {
109                 int i, length;
110                 if( !PySequence_Check( in_args ) )
111                         goto TypeError;
112
113                 length = PySequence_Length( in_args );
114                 if( length != 9 && length != 3 )
115                         goto TypeError;
116                 
117                 for( i = 0; i < length; i++ ) {
118                         PyObject *item, *pyfloat;
119                         item = PySequence_ITEM( in_args, i);
120                         if( !item )
121                                 goto TypeError;
122                         pyfloat = PyNumber_Float( item );
123                         Py_DECREF( item );
124                         if( !pyfloat )
125                                 goto TypeError;
126                         numbuf[i] = ( float )PyFloat_AS_DOUBLE( pyfloat );
127                         Py_DECREF( pyfloat );
128                 }
129
130                 if( length == 3 ) {
131                         numbuf[3] = numbuf[0]; numbuf[6] = numbuf[0];
132                         numbuf[4] = numbuf[1]; numbuf[7] = numbuf[1];
133                         numbuf[5] = numbuf[2]; numbuf[8] = numbuf[2];
134                 }
135         }
136
137         return newBezTriple( numbuf );
138
139 TypeError:
140         return EXPP_ReturnPyObjError( PyExc_TypeError,
141                         "expected sequence of 3 or 9 floats or nothing" );
142 }
143
144 /****************************************************************************
145  Function:              M_BezTriple_Get                                   
146  Python equivalent:     Blender.BezTriple.Get                             
147  Description:           Receives a string and returns the ipo data obj  
148                         whose name matches the string.  If no argument is  
149                         passed in, a list of all ipo data names in the  
150                         current scene is returned.                         
151 ****************************************************************************/
152 static PyObject *M_BezTriple_Get( PyObject * self, PyObject * args )
153 {
154         return 0;
155 }
156
157 /****************************************************************************
158  Function:    BezTriple_dealloc                                            
159  Description: This is a callback function for the BPy_BezTriple type. It is  
160               the destructor function.                                     
161 ****************************************************************************/
162 static void BezTriple_dealloc( BPy_BezTriple * self )
163 {
164         if( self->own_memory)
165                 MEM_freeN( self->beztriple );
166         
167         PyObject_DEL( self );
168 }
169
170 /*
171  * BezTriple_getTriple
172  * 
173  * Get the coordinate data for a BezTriple.  Returns a list of 3 points.
174  * List order is handle1, knot, handle2.  each point consists of a list
175  * of x,y,z float values.
176  */
177
178 static PyObject *BezTriple_getTriple( BPy_BezTriple * self )
179 {
180         BezTriple *bezt = self->beztriple;
181         return Py_BuildValue( "[[fff][fff][fff]]",
182                                        bezt->vec[0][0], bezt->vec[0][1], bezt->vec[0][2],
183                                        bezt->vec[1][0], bezt->vec[1][1], bezt->vec[1][2],
184                                        bezt->vec[2][0], bezt->vec[2][1], bezt->vec[2][2] );
185 }
186
187 /*
188  * BezTriple_setTriple
189  *
190  * Set the cordinate data for a BezTriple.  Takes a sequence of 3 points,
191  * of the same format at BezTriple_getTriple.
192  */
193
194 static int BezTriple_setTriple( BPy_BezTriple * self, PyObject * args )
195 {
196         int i, j;
197         struct BezTriple *bezt = self->beztriple;
198         float vec[3][3];
199
200         if( !PySequence_Check( args ) || PySequence_Size( args ) != 3 )
201                 return EXPP_ReturnIntError( PyExc_TypeError,
202                                 "expected three sequences of three floats" );
203
204         for( i = 0; i < 3; i++ ) {
205                 PyObject *obj1 = PySequence_ITEM( args, i );
206                 if( !PySequence_Check( obj1 ) || PySequence_Size( obj1 ) != 3 ) {
207                         Py_DECREF( obj1 );
208                         return EXPP_ReturnIntError( PyExc_TypeError,
209                                         "expected three sequences of three floats" );
210                 }
211                 for( j = 0; j < 3; j++ ) {
212                         PyObject *obj2 = PySequence_ITEM( obj1, j );
213                         PyObject *num = PyNumber_Float( obj2 );
214                         Py_DECREF( obj2 );
215
216                         if( !num ) {
217                                 Py_DECREF( obj1 );
218                                 return EXPP_ReturnIntError( PyExc_ValueError,
219                                                 "expected float parameter" );
220                         }
221                         vec[i][j] = ( float )PyFloat_AsDouble( num );
222                         Py_DECREF( num );
223                 }
224                 Py_DECREF( obj1 );
225         }
226
227         for( i = 0; i < 3; i++ )
228                 for( j = 0; j < 3; j++ )
229                         bezt->vec[i][j] = vec[i][j];
230
231         return 0;
232 }
233
234 /*
235  * BezTriple_getPoint
236  * 
237  * Get the coordinate data for a BezTriple.  Returns the control point,
238  * as a list of x,y float values.
239  */
240
241 static PyObject *BezTriple_getPoints( BPy_BezTriple * self )
242 {
243         BezTriple *bezt = self->beztriple;
244         return Py_BuildValue( "[ff]", bezt->vec[1][0], bezt->vec[1][1] );
245 }
246
247 /*
248  * BezTriple_setPoint
249  * 
250  * Set the coordinate data for a BezTriple.  Accepts the x,y for the control
251  * point and builds handle values based on control point.
252  */
253
254 static int BezTriple_setPoints( BPy_BezTriple * self, PyObject * args )
255 {
256         int i;
257         struct BezTriple *bezt = self->beztriple;
258         float vec[2];
259
260         if( !PySequence_Check( args ) || PySequence_Size( args ) != 2 )
261                 return EXPP_ReturnIntError( PyExc_TypeError,
262                                 "expected sequence of two floats" );
263
264         for( i = 0; i < 2; i++ ) {
265                 PyObject *obj = PySequence_ITEM( args, i );
266                 PyObject *num = PyNumber_Float( obj );
267                 Py_DECREF( obj );
268
269                 if( !num )
270                         return EXPP_ReturnIntError( PyExc_ValueError,
271                                         "expected float parameter" );
272                 vec[i] = ( float )PyFloat_AsDouble( num );
273                 Py_DECREF( num );
274         }
275
276         for( i = 0; i < 2; i++ ) {
277                 bezt->vec[0][i] = vec[i] - 1;
278                 bezt->vec[1][i] = vec[i];
279                 bezt->vec[2][i] = vec[i] + 1;
280         }
281
282         /* experimental fussing with handles - ipo.c: calchandles_ipocurve */
283         if( bezt->vec[0][0] > bezt->vec[1][0] )
284                 bezt->vec[0][0] = bezt->vec[1][0];
285
286         if( bezt->vec[2][0] < bezt->vec[1][0] )
287                 bezt->vec[2][0] = bezt->vec[1][0];
288
289         return 0;
290 }
291
292 static PyObject *BezTriple_getTilt( BPy_BezTriple * self )
293 {
294         return PyFloat_FromDouble( self->beztriple->alfa );
295 }
296
297 static int BezTriple_setTilt( BPy_BezTriple * self, PyObject *value )
298 {
299         PyObject *num = PyNumber_Float( value );
300
301         if( !num )
302                 return EXPP_ReturnIntError( PyExc_TypeError, "expected a float" );
303
304         self->beztriple->alfa = (float)PyFloat_AsDouble( num );
305         Py_DECREF( num );
306         return 0;
307 }
308
309 static PyObject *BezTriple_getWeight( BPy_BezTriple * self )
310 {
311         return PyFloat_FromDouble( self->beztriple->weight );
312 }
313
314 static int BezTriple_setWeight( BPy_BezTriple * self, PyObject *value )
315 {
316         PyObject *num = PyNumber_Float( value );
317
318         if( !num )
319                 return EXPP_ReturnIntError( PyExc_TypeError, "expected a float" );
320
321         self->beztriple->weight = (float)PyFloat_AsDouble( num );
322         Py_DECREF( num );
323         return 0;
324 }
325
326 static PyObject *BezTriple_getRadius( BPy_BezTriple * self )
327 {
328         return PyFloat_FromDouble( self->beztriple->radius );
329 }
330
331 static int BezTriple_setRadius( BPy_BezTriple * self, PyObject *value )
332 {
333         PyObject *num = PyNumber_Float( value );
334
335         if( !num )
336                 return EXPP_ReturnIntError( PyExc_TypeError, "expected a float" );
337
338         self->beztriple->radius = (float)PyFloat_AsDouble( num );
339         Py_DECREF( num );
340         return 0;
341 }
342
343 static PyObject *BezTriple_getHide( BPy_BezTriple * self )
344 {
345         return PyInt_FromLong( self->beztriple->hide == IPO_BEZ );
346 }
347
348 static int BezTriple_setHide( BPy_BezTriple * self, PyObject *value )
349 {
350         int param = PyObject_IsTrue( value );
351         if( param == -1 )
352                 return EXPP_ReturnIntError( PyExc_TypeError,
353                                 "expected True/False or 0/1" );
354         
355         if( param )
356                 self->beztriple->hide = IPO_BEZ;
357         else
358                 self->beztriple->hide = 0;
359         return 0;
360 }
361
362 static PyObject *BezTriple_getSelects( BPy_BezTriple * self )
363 {
364         BezTriple *bezt = self->beztriple;
365
366         return Py_BuildValue( "[iii]", bezt->f1, bezt->f2, bezt->f3 );
367 }
368
369 static int BezTriple_setSelects( BPy_BezTriple * self, PyObject *args )
370 {
371         struct BezTriple *bezt = self->beztriple;
372         PyObject *ob1, *ob2, *ob3;
373         int param1, param2, param3;
374
375        /* only accept a sequence of three booleans */
376
377         if( !PySequence_Check( args ) || PySequence_Size( args ) != 3 )
378                 return EXPP_ReturnIntError( PyExc_TypeError,
379                                 "expected sequence of three integers" );
380
381         ob1 = PySequence_ITEM( args, 0 );
382         ob2 = PySequence_ITEM( args, 1 );
383         ob3 = PySequence_ITEM( args, 2 );
384
385         param1 = PyObject_IsTrue( ob1 );
386         param2 = PyObject_IsTrue( ob2 );
387         param3 = PyObject_IsTrue( ob3 );
388         
389         if (param1==-1 || param2==-1 || param3==-1)
390                 return EXPP_ReturnIntError( PyExc_TypeError,
391                                 "expected a sequence of 3 items: True/False or 0/1" );
392         
393        /* assign the selects */
394         bezt->f1 = (char)param1;
395         bezt->f2 = (char)param2;
396         bezt->f3 = (char)param3;
397
398         Py_DECREF( ob1 );
399         Py_DECREF( ob2 );
400         Py_DECREF( ob3 );
401         return 0;
402 }
403
404 static PyObject *BezTriple_getHandles( BPy_BezTriple * self )
405 {
406         BezTriple *bezt = self->beztriple;
407
408         return Py_BuildValue( "[ii]", bezt->h1, bezt->h2 );
409 }
410
411 static int BezTriple_setHandles( BPy_BezTriple * self, PyObject *args )
412 {
413         struct BezTriple *bezt = self->beztriple;
414         PyObject *ob1, *ob2;
415         short h1, h2;
416
417        /* only accept a sequence of two ints */
418
419         if( !PySequence_Check( args ) || PySequence_Size( args ) != 2 )
420                 return EXPP_ReturnIntError( PyExc_TypeError,
421                                 "expected sequence of two integers" );
422
423         ob1 = PySequence_ITEM( args, 0 );
424         ob2 = PySequence_ITEM( args, 1 );
425
426         if( !PyInt_Check( ob1 ) || !PyInt_Check( ob2 ) ) {
427                 Py_DECREF( ob1 );
428                 Py_DECREF( ob2 );
429                 return EXPP_ReturnIntError( PyExc_TypeError,
430                                 "expected sequence of two integers" );
431         }
432
433         h1 = ( short ) PyInt_AsLong( ob1 );
434         h2 = ( short ) PyInt_AsLong( ob2 );
435         Py_DECREF( ob1 );
436         Py_DECREF( ob2 );
437
438         if( h1 < HD_FREE || h2 < HD_FREE ||
439                         h1 > HD_AUTO_ANIM || h2 > HD_AUTO_ANIM )
440                 return EXPP_ReturnIntError( PyExc_ValueError,
441                                 "expected int in range [0,4]" );
442
443        /* assign the handles */
444
445         bezt->h1 = h1;
446         bezt->h2 = h2;
447
448         return 0;
449 }
450
451 /*
452  * Python BezTriple attributes get/set structure
453  */
454
455 static PyGetSetDef BPy_BezTriple_getseters[] = {
456         {"pt",
457          (getter)BezTriple_getPoints, (setter)BezTriple_setPoints,
458          "point knot values",
459          NULL},
460         {"vec",
461          (getter)BezTriple_getTriple, (setter)BezTriple_setTriple,
462          "point handle and knot values",
463          NULL},
464         {"tilt",
465          (getter)BezTriple_getTilt, (setter)BezTriple_setTilt,
466          "point tilt",
467          NULL},
468         {"hide",
469          (getter)BezTriple_getHide, (setter)BezTriple_setHide,
470          "point hide status",
471          NULL},
472         {"selects",
473          (getter)BezTriple_getSelects, (setter)BezTriple_setSelects,
474          "point select statuses",
475          NULL},
476         {"handleTypes",
477          (getter)BezTriple_getHandles, (setter)BezTriple_setHandles,
478          "point handle types",
479          NULL},
480         {"weight",
481          (getter)BezTriple_getWeight, (setter)BezTriple_setWeight,
482          "point weight",
483          NULL},
484         {"radius",
485          (getter)BezTriple_getRadius, (setter)BezTriple_setRadius,
486          "point radius",
487          NULL},
488         {NULL,NULL,NULL,NULL,NULL}  /* Sentinel */
489 };
490
491 /*****************************************************************************/
492 /* Function:    BezTriple_repr                                               */
493 /* Description: This is a callback function for the BPy_BezTriple type. It   */
494 /*              builds a meaninful string to represent BezTriple objects.    */
495 /*****************************************************************************/
496 static PyObject *BezTriple_repr( BPy_BezTriple * self )
497 {
498         char str[512];
499         sprintf( str,
500                 "[BezTriple [%.6f, %.6f, %.6f] [%.6f, %.6f, %.6f] [%.6f, %.6f, %.6f]\n",
501                  self->beztriple->vec[0][0], self->beztriple->vec[0][1], self->beztriple->vec[0][2],
502                  self->beztriple->vec[1][0], self->beztriple->vec[1][1], self->beztriple->vec[1][2],
503                  self->beztriple->vec[2][0], self->beztriple->vec[2][1], self->beztriple->vec[2][2]);
504         return PyString_FromString( str );
505 }
506
507 /************************************************************************
508  *
509  * Python BezTriple_Type structure definition
510  *
511  ************************************************************************/
512
513 PyTypeObject BezTriple_Type = {
514         PyObject_HEAD_INIT( NULL )  /* required py macro */
515         0,                          /* ob_size */
516         /*  For printing, in format "<module>.<name>" */
517         "BezTriple",                /* char *tp_name; */
518         sizeof( BPy_BezTriple ),    /* int tp_basicsize; */
519         0,                          /* tp_itemsize;  For allocation */
520
521         /* Methods to implement standard operations */
522
523         ( destructor ) BezTriple_dealloc,/* destructor tp_dealloc; */
524         NULL,                       /* printfunc tp_print; */
525         NULL,                       /* getattrfunc tp_getattr; */
526         NULL,                       /* setattrfunc tp_setattr; */
527         NULL,                       /* cmpfunc tp_compare; */
528         ( reprfunc ) BezTriple_repr,     /* reprfunc tp_repr; */
529
530         /* Method suites for standard classes */
531
532         NULL,                       /* PyNumberMethods *tp_as_number; */
533         NULL,                                   /* PySequenceMethods *tp_as_sequence; */
534         NULL,                       /* PyMappingMethods *tp_as_mapping; */
535
536         /* More standard operations (here for binary compatibility) */
537
538         NULL,                       /* hashfunc tp_hash; */
539         NULL,                       /* ternaryfunc tp_call; */
540         NULL,                       /* reprfunc tp_str; */
541         NULL,                       /* getattrofunc tp_getattro; */
542         NULL,                       /* setattrofunc tp_setattro; */
543
544         /* Functions to access object as input/output buffer */
545         NULL,                       /* PyBufferProcs *tp_as_buffer; */
546
547   /*** Flags to define presence of optional/expanded features ***/
548         Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
549
550         NULL,                       /*  char *tp_doc;  Documentation string */
551   /*** Assigned meaning in release 2.0 ***/
552         /* call function for all accessible objects */
553         NULL,                       /* traverseproc tp_traverse; */
554
555         /* delete references to contained objects */
556         NULL,                       /* inquiry tp_clear; */
557
558   /***  Assigned meaning in release 2.1 ***/
559   /*** rich comparisons ***/
560         NULL,                       /* richcmpfunc tp_richcompare; */
561
562   /***  weak reference enabler ***/
563         0,                          /* long tp_weaklistoffset; */
564
565   /*** Added in release 2.2 ***/
566         /*   Iterators */
567         NULL,                       /* getiterfunc tp_iter; */
568         NULL,                       /* iternextfunc tp_iternext; */
569
570   /*** Attribute descriptor and subclassing stuff ***/
571         BPy_BezTriple_methods,      /* struct PyMethodDef *tp_methods; */
572         NULL,                       /* struct PyMemberDef *tp_members; */
573         BPy_BezTriple_getseters,    /* struct PyGetSetDef *tp_getset; */
574         NULL,                       /* struct _typeobject *tp_base; */
575         NULL,                       /* PyObject *tp_dict; */
576         NULL,                       /* descrgetfunc tp_descr_get; */
577         NULL,                       /* descrsetfunc tp_descr_set; */
578         0,                          /* long tp_dictoffset; */
579         NULL,                       /* initproc tp_init; */
580         NULL,                       /* allocfunc tp_alloc; */
581         NULL,                       /* newfunc tp_new; */
582         /*  Low-level free-memory routine */
583         NULL,                       /* freefunc tp_free;  */
584         /* For PyObject_IS_GC */
585         NULL,                       /* inquiry tp_is_gc;  */
586         NULL,                       /* PyObject *tp_bases; */
587         /* method resolution order */
588         NULL,                       /* PyObject *tp_mro;  */
589         NULL,                       /* PyObject *tp_cache; */
590         NULL,                       /* PyObject *tp_subclasses; */
591         NULL,                       /* PyObject *tp_weaklist; */
592         NULL
593 };
594
595 static PyObject *M_BezTriple_HandleDict( void )
596 {
597         PyObject *HM = PyConstant_New(  );
598
599         if( HM ) {
600                 BPy_constant *d = ( BPy_constant * ) HM;
601
602                 PyConstant_Insert( d, "FREE", PyInt_FromLong( HD_FREE ) );
603                 PyConstant_Insert( d, "AUTO", PyInt_FromLong( HD_AUTO ) );
604                 PyConstant_Insert( d, "VECT", PyInt_FromLong( HD_VECT ) );
605                 PyConstant_Insert( d, "ALIGN", PyInt_FromLong( HD_ALIGN ) );
606                 PyConstant_Insert( d, "AUTOANIM", PyInt_FromLong( HD_AUTO_ANIM ) );
607         }
608         return HM;
609 }
610
611 /*
612   BezTriple_Init
613 */
614
615 PyObject *BezTriple_Init( void )
616 {
617         PyObject *submodule;
618         PyObject *HandleTypes = M_BezTriple_HandleDict( );
619
620         if( PyType_Ready( &BezTriple_Type ) < 0 )
621                 return NULL;
622
623         submodule = Py_InitModule3( "Blender.BezTriple",
624                                                                 M_BezTriple_methods,
625                                                                 M_BezTriple_doc );
626         if( HandleTypes )
627                 PyModule_AddObject( submodule, "HandleTypes", HandleTypes );
628
629
630         return submodule;
631 }
632
633 /* Three Python BezTriple_Type helper functions needed by the Object module: */
634
635 /****************************************************************************
636  Function:    BezTriple_CreatePyObject                                    
637  Description: This function will create a new BPy_BezTriple from an existing 
638               Blender ipo structure.                                       
639 ****************************************************************************/
640 PyObject *BezTriple_CreatePyObject( BezTriple * bzt )
641 {
642         BPy_BezTriple *pybeztriple;
643
644         pybeztriple =
645                 ( BPy_BezTriple * ) PyObject_NEW( BPy_BezTriple, &BezTriple_Type );
646
647         if( !pybeztriple )
648                 return EXPP_ReturnPyObjError( PyExc_MemoryError,
649                                               "couldn't create BPy_BezTriple object" );
650
651         pybeztriple->beztriple = bzt;
652         pybeztriple->own_memory = 0;
653
654         return ( PyObject * ) pybeztriple;
655 }
656
657
658 /*****************************************************************************/
659 /* Function:    BezTriple_FromPyObject                                      */
660 /* Description: This function returns the Blender beztriple from the given   */
661 /*              PyObject.                                                    */
662 /*****************************************************************************/
663 BezTriple *BezTriple_FromPyObject( PyObject * pyobj )
664 {
665         return ( ( BPy_BezTriple * ) pyobj )->beztriple;
666 }
667
668
669 /*
670   Create a new BezTriple
671   input args is a sequence - either 3 or 9 floats
672 */
673
674 PyObject *newBezTriple( float *numbuf )
675 {
676         int i, j, num;
677         PyObject *pyobj = NULL;
678         BezTriple *bzt = NULL;
679
680         /* create our own beztriple data */
681         bzt = MEM_callocN( sizeof( BezTriple ), "new bpytriple");
682
683         /* check malloc */
684         if( !bzt )
685                 return EXPP_ReturnPyObjError( PyExc_RuntimeError,
686                                                "MEM_callocN failed");
687
688         /* copy the data */
689         num = 0;
690         for( i = 0; i < 3; i++ ) {
691                 for( j = 0; j < 3; j++) {
692                         bzt->vec[i][j] = numbuf[num++];
693                 }
694         }
695         bzt->h1 = HD_ALIGN;
696         bzt->h2 = HD_ALIGN;
697
698         /* wrap it */
699         pyobj = BezTriple_CreatePyObject( bzt );
700
701         /* we own it. must free later */
702         ( ( BPy_BezTriple * )pyobj)->own_memory = 1;
703
704         return pyobj;
705 }
706
707 /* #####DEPRECATED###### */
708
709 static PyObject *BezTriple_oldsetPoints( BPy_BezTriple * self, PyObject * args )
710 {
711         return EXPP_setterWrapper( (void *)self, args,
712                         (setter)BezTriple_setPoints );
713 }