/*
 * $Id: Ipo.c,v 1.34 2004/12/21 01:15:42 stiv Exp $
 *
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version. The Blender
 * Foundation also sells licenses for use in proprietary software under
 * the Blender License.  See http://www.blender.org/BL/ for information
 * about this.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * This is a new part of Blender.
 *
 * Contributor(s): Jacques Guignot, Nathan Letwory
 *
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */

#include "Ipo.h"

#include <BKE_main.h>
#include <BKE_global.h>
#include <BKE_object.h>
#include <BKE_library.h>
#include <BSE_editipo.h>
#include <BLI_blenlib.h>

#include <DNA_curve_types.h>

#include "Ipocurve.h"
#include "constant.h"
#include "gen_utils.h"



/* forward declarations */
char *GetIpoCurveName( IpoCurve * icu );

/*****************************************************************************/
/* Python API function prototypes for the Ipo module.                        */
/*****************************************************************************/
static PyObject *M_Ipo_New( PyObject * self, PyObject * args );
static PyObject *M_Ipo_Get( PyObject * self, PyObject * args );
static PyObject *M_Ipo_Recalc( PyObject * self, PyObject * args );

/*****************************************************************************/
/* The following string definitions are used for documentation strings.      */
/* In Python these will be written to the console when doing a               */
/* Blender.Ipo.__doc__                                                       */
/*****************************************************************************/
char M_Ipo_doc[] = "";
char M_Ipo_New_doc[] = "";
char M_Ipo_Get_doc[] = "";


/*****************************************************************************/
/* Python method structure definition for Blender.Ipo module:             */
/*****************************************************************************/

struct PyMethodDef M_Ipo_methods[] = {
	{"New", ( PyCFunction ) M_Ipo_New, METH_VARARGS | METH_KEYWORDS,
	 M_Ipo_New_doc},
	{"Get", M_Ipo_Get, METH_VARARGS, M_Ipo_Get_doc},
	{"get", M_Ipo_Get, METH_VARARGS, M_Ipo_Get_doc},
	{"Recalc", M_Ipo_Recalc, METH_VARARGS, M_Ipo_Get_doc},
	{NULL, NULL, 0, NULL}
};

/*****************************************************************************/
/* Python BPy_Ipo methods declarations:                                     */
/*****************************************************************************/
static PyObject *Ipo_getName( BPy_Ipo * self );
static PyObject *Ipo_setName( BPy_Ipo * self, PyObject * args );
static PyObject *Ipo_getBlocktype( BPy_Ipo * self );
static PyObject *Ipo_setBlocktype( BPy_Ipo * self, PyObject * args );
static PyObject *Ipo_getRctf( BPy_Ipo * self );
static PyObject *Ipo_setRctf( BPy_Ipo * self, PyObject * args );

static PyObject *Ipo_getCurve( BPy_Ipo * self, PyObject * args );
static PyObject *Ipo_getCurves( BPy_Ipo * self );
static PyObject *Ipo_addCurve( BPy_Ipo * self, PyObject * args );
static PyObject *Ipo_getNcurves( BPy_Ipo * self );
static PyObject *Ipo_getNBezPoints( BPy_Ipo * self, PyObject * args );
static PyObject *Ipo_DeleteBezPoints( BPy_Ipo * self, PyObject * args );
static PyObject *Ipo_getCurveBP( BPy_Ipo * self, PyObject * args );
static PyObject *Ipo_getCurvecurval( BPy_Ipo * self, PyObject * args );
static PyObject *Ipo_EvaluateCurveOn( BPy_Ipo * self, PyObject * args );


static PyObject *Ipo_setCurveBeztriple( BPy_Ipo * self, PyObject * args );
static PyObject *Ipo_getCurveBeztriple( BPy_Ipo * self, PyObject * args );

/*****************************************************************************/
/* Python BPy_Ipo methods table:                                            */
/*****************************************************************************/
static PyMethodDef BPy_Ipo_methods[] = {
	/* name, method, flags, doc */
	{"getName", ( PyCFunction ) Ipo_getName, METH_NOARGS,
	 "() - Return Ipo Data name"},
	{"setName", ( PyCFunction ) Ipo_setName, METH_VARARGS,
	 "(str) - Change Ipo Data name"},
	{"getBlocktype", ( PyCFunction ) Ipo_getBlocktype, METH_NOARGS,
	 "() - Return Ipo blocktype -"},
	{"setBlocktype", ( PyCFunction ) Ipo_setBlocktype, METH_VARARGS,
	 "(str) - Change Ipo blocktype"},
	{"getRctf", ( PyCFunction ) Ipo_getRctf, METH_NOARGS,
	 "() - Return Ipo rctf - "},
	{"setRctf", ( PyCFunction ) Ipo_setRctf, METH_VARARGS,
	 "(str) - Change Ipo rctf"},
	{"addCurve", ( PyCFunction ) Ipo_addCurve, METH_VARARGS,
	 "() - Return Ipo ncurves"},
	{"getNcurves", ( PyCFunction ) Ipo_getNcurves, METH_NOARGS,
	 "() - Return Ipo ncurves"},
	{"getNBezPoints", ( PyCFunction ) Ipo_getNBezPoints, METH_VARARGS,
	 "() - Return curve number of Bez points"},
	{"delBezPoint", ( PyCFunction ) Ipo_DeleteBezPoints, METH_VARARGS,
	 "() - Return curve number of Bez points"},
	{"getCurveBP", ( PyCFunction ) Ipo_getCurveBP, METH_VARARGS,
	 "() - Return Ipo ncurves"},
	{"EvaluateCurveOn", ( PyCFunction ) Ipo_EvaluateCurveOn, METH_VARARGS,
	 "() - Return curve value at given time"},
	{"getCurveCurval", ( PyCFunction ) Ipo_getCurvecurval, METH_VARARGS,
	 "() - Return curval"},
	{"getCurveBeztriple", ( PyCFunction ) Ipo_getCurveBeztriple,
	 METH_VARARGS,
	 "() - Return Ipo ncurves"},
	{"setCurveBeztriple", ( PyCFunction ) Ipo_setCurveBeztriple,
	 METH_VARARGS,
	 "() - Return curval"},
	{"getCurves", ( PyCFunction ) Ipo_getCurves, METH_NOARGS,
	 "() - Return curval"},
	{"getCurve", ( PyCFunction ) Ipo_getCurve, METH_VARARGS,
	 "() - Return curval"},
	{NULL, NULL, 0, NULL}
};

/*****************************************************************************/
/* Python Ipo_Type callback function prototypes:                          */
/*****************************************************************************/
static void IpoDeAlloc( BPy_Ipo * self );
//static int IpoPrint (BPy_Ipo *self, FILE *fp, int flags);
static int IpoSetAttr( BPy_Ipo * self, char *name, PyObject * v );
static PyObject *IpoGetAttr( BPy_Ipo * self, char *name );
static PyObject *IpoRepr( BPy_Ipo * self );

/*****************************************************************************/
/* Python Ipo_Type structure definition:                                  */
/*****************************************************************************/
PyTypeObject Ipo_Type = {
	PyObject_HEAD_INIT( NULL ) /* required macro */ 0,	/* ob_size */
	"Ipo",			/* tp_name */
	sizeof( BPy_Ipo ),	/* tp_basicsize */
	0,			/* tp_itemsize */
	/* methods */
	( destructor ) IpoDeAlloc,	/* tp_dealloc */
	0,			/* tp_print */
	( getattrfunc ) IpoGetAttr,	/* tp_getattr */
	( setattrfunc ) IpoSetAttr,	/* tp_setattr */
	0,			/* tp_compare */
	( reprfunc ) IpoRepr,	/* tp_repr */
	0,			/* tp_as_number */
	0,			/* tp_as_sequence */
	0,			/* tp_as_mapping */
	0,			/* tp_as_hash */
	0, 0, 0, 0, 0, 0,
	0,			/* tp_doc */
	0, 0, 0, 0, 0, 0,
	BPy_Ipo_methods,	/* tp_methods */
	0,			/* tp_members */
};

/*****************************************************************************/
/* Function:              M_Ipo_New                                          */
/* Python equivalent:     Blender.Ipo.New                                    */
/*****************************************************************************/

static PyObject *M_Ipo_New( PyObject * self, PyObject * args )
{
	Ipo *add_ipo( char *name, int idcode );
	char *name = NULL, *code = NULL;
	int idcode = -1;
	BPy_Ipo *pyipo;
	Ipo *blipo;

	if( !PyArg_ParseTuple( args, "ss", &code, &name ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError,
			   "expected string string arguments" ) );

	if( !strcmp( code, "Object" ) )
		idcode = ID_OB;
	if( !strcmp( code, "Camera" ) )
		idcode = ID_CA;
	if( !strcmp( code, "World" ) )
		idcode = ID_WO;
	if( !strcmp( code, "Material" ) )
		idcode = ID_MA;
	if( !strcmp( code, "Texture" ) )
		idcode = ID_TE;
	if( !strcmp( code, "Lamp" ) )
		idcode = ID_LA;
	if( !strcmp( code, "Action" ) )
		idcode = ID_AC;
	if( !strcmp( code, "Constraint" ) )
		idcode = IPO_CO;
	if( !strcmp( code, "Sequence" ) )
		idcode = ID_SEQ;
	if( !strcmp( code, "Curve" ) )
		idcode = ID_CU;
	if( !strcmp( code, "Key" ) )
		idcode = ID_KE;

	if( idcode == -1 )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "Bad code" ) );


	blipo = add_ipo( name, idcode );

	if( blipo ) {
		/* return user count to zero because add_ipo() inc'd it */
		blipo->id.us = 0;
		/* create python wrapper obj */
		pyipo = ( BPy_Ipo * ) PyObject_NEW( BPy_Ipo, &Ipo_Type );
	} else
		return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
						"couldn't create Ipo Data in Blender" ) );

	if( pyipo == NULL )
		return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
						"couldn't create Ipo Data object" ) );

	pyipo->ipo = blipo;

	return ( PyObject * ) pyipo;
}

/*****************************************************************************/
/* Function:              M_Ipo_Get                                       */
/* Python equivalent:     Blender.Ipo.Get                                 */
/* Description:           Receives a string and returns the ipo data obj  */
/*                        whose name matches the string.  If no argument is  */
/*                        passed in, a list of all ipo data names in the  */
/*                        current scene is returned.                         */
/*****************************************************************************/
static PyObject *M_Ipo_Get( PyObject * self, PyObject * args )
{
	char *name = NULL;
	Ipo *ipo_iter;
	PyObject *ipolist, *pyobj;
	BPy_Ipo *wanted_ipo = NULL;
	char error_msg[64];

	if( !PyArg_ParseTuple( args, "|s", &name ) )
		return ( EXPP_ReturnPyObjError( PyExc_TypeError,
						"expected string argument (or nothing)" ) );

	ipo_iter = G.main->ipo.first;

	if( name ) {		/* (name) - Search ipo by name */
		while( ( ipo_iter ) && ( wanted_ipo == NULL ) ) {
			if( strcmp( name, ipo_iter->id.name + 2 ) == 0 ) {
				wanted_ipo =
					( BPy_Ipo * ) PyObject_NEW( BPy_Ipo,
								    &Ipo_Type );
				if( wanted_ipo )
					wanted_ipo->ipo = ipo_iter;
			}
			ipo_iter = ipo_iter->id.next;
		}

		if( wanted_ipo == NULL ) {	/* Requested ipo doesn't exist */
			PyOS_snprintf( error_msg, sizeof( error_msg ),
				       "Ipo \"%s\" not found", name );
			return ( EXPP_ReturnPyObjError
				 ( PyExc_NameError, error_msg ) );
		}

		return ( PyObject * ) wanted_ipo;
	}

	else {			/* () - return a list with all ipos in the scene */
		int index = 0;

		ipolist = PyList_New( BLI_countlist( &( G.main->ipo ) ) );

		if( ipolist == NULL )
			return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
							"couldn't create PyList" ) );

		while( ipo_iter ) {
			pyobj = Ipo_CreatePyObject( ipo_iter );

			if( !pyobj )
				return ( EXPP_ReturnPyObjError
					 ( PyExc_MemoryError,
					   "couldn't create PyString" ) );

			PyList_SET_ITEM( ipolist, index, pyobj );

			ipo_iter = ipo_iter->id.next;
			index++;
		}

		return ( ipolist );
	}
}


static PyObject *M_Ipo_Recalc( PyObject * self, PyObject * args )
{
	void testhandles_ipocurve( IpoCurve * icu );
	PyObject *a;
	IpoCurve *icu;
	if( !PyArg_ParseTuple( args, "O", &a ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected ipo argument)" ) );
	icu = IpoCurve_FromPyObject( a );
	testhandles_ipocurve( icu );

	Py_INCREF( Py_None );
	return Py_None;

}

/*****************************************************************************/
/* Function:              Ipo_Init                                           */
/*****************************************************************************/
PyObject *Ipo_Init( void )
{
	PyObject *submodule;

	Ipo_Type.ob_type = &PyType_Type;

	submodule = Py_InitModule3( "Blender.Ipo", M_Ipo_methods, M_Ipo_doc );

	return ( submodule );
}

/*****************************************************************************/
/* Python BPy_Ipo methods:                                                  */
/*****************************************************************************/
static PyObject *Ipo_getName( BPy_Ipo * self )
{
	PyObject *attr = PyString_FromString( self->ipo->id.name + 2 );

	if( attr )
		return attr;
	Py_INCREF( Py_None );
	return Py_None;
}


static PyObject *Ipo_setName( BPy_Ipo * self, PyObject * args )
{
	char *name;
	char buf[21];

	if( !PyArg_ParseTuple( args, "s", &name ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected string argument" ) );

	PyOS_snprintf( buf, sizeof( buf ), "%s", name );

	rename_id( &self->ipo->id, buf );

	Py_INCREF( Py_None );
	return Py_None;
}

static PyObject *Ipo_getBlocktype( BPy_Ipo * self )
{
	PyObject *attr = PyInt_FromLong( self->ipo->blocktype );
	if( attr )
		return attr;
	return ( EXPP_ReturnPyObjError
		 ( PyExc_RuntimeError,
		   "couldn't get Ipo.blocktype attribute" ) );
}


static PyObject *Ipo_setBlocktype( BPy_Ipo * self, PyObject * args )
{
	int blocktype = 0;

	if( !PyArg_ParseTuple( args, "i", &blocktype ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected string argument" ) );

	self->ipo->blocktype = ( short ) blocktype;

	Py_INCREF( Py_None );
	return Py_None;
}


static PyObject *Ipo_getRctf( BPy_Ipo * self )
{
	PyObject *l = PyList_New( 0 );
	PyList_Append( l, PyFloat_FromDouble( self->ipo->cur.xmin ) );
	PyList_Append( l, PyFloat_FromDouble( self->ipo->cur.xmax ) );
	PyList_Append( l, PyFloat_FromDouble( self->ipo->cur.ymin ) );
	PyList_Append( l, PyFloat_FromDouble( self->ipo->cur.ymax ) );
	return l;

}


static PyObject *Ipo_setRctf( BPy_Ipo * self, PyObject * args )
{
	float v[4];
	if( !PyArg_ParseTuple( args, "ffff", v, v + 1, v + 2, v + 3 ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected 4 float argument" ) );

	self->ipo->cur.xmin = v[0];
	self->ipo->cur.xmax = v[1];
	self->ipo->cur.ymin = v[2];
	self->ipo->cur.ymax = v[3];

	Py_INCREF( Py_None );
	return Py_None;
}

static PyObject *Ipo_getNcurves( BPy_Ipo * self )
{
	int i = 0;

	IpoCurve *icu;
	for( icu = self->ipo->curve.first; icu; icu = icu->next ) {
		i++;
	}

	return ( PyInt_FromLong( i ) );
}

int Ipo_laIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "Energy" ) ) {
		*param = LA_ENERGY;
		ok = 1;
	}
	if( !strcmp( s, "R" ) ) {
		*param = LA_COL_R;
		ok = 1;
	}
	if( !strcmp( s, "G" ) ) {
		*param = LA_COL_G;
		ok = 1;
	}
	if( !strcmp( s, "B" ) ) {
		*param = LA_COL_B;
		ok = 1;
	}
	if( !strcmp( s, "Dist" ) ) {
		*param = LA_DIST;
		ok = 1;
	}
	if( !strcmp( s, "SpoSi" ) ) {
		*param = LA_SPOTSI;
		ok = 1;
	}
	if( !strcmp( s, "SpoBl" ) ) {
		*param = LA_SPOTBL;
		ok = 1;
	}
	if( !strcmp( s, "Quad1" ) ) {
		*param = LA_QUAD1;
		ok = 1;
	}
	if( !strcmp( s, "Quad2" ) ) {
		*param = LA_QUAD2;
		ok = 1;
	}
	if( !strcmp( s, "HaInt" ) ) {
		*param = LA_HALOINT;
		ok = 1;
	}
	return ok;
}

int Ipo_woIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "HorR" ) ) {
		*param = WO_HOR_R;
		ok = 1;
	}
	if( !strcmp( s, "HorG" ) ) {
		*param = WO_HOR_G;
		ok = 1;
	}
	if( !strcmp( s, "HorB" ) ) {
		*param = WO_HOR_B;
		ok = 1;
	}
	if( !strcmp( s, "ZenR" ) ) {
		*param = WO_ZEN_R;
		ok = 1;
	}
	if( !strcmp( s, "ZenG" ) ) {
		*param = WO_ZEN_G;
		ok = 1;
	}
	if( !strcmp( s, "ZenB" ) ) {
		*param = WO_ZEN_B;
		ok = 1;
	}
	if( !strcmp( s, "Expos" ) ) {
		*param = WO_EXPOS;
		ok = 1;
	}
	if( !strcmp( s, "Misi" ) ) {
		*param = WO_MISI;
		ok = 1;
	}
	if( !strcmp( s, "MisDi" ) ) {
		*param = WO_MISTDI;
		ok = 1;
	}
	if( !strcmp( s, "MisHi" ) ) {
		*param = WO_MISTHI;
		ok = 1;
	}
	if( !strcmp( s, "StarR" ) ) {
		*param = WO_STAR_R;
		ok = 1;
	}
	if( !strcmp( s, "StarB" ) ) {
		*param = WO_STAR_B;
		ok = 1;
	}
	if( !strcmp( s, "StarG" ) ) {
		*param = WO_STAR_G;
		ok = 1;
	}
	if( !strcmp( s, "ClSta" ) ) {
		*param = WO_MISTSTA;
		ok = 1;
	}
	if( !strcmp( s, "StarDi" ) ) {
		*param = WO_STARDIST;
		ok = 1;
	}
	if( !strcmp( s, "StarSi" ) ) {
		*param = WO_STARSIZE;
		ok = 1;
	}
	return ok;
}

int Ipo_maIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "R" ) ) {
		*param = MA_COL_R;
		ok = 1;
	}
	if( !strcmp( s, "G" ) ) {
		*param = MA_COL_G;
		ok = 1;
	}
	if( !strcmp( s, "B" ) ) {
		*param = MA_COL_B;
		ok = 1;
	}
	if( !strcmp( s, "SpecR" ) ) {
		*param = MA_SPEC_R;
		ok = 1;
	}
	if( !strcmp( s, "SpecG" ) ) {
		*param = MA_SPEC_G;
		ok = 1;
	}
	if( !strcmp( s, "SpecB" ) ) {
		*param = MA_SPEC_B;
		ok = 1;
	}
	if( !strcmp( s, "MirR" ) ) {
		*param = MA_MIR_R;
		ok = 1;
	}
	if( !strcmp( s, "MirG" ) ) {
		*param = MA_MIR_G;
		ok = 1;
	}
	if( !strcmp( s, "MirB" ) ) {
		*param = MA_MIR_B;
		ok = 1;
	}
	if( !strcmp( s, "Ref" ) ) {
		*param = MA_REF;
		ok = 1;
	}
	if( !strcmp( s, "Alpha" ) ) {
		*param = MA_ALPHA;
		ok = 1;
	}
	if( !strcmp( s, "Emit" ) ) {
		*param = MA_EMIT;
		ok = 1;
	}
	if( !strcmp( s, "Amb" ) ) {
		*param = MA_AMB;
		ok = 1;
	}
	if( !strcmp( s, "Spec" ) ) {
		*param = MA_SPEC;
		ok = 1;
	}
	if( !strcmp( s, "Hard" ) ) {
		*param = MA_HARD;
		ok = 1;
	}
	if( !strcmp( s, "SpTra" ) ) {
		*param = MA_SPTR;
		ok = 1;
	}
	if( !strcmp( s, "Ior" ) ) {
		*param = MA_IOR;
		ok = 1;
	}
	if( !strcmp( s, "Mode" ) ) {
		*param = MA_MODE;
		ok = 1;
	}
	if( !strcmp( s, "HaSize" ) ) {
		*param = MA_HASIZE;
		ok = 1;
	}
	if( !strcmp( s, "Translu" ) ) {
		*param = MA_TRANSLU;
		ok = 1;
	}
	if( !strcmp( s, "RayMir" ) ) {
		*param = MA_RAYM;
		ok = 1;
	}
	if( !strcmp( s, "FresMir" ) ) {
		*param = MA_FRESMIR;
		ok = 1;
	}
	if( !strcmp( s, "FresMirI" ) ) {
		*param = MA_FRESMIRI;
		ok = 1;
	}
	if( !strcmp( s, "FresTra" ) ) {
		*param = MA_FRESTRA;
		ok = 1;
	}
	if( !strcmp( s, "FresTraI" ) ) {
		*param = MA_FRESTRAI;
		ok = 1;
	}
	if( !strcmp( s, "TraGlow" ) ) {
		*param = MA_ADD;
		ok = 1;
	}
	return ok;
}

int Ipo_keIcuName( char *s, int *param )
{
	char key[10];
	int ok = 0;
	int nr = 0;
	if( !strcmp( s, "Speed" ) ) {
		*param = KEY_SPEED;
		ok = 1;
	}
	for( nr = 1; nr < 64; nr++ ) {
		sprintf( key, "Key %d", nr );
		if( !strcmp( s, key ) ) {
			*param = nr;
			ok = 1;
			break;
		}
	}

	return ok;
}

int Ipo_seqIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "Fac" ) ) {
		*param = SEQ_FAC1;
		ok = 1;
	}

	return ok;
}

int Ipo_cuIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "Speed" ) ) {
		*param = CU_SPEED;
		ok = 1;
	}

	return ok;
}

int Ipo_coIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "Inf" ) ) {
		*param = CO_ENFORCE;
		ok = 1;
	}

	return ok;
}

int Ipo_acIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "LocX" ) ) {
		*param = AC_LOC_X;
		ok = 1;
	}
	if( !strcmp( s, "LocY" ) ) {
		*param = AC_LOC_Y;
		ok = 1;
	}
	if( !strcmp( s, "LocZ" ) ) {
		*param = AC_LOC_Z;
		ok = 1;
	}
	if( !strcmp( s, "SizeX" ) ) {
		*param = AC_SIZE_X;
		ok = 1;
	}
	if( !strcmp( s, "SizeY" ) ) {
		*param = AC_SIZE_Y;
		ok = 1;
	}
	if( !strcmp( s, "SizeZ" ) ) {
		*param = AC_SIZE_Z;
		ok = 1;
	}
	if( !strcmp( s, "QuatX" ) ) {
		*param = AC_QUAT_X;
		ok = 1;
	}
	if( !strcmp( s, "QuatY" ) ) {
		*param = AC_QUAT_Y;
		ok = 1;
	}
	if( !strcmp( s, "QuatZ" ) ) {
		*param = AC_QUAT_Z;
		ok = 1;
	}
	if( !strcmp( s, "QuatW" ) ) {
		*param = AC_QUAT_W;
		ok = 1;
	}
	return ok;
}

int Ipo_caIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "Lens" ) ) {
		*param = CAM_LENS;
		ok = 1;
	}
	if( !strcmp( s, "ClSta" ) ) {
		*param = CAM_STA;
		ok = 1;
	}
	if( !strcmp( s, "ClEnd" ) ) {
		*param = CAM_END;
		ok = 1;
	}
	return ok;
}

int Ipo_texIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "NSize" ) ) {
		*param = TE_NSIZE;
		ok = 1;
	}
	if( !strcmp( s, "NDepth" ) ) {
		*param = TE_NDEPTH;
		ok = 1;
	}
	if( !strcmp( s, "NType" ) ) {
		*param = TE_NTYPE;
		ok = 1;
	}
	if( !strcmp( s, "Turb" ) ) {
		*param = TE_TURB;
		ok = 1;
	}
	if( !strcmp( s, "Vnw1" ) ) {
		*param = TE_VNW1;
		ok = 1;
	}
	if( !strcmp( s, "Vnw2" ) ) {
		*param = TE_VNW2;
		ok = 1;
	}
	if( !strcmp( s, "Vnw3" ) ) {
		*param = TE_VNW3;
		ok = 1;
	}
	if( !strcmp( s, "Vnw4" ) ) {
		*param = TE_VNW4;
		ok = 1;
	}
	if( !strcmp( s, "MinkMExp" ) ) {
		*param = TE_VNMEXP;
		ok = 1;
	}
	if( !strcmp( s, "DistM" ) ) {
		*param = TE_VN_DISTM;
		ok = 1;
	}
	if( !strcmp( s, "ColT" ) ) {
		*param = TE_VN_COLT;
		ok = 1;
	}
	if( !strcmp( s, "iScale" ) ) {
		*param = TE_ISCA;
		ok = 1;
	}
	if( !strcmp( s, "DistA" ) ) {
		*param = TE_DISTA;
		ok = 1;
	}
	if( !strcmp( s, "MgType" ) ) {
		*param = TE_MG_TYP;
		ok = 1;
	}
	if( !strcmp( s, "MgH" ) ) {
		*param = TE_MGH;
		ok = 1;
	}
	if( !strcmp( s, "Lacu" ) ) {
		*param = TE_MG_LAC;
		ok = 1;
	}
	if( !strcmp( s, "Oct" ) ) {
		*param = TE_MG_OCT;
		ok = 1;
	}
	if( !strcmp( s, "MgOff" ) ) {
		*param = TE_MG_OFF;
		ok = 1;
	}
	if( !strcmp( s, "MgGain" ) ) {
		*param = TE_MG_GAIN;
		ok = 1;
	}
	if( !strcmp( s, "NBase1" ) ) {
		*param = TE_N_BAS1;
		ok = 1;
	}
	if( !strcmp( s, "NBase2" ) ) {
		*param = TE_N_BAS2;
		ok = 1;
	}

	return ok;
}

int Ipo_obIcuName( char *s, int *param )
{
	int ok = 0;
	if( !strcmp( s, "LocX" ) ) {
		*param = OB_LOC_X;
		ok = 1;
	}
	if( !strcmp( s, "LocY" ) ) {
		*param = OB_LOC_Y;
		ok = 1;
	}
	if( !strcmp( s, "LocZ" ) ) {
		*param = OB_LOC_Z;
		ok = 1;
	}
	if( !strcmp( s, "RotX" ) ) {
		*param = OB_ROT_X;
		ok = 1;
	}
	if( !strcmp( s, "RotY" ) ) {
		*param = OB_ROT_Y;
		ok = 1;
	}
	if( !strcmp( s, "RotZ" ) ) {
		*param = OB_ROT_Z;
		ok = 1;
	}
	if( !strcmp( s, "SizeX" ) ) {
		*param = OB_SIZE_X;
		ok = 1;
	}
	if( !strcmp( s, "SizeY" ) ) {
		*param = OB_SIZE_Y;
		ok = 1;
	}
	if( !strcmp( s, "SizeZ" ) ) {
		*param = OB_SIZE_Z;
		ok = 1;
	}

	if( !strcmp( s, "dLocX" ) ) {
		*param = OB_DLOC_X;
		ok = 1;
	}
	if( !strcmp( s, "dLocY" ) ) {
		*param = OB_DLOC_Y;
		ok = 1;
	}
	if( !strcmp( s, "dLocZ" ) ) {
		*param = OB_DLOC_Z;
		ok = 1;
	}
	if( !strcmp( s, "dRotX" ) ) {
		*param = OB_DROT_X;
		ok = 1;
	}
	if( !strcmp( s, "dRotY" ) ) {
		*param = OB_DROT_Y;
		ok = 1;
	}
	if( !strcmp( s, "dRotZ" ) ) {
		*param = OB_DROT_Z;
		ok = 1;
	}
	if( !strcmp( s, "dSizeX" ) ) {
		*param = OB_DSIZE_X;
		ok = 1;
	}
	if( !strcmp( s, "dSizeY" ) ) {
		*param = OB_DSIZE_Y;
		ok = 1;
	}
	if( !strcmp( s, "dSizeZ" ) ) {
		*param = OB_DSIZE_Z;
		ok = 1;
	}

	if( !strcmp( s, "Layer" ) ) {
		*param = OB_LAY;
		ok = 1;
	}
	if( !strcmp( s, "Time" ) ) {
		*param = OB_TIME;
		ok = 1;
	}

	if( !strcmp( s, "ColR" ) ) {
		*param = OB_COL_R;
		ok = 1;
	}
	if( !strcmp( s, "ColG" ) ) {
		*param = OB_COL_G;
		ok = 1;
	}
	if( !strcmp( s, "ColB" ) ) {
		*param = OB_COL_B;
		ok = 1;
	}
	if( !strcmp( s, "ColA" ) ) {
		*param = OB_COL_A;
		ok = 1;
	}
	if( !strcmp( s, "FStreng" ) ) {
		*param = OB_PD_FSTR;
		ok = 1;
	}
	if( !strcmp( s, "FFall" ) ) {
		*param = OB_PD_FFALL;
		ok = 1;
	}
	if( !strcmp( s, "Damping" ) ) {
		*param = OB_PD_SDAMP;
		ok = 1;
	}
	if( !strcmp( s, "RDamp" ) ) {
		*param = OB_PD_RDAMP;
		ok = 1;
	}
	if( !strcmp( s, "Perm" ) ) {
		*param = OB_PD_PERM;
		ok = 1;
	}

	return ok;
}

static PyObject *Ipo_addCurve( BPy_Ipo * self, PyObject * args )
{
	IpoCurve *get_ipocurve( ID * from, short type, int adrcode,
				Ipo * useipo );
	void allspace( unsigned short event, short val );
	void allqueue( unsigned short event, short val );
	int param = 0, ok = 0, ipofound = 0;
	char *s = 0;
	Ipo *ipo = 0;
	IpoCurve *icu = 0;
	Link *link;

	if( !PyArg_ParseTuple( args, "s", &s ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected string argument" ) );


	link = G.main->ipo.first;

	while( link ) {
		ipo = ( Ipo * ) link;
		if( ipo == self->ipo ) {
			ipofound = 1;
			break;
		}
		link = link->next;
	}

	if( ipo && ipofound ) {
		switch ( ipo->blocktype ) {
		case ID_OB:
			ok = Ipo_obIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case ID_CA:
			ok = Ipo_caIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case ID_LA:
			ok = Ipo_laIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case ID_TE:
			ok = Ipo_texIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case ID_WO:
			ok = Ipo_woIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case ID_MA:
			ok = Ipo_maIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case ID_AC:
			ok = Ipo_acIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case IPO_CO:
			ok = Ipo_coIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case ID_CU:
			ok = Ipo_cuIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case ID_KE:
			ok = Ipo_keIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		case ID_SEQ:
			ok = Ipo_seqIcuName( s, &param );
			icu = get_ipocurve( NULL, ipo->blocktype, param,
					    self->ipo );
			break;
		}
	}

	if( icu == 0 )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_ValueError, "Not a valid param." ) );

#define REMAKEIPO		1
#define REDRAWIPO		0x4023
	allspace( REMAKEIPO, 0 );
	allqueue( REDRAWIPO, 0 );

	return IpoCurve_CreatePyObject( icu );
}



static PyObject *Ipo_getCurve( BPy_Ipo * self, PyObject * args )
{
	char *str, *str1;
	IpoCurve *icu = 0;
	if( !PyArg_ParseTuple( args, "s", &str ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected string argument" ) );
	for( icu = self->ipo->curve.first; icu; icu = icu->next ) {
		str1 = GetIpoCurveName( icu );
		if( !strcmp( str1, str ) )
			return IpoCurve_CreatePyObject( icu );
	}

	Py_INCREF( Py_None );
	return Py_None;
}

char *GetIpoCurveName( IpoCurve * icu )
{
	switch ( icu->blocktype ) {
	case ID_MA:
		{
			return getname_mat_ei( icu->adrcode );
		}
	case ID_WO:
		{
			return getname_world_ei( icu->adrcode );
		}
	case ID_CA:
		{
			return getname_cam_ei( icu->adrcode );
		}
	case ID_OB:
		{
			return getname_ob_ei( icu->adrcode, 1 );	/* solve: what if EffX/Y/Z are wanted? */
		}
	case ID_TE:
		{
			return getname_tex_ei( icu->adrcode );
		}
	case ID_LA:
		{
			return getname_la_ei( icu->adrcode );
		}
	case ID_AC:
		{
			return getname_ac_ei( icu->adrcode );
		}
	case ID_CU:
		{
			return getname_cu_ei( icu->adrcode );
		}
	case ID_KE:
		{
			return getname_key_ei( icu->adrcode );
		}
	case ID_SEQ:
		{
			return getname_seq_ei( icu->adrcode );
		}
	case IPO_CO:
		{
			return getname_co_ei( icu->adrcode );
		}
	}
	return NULL;
}

static PyObject *Ipo_getCurves( BPy_Ipo * self )
{
	PyObject *attr = PyList_New( 0 );
	IpoCurve *icu;
	for( icu = self->ipo->curve.first; icu; icu = icu->next ) {
		PyList_Append( attr, IpoCurve_CreatePyObject( icu ) );
	}
	return attr;
}


static PyObject *Ipo_getNBezPoints( BPy_Ipo * self, PyObject * args )
{
	int num = 0, i = 0;
	IpoCurve *icu = 0;
	if( !PyArg_ParseTuple( args, "i", &num ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected int argument" ) );
	icu = self->ipo->curve.first;
	if( !icu )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "No IPO curve" ) );
	for( i = 0; i < num; i++ ) {
		if( !icu )
			return ( EXPP_ReturnPyObjError
				 ( PyExc_TypeError, "Bad curve number" ) );
		icu = icu->next;

	}
	return ( PyInt_FromLong( icu->totvert ) );
}

static PyObject *Ipo_DeleteBezPoints( BPy_Ipo * self, PyObject * args )
{
	int num = 0, i = 0;
	IpoCurve *icu = 0;
	if( !PyArg_ParseTuple( args, "i", &num ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected int argument" ) );
	icu = self->ipo->curve.first;
	if( !icu )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "No IPO curve" ) );
	for( i = 0; i < num; i++ ) {
		if( !icu )
			return ( EXPP_ReturnPyObjError
				 ( PyExc_TypeError, "Bad curve number" ) );
		icu = icu->next;

	}
	icu->totvert--;
	return ( PyInt_FromLong( icu->totvert ) );
}


/*
 * Ipo_getCurveBP()
 * this method is UNSUPPORTED.
 * Calling this method throws a TypeError Exception.
 *
 * it looks like the original intent was to return the first point
 * of a BPoint Ipo curve.  However, BPoint ipos are not currently
 * implemented.
 */

static PyObject *Ipo_getCurveBP( BPy_Ipo * self, PyObject * args )
{

	/* unsupported method */
	return EXPP_ReturnPyObjError( PyExc_NotImplementedError,
				      "bpoint ipos are not supported" );

#if 0

	struct BPoint *ptrbpoint;
	int num = 0, i;
	IpoCurve *icu;
	PyObject *l;

	if( !PyArg_ParseTuple( args, "i", &num ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected int argument" ) );
	icu = self->ipo->curve.first;
	if( !icu )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "No IPO curve" ) );
	for( i = 0; i < num; i++ ) {
		if( !icu )
			return ( EXPP_ReturnPyObjError
				 ( PyExc_TypeError, "Bad curve number" ) );
		icu = icu->next;

	}
	ptrbpoint = icu->bp;
	if( !ptrbpoint )
		return EXPP_ReturnPyObjError( PyExc_TypeError,
					      "No base point" );

	l = PyList_New( 0 );
	for( i = 0; i < 4; i++ )
		PyList_Append( l, PyFloat_FromDouble( ptrbpoint->vec[i] ) );
	return l;
#endif
}

static PyObject *Ipo_getCurveBeztriple( BPy_Ipo * self, PyObject * args )
{
	struct BezTriple *ptrbt;
	int num = 0, pos, i, j;
	IpoCurve *icu;
	PyObject *l = PyList_New( 0 );

	if( !PyArg_ParseTuple( args, "ii", &num, &pos ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected int argument" ) );
	icu = self->ipo->curve.first;
	if( !icu )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "No IPO curve" ) );
	for( i = 0; i < num; i++ ) {
		if( !icu )
			return ( EXPP_ReturnPyObjError
				 ( PyExc_TypeError, "Bad ipo number" ) );
		icu = icu->next;
	}
	if( pos >= icu->totvert )
		return EXPP_ReturnPyObjError( PyExc_TypeError,
					      "Bad bezt number" );

	ptrbt = icu->bezt + pos;
	if( !ptrbt )
		return EXPP_ReturnPyObjError( PyExc_TypeError,
					      "No bez triple" );

	for( i = 0; i < 3; i++ )
		for( j = 0; j < 3; j++ )
			PyList_Append( l,
				       PyFloat_FromDouble( ptrbt->
							   vec[i][j] ) );
	return l;
}


static PyObject *Ipo_setCurveBeztriple( BPy_Ipo * self, PyObject * args )
{
	struct BezTriple *ptrbt;
	int num = 0, pos, i;
	IpoCurve *icu;
	PyObject *listargs = 0;

	if( !PyArg_ParseTuple( args, "iiO", &num, &pos, &listargs ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError,
			   "expected int int object argument" ) );
	if( !PyTuple_Check( listargs ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "3rd arg should be a tuple" ) );
	icu = self->ipo->curve.first;
	if( !icu )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "No IPO curve" ) );
	for( i = 0; i < num; i++ ) {
		if( !icu )
			return ( EXPP_ReturnPyObjError
				 ( PyExc_TypeError, "Bad ipo number" ) );
		icu = icu->next;
	}
	if( pos >= icu->totvert )
		return EXPP_ReturnPyObjError( PyExc_TypeError,
					      "Bad bezt number" );

	ptrbt = icu->bezt + pos;
	if( !ptrbt )
		return EXPP_ReturnPyObjError( PyExc_TypeError,
					      "No bez triple" );

	for( i = 0; i < 9; i++ ) {
		PyObject *xx = PyTuple_GetItem( listargs, i );
		ptrbt->vec[i / 3][i % 3] = PyFloat_AsDouble( xx );
	}

	Py_INCREF( Py_None );
	return Py_None;
}


static PyObject *Ipo_EvaluateCurveOn( BPy_Ipo * self, PyObject * args )
{
	float eval_icu( IpoCurve * icu, float ipotime );

	int num = 0, i;
	IpoCurve *icu;
	float time = 0;

	if( !PyArg_ParseTuple( args, "if", &num, &time ) )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "expected int argument" ) );

	icu = self->ipo->curve.first;
	if( !icu )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "No IPO curve" ) );

	for( i = 0; i < num; i++ ) {
		if( !icu )
			return ( EXPP_ReturnPyObjError
				 ( PyExc_TypeError, "Bad ipo number" ) );
		icu = icu->next;

	}
	return PyFloat_FromDouble( eval_icu( icu, time ) );
}


static PyObject *Ipo_getCurvecurval( BPy_Ipo * self, PyObject * args )
{
	int numcurve = 0, i;
	IpoCurve *icu;
	char *stringname = 0, *str1 = 0;

	icu = self->ipo->curve.first;
	if( !icu )
		return ( EXPP_ReturnPyObjError
			 ( PyExc_TypeError, "No IPO curve" ) );

	if( PyNumber_Check( PySequence_GetItem( args, 0 ) ) )	// args is an integer
	{
		if( !PyArg_ParseTuple( args, "i", &numcurve ) )
			return ( EXPP_ReturnPyObjError
				 ( PyExc_TypeError,
				   "expected int or string argument" ) );
		for( i = 0; i < numcurve; i++ ) {
			if( !icu )
				return ( EXPP_ReturnPyObjError
					 ( PyExc_TypeError,
					   "Bad ipo number" ) );
			icu = icu->next;
		}
	}

	else			// args is a string
	{
		if( !PyArg_ParseTuple( args, "s", &stringname ) )
			return ( EXPP_ReturnPyObjError
				 ( PyExc_TypeError,
				   "expected int or string argument" ) );
		while( icu ) {
			/*char str1[10];
			   GetIpoCurveName (icu, str1); */
			str1 = GetIpoCurveName( icu );
			if( !strcmp( str1, stringname ) )
				break;
			icu = icu->next;
		}
	}

	if( icu )
		return PyFloat_FromDouble( icu->curval );
	Py_INCREF( Py_None );
	return Py_None;
}


/*****************************************************************************/
/* Function:    IpoDeAlloc                                                   */
/* Description: This is a callback function for the BPy_Ipo type. It is        */
/*              the destructor function.                                     */
/*****************************************************************************/
static void IpoDeAlloc( BPy_Ipo * self )
{
	PyObject_DEL( self );
}

/*****************************************************************************/
/* Function:    IpoGetAttr                                                   */
/* Description: This is a callback function for the BPy_Ipo type. It is        */
/*              the function that accesses BPy_Ipo "member variables" and      */
/*              methods.                                                     */
/*****************************************************************************/
static PyObject *IpoGetAttr( BPy_Ipo * self, char *name )
{
	if( strcmp( name, "curves" ) == 0 )
		return Ipo_getCurves( self );
	return Py_FindMethod( BPy_Ipo_methods, ( PyObject * ) self, name );
}

/*****************************************************************************/
/* Function:    IpoSetAttr                                                */
/* Description: This is a callback function for the BPy_Ipo type. It is the */
/*              function that sets Ipo Data attributes (member variables).*/
/*****************************************************************************/
static int IpoSetAttr( BPy_Ipo * self, char *name, PyObject * value )
{
	return 0;		/* normal exit */
}

/*****************************************************************************/
/* Function:    IpoRepr                                                      */
/* Description: This is a callback function for the BPy_Ipo type. It           */
/*              builds a meaninful string to represent ipo objects.          */
/*****************************************************************************/
static PyObject *IpoRepr( BPy_Ipo * self )
{
	return PyString_FromFormat( "[Ipo \"%s\" %d]", self->ipo->id.name + 2,
				    self->ipo->blocktype );
}

/* Three Python Ipo_Type helper functions needed by the Object module: */

/*****************************************************************************/
/* Function:    Ipo_CreatePyObject                                           */
/* Description: This function will create a new BPy_Ipo from an existing       */
/*              Blender ipo structure.                                       */
/*****************************************************************************/
PyObject *Ipo_CreatePyObject( Ipo * ipo )
{
	BPy_Ipo *pyipo;
	pyipo = ( BPy_Ipo * ) PyObject_NEW( BPy_Ipo, &Ipo_Type );
	if( !pyipo )
		return EXPP_ReturnPyObjError( PyExc_MemoryError,
					      "couldn't create BPy_Ipo object" );
	pyipo->ipo = ipo;
	return ( PyObject * ) pyipo;
}

/*****************************************************************************/
/* Function:    Ipo_CheckPyObject                                            */
/* Description: This function returns true when the given PyObject is of the */
/*              type Ipo. Otherwise it will return false.                    */
/*****************************************************************************/
int Ipo_CheckPyObject( PyObject * pyobj )
{
	return ( pyobj->ob_type == &Ipo_Type );
}

/*****************************************************************************/
/* Function:    Ipo_FromPyObject                                             */
/* Description: This function returns the Blender ipo from the given         */
/*              PyObject.                                                    */
/*****************************************************************************/
Ipo *Ipo_FromPyObject( PyObject * pyobj )
{
	return ( ( BPy_Ipo * ) pyobj )->ipo;
}
