"""The Blender Ipo module

This module provides access to **Ipo** objects in Blender.

An Ipo object is a datablock of IpoCurves which control properties of
an object in time.

Note that IpoCurves assigned to rotation values (which must be specified
in radians) appear scaled in the IpoWindow (which is in fact true, due
to the fact that conversion to an internal unit of 10.0 angles happens).

Example::
  
  from Blender import Ipo, Object

  ipo = Ipo.New('Object', 'ObIpo')                   # Create object ipo with name 'ObIpo'
  curve = ipo.addCurve('LocY')                       # add IpoCurve for LocY
  curve.setInterpolation('Bezier')                   # set interpolation type
  curve.setExtrapolation('CyclicLinear')             # set extrapolation type

  curve.addBezier((0.0, 0.0))                        # add automatic handle bezier point
  curve.addBezier((20.0, 5.0), 'Free', (10.0, 4.0))  # specify left handle, right auto handle
  curve.addBezier((30.0, 1.0), 'Vect')               # automatic split handle
  curve.addBezier((100.0, 1.0))                      # auto handle

  curve.update()                                     # recalculate curve handles

  curve.eval(35.0)                                   # evaluate curve at 35.0

  ob = Object.get('Plane')
  ob.setIpo(ipo)                                     # assign ipo to object
"""

import _Blender.Ipo as _Ipo

import shadow

_RotIpoCurves = ["RotX", "RotY", "RotZ", "dRotX", "dRotY", "dRotZ"]

_radian_factor = 5.72957814 # 18.0 / 3.14159255

def _convertBPoint(b):
	f = _radian_factor
	newb = BezierPoint() 
	p = b.pt
	q = newb.pt
	q[0], q[1] = (p[0], f * p[1])
	p = b.h1
	q = newb.h1
	q[0], q[1] = (p[0], f * p[1])
	p = b.h2
	q = newb.h2
	q[0], q[1] = (p[0], f * p[1])
	return newb


class IpoBlock(shadow.shadowEx):
	"""Wrapper for Blender Ipo DataBlock

  Attributes
  
    curves -- list of owned IpoCurves
"""
	def get(self, channel = None):
		"""Returns curve with channel identifier 'channel', which is one of the properties
listed in the Ipo Window, 'None' if not found.
If 'channel' is not specified, all curves are returned in a list"""
		if channel:
			for c in self._object.curves:
				if c.name == channel:
					return IpoCurve(c)
			return None
		else:
			return map(lambda x: IpoCurve(x), self._object.curves)

	def __getitem__(self, k):
		"""Emulates dictionary syntax, e.g. ipocurve = ipo['LocX']"""
		curve = self.get(k)
		if not curve:
			raise KeyError, "Ipo does not have a curve for channel %s" % k
		return curve		

	def __setitem__(self, k, val):
		"""Emulates dictionary syntax, e.g. ipo['LocX'] = ipocurve"""
		c = self.addCurve(k, val)
		
	has_key = get # dict emulation

	items = get   # dict emulation

	def keys(self):
		return map(lambda x: x.name, self.get())

	def addCurve(self, channel, curve = None):
		"""Adds a curve of channel type 'channel' to the Ipo Block. 'channel' must be one of
the object properties listed in the Ipo Window. If 'curve' is not specified,
an empty curve is created, otherwise, the existing IpoCurve 'curve' is copied and
added to the IpoBlock 'self'.
In any case, the added curve is returned.
""" 		
		if curve:
			if curve.__class__.__name__ != "IpoCurve":
				raise TypeError, "IpoCurve expected"
			c = self._object.addCurve(channel, curve._object)

			### RotIpo conversion hack
			if channel in _RotIpoCurves:
				print "addCurve, converting", curve.name
				c.points = map(_convertBPoint, curve.bezierPoints)
			else:
				c.points = curve.bezierPoints
		else:	
			c = self._object.addCurve(channel)
		return IpoCurve(c)

	_getters = { 'curves' : get }

class BezierPoint:
	"""BezierPoint object

  Attributes
  
    pt   -- Coordinates of the Bezier point

    h1   -- Left handle coordinates

    h2   -- Right handle coordinates

    h1t  -- Left handle type (see IpoCurve.addBezier(...) )

    h2t  -- Right handle type
"""

BezierPoint = _Ipo.BezTriple # override

class IpoCurve(shadow.shadowEx):
	"""Wrapper for Blender IpoCurve

  Attributes

    bezierPoints -- A list of BezierPoints (see class BezierPoint),
    defining the curve shape
"""

	InterpolationTypes = _Ipo.InterpolationTypes
	ExtrapolationTypes = _Ipo.ExtrapolationTypes

	def __init__(self, object):
		self._object = object
		self.__dict__['bezierPoints'] = self._object.points

	def __getitem__(self, k):
		"""Emulate a sequence of BezierPoints"""
		print k, type(k)
		return self.bezierPoints[k]

	def __repr__(self):
		return "[IpoCurve %s]" % self.name

	def __len__(self):
		return len(self.bezierPoints)

	def eval(self, time):
		"""Returns float value of curve 'self' evaluated at time 'time' which
must be a float."""
		return self._object.eval(time)

	def addBezier(self, p, leftType = 'Auto', left = None, rightType = None, right = None):
		"""Adds a Bezier triple to the IpoCurve.

The following values are float tuples (x,y), denoting position of a control vertex:

p     -- The position of the Bezier point

left  -- The position of the leftmost handle

right -- The position of the rightmost handle

'leftType', 'rightType' must be one of:

"Auto"  --  automatic handle calculation. In this case, 'left' and 'right' don't need to be specified

"Vect"  --  automatic split handle calculation. 'left' and 'right' are disregarded.

"Align" --  Handles are aligned automatically. In this case, 'right' does not need to be specified.

"Free"  --  Handles can be set freely - this requires both arguments 'left' and 'right'.

"""

		b = _Ipo.BezTriple()
		b.pt[0], b.pt[1] = (p[0], p[1])
		b.h1t = leftType

		if rightType:
			b.h2t = rightType
		else:
			b.h2t = leftType

		if left:
			b.h1[0], b.h1[1] = (left[0], left[1])

		if right:	
			b.h2[0], b.h2[1] = (right[0], right[1])

		self.__dict__['bezierPoints'].append(b)
		return b

	def update(self, noconvert = 0):
		# This is an ugly fix for the 'broken' storage of Rotation
		# ipo values. The angles are stored in units of 10.0 degrees,
		# which is totally inconsistent with anything I know :-)
		# We can't (at the moment) change the internals, so we
		# apply a conversion kludge..
		if self._object.name in _RotIpoCurves and not noconvert:
			points = map(_convertBPoint, self.bezierPoints)
		else:
			points = self.bezierPoints
		self._object.points = points
		self._object.update()

	def getInterpolationType(self, ipotype):
		"Returns the Interpolation type - see also IpoCurve.InterpolationTypes"
		return self._object.getInterpolationType()
		
	def setInterpolationType(self, ipotype):
		"""Sets the interpolation type which must be one of IpoCurve.InterpolationTypes"""
		try:
			self._object.setInterpolationType(ipotype)
		except:
			raise TypeError, "must be one of %s" % self.InterpolationTypes.keys()

	def getExtrapolationType(self, ipotype):
		"Returns the Extrapolation type - see also IpoCurve.ExtrapolationTypes"
		return self._object.getExtrapolationType()

	def setExtrapolationType(self, ipotype):
		"""Sets the interpolation type which must be one of IpoCurve.ExtrapolationTypes"""
		try:
			self._object.setInterpolationType(ipotype)
		except:
			raise TypeError, "must be one of %s" % self.ExtrapolationTypes.keys()
	

def New(blocktype, name = None):
	"""Returns a new IPO block of type 'blocktype' which must be one of:
["Object", "Camera", "World", "Material"]
"""
	if name:
		i = _Ipo.New(blocktype, name)
	else:
		i = _Ipo.New(blocktype)
	return IpoBlock(i)

def Eval(ipocurve, time):  # emulation code
	"""This function is just there for compatibility. 
Use IpoCurve.eval(time) instead"""
	return ipocurve.eval(time)

def Recalc(ipocurve):  # emulation code
	"""This function is just there for compatibility. Note that Ipos
assigned to rotation values will *not* get converted to the proper
unit of radians.
In the new style API, use IpoCurve.update() instead"""
	return ipocurve.update(1)

def get(name = None):
	"""If 'name' given, the Ipo 'name' is returned if existing, 'None' otherwise.
If no name is given, a list of all Ipos is returned"""
	if name:
		ipo = _Ipo.get(name)	
		if ipo:
			return IpoBlock(ipo)
		else:
			return None
	else:
		return shadow._List(_Ipo.get(), IpoBlock)

Get = get # emulation