// TnzCore includes

#include "tstream.h"

#include "tconvert.h"

#include "tsystem.h"

#include "tcubicbezier.h"

#include "tundo.h"

// TnzBase includes

#include "tdoublekeyframe.h"

#include "tdoubleparamfile.h"

#include "texpression.h"

#include "tgrammar.h"

#include "tparser.h"

#include "tunit.h"

// STD includes

#include <set></set>

#include "tdoubleparam.h"

using namespace std;

//===============================

class TActualDoubleKeyframe : public TDoubleKeyframe

{

public:

	mutable TExpression m_expression;

	mutable TDoubleParamFileData m_fileData;

	TActualDoubleKeyframe(double frame = 0, double value = 0)

		: TDoubleKeyframe(frame, value), m_unit(0) {}

	explicit TActualDoubleKeyframe(const TDoubleKeyframe &src) : m_unit(0)

	{

		TDoubleKeyframe::operator=(src);

		if (m_type == Expression || m_type == SimilarShape)

			m_expression.setText(m_expressionText);

		else if (m_type == File)

			m_fileData.setParams(m_fileParams);

	}

	TActualDoubleKeyframe &operator=(const TDoubleKeyframe &src)

	{

		TDoubleKeyframe::operator=(src);

		m_unit = 0;

		if (m_type == Expression || m_type == SimilarShape) {

			m_expression.setText(m_expressionText);

		} else if (m_type == File) {

			m_fileData.setParams(m_fileParams);

		}

		return *this;

	}

	const TUnit *updateUnit(const TMeasure *measure)

	{

		if (!measure) {

			m_unit = 0;

			m_unitName = "";

		} else {

			if (m_unitName != "")

				m_unit = measure->getUnit(::to_wstring(m_unitName));

			else

				m_unit = 0;

			if (!m_unit) {

				m_unit = measure->getCurrentUnit();

				if (m_unit) {

					QString app = QString::fromStdWString(m_unit->getDefaultExtension());

					m_unitName = app.toStdString();

				}

			}

		}

		assert(measure || m_unit == 0 && m_unitName == "");

		assert((m_unit == 0) == (m_unitName == ""));

		QString app = QString::fromStdString(m_unitName);

		assert(m_unit == 0 || m_unit->isExtension(app.toStdWString()));

		return m_unit;

	}

	double convertFrom(TMeasure *measure, double value) const

	{

		if (!m_unit)

			const_cast<tactualdoublekeyframe *="">(this)->updateUnit(measure);</tactualdoublekeyframe>

		if (m_unit)

			value = m_unit->convertFrom(value);

		return value;

	}

private:

	mutable const TUnit *m_unit;

};

typedef vector<tactualdoublekeyframe> DoubleKeyframeVector;</tactualdoublekeyframe>

//===================================================================

inline double getConstantValue(

	const TActualDoubleKeyframe &k0,

	const TActualDoubleKeyframe &k1,

	double f)

{

	return (f == k1.m_frame) ? k1.m_value : k0.m_value;

}

//---------------------------------------------------------

inline double getLinearValue(

	const TActualDoubleKeyframe &k0,

	const TActualDoubleKeyframe &k1,

	double f)

{

	return k0.m_value +

		   (f - k0.m_frame) * (k1.m_value - k0.m_value) / (k1.m_frame - k0.m_frame);

}

//---------------------------------------------------------

void truncateSpeeds(double aFrame, double bFrame, TPointD &aSpeedTrunc, TPointD &bSpeedTrunc)

{

	double deltaX = bFrame - aFrame;

	if (aSpeedTrunc.x < 0)

		aSpeedTrunc.x = 0;

	if (bSpeedTrunc.x > 0)

		bSpeedTrunc.x = 0;

	if (aFrame + aSpeedTrunc.x > bFrame) {

		if (aSpeedTrunc.x != 0) {

			aSpeedTrunc = aSpeedTrunc * (deltaX / aSpeedTrunc.x);

		}

	}

	if (bFrame + bSpeedTrunc.x < aFrame) {

		if (bSpeedTrunc.x != 0) {

			bSpeedTrunc = -bSpeedTrunc * (deltaX / bSpeedTrunc.x);

		}

	}

}

//---------------------------------------------------------

inline double getSpeedInOutValue(

	const TActualDoubleKeyframe &k0,

	const TActualDoubleKeyframe &k1,

	const TPointD &speed0,

	const TPointD &speed1,

	double frame)

{

	double aFrame = k0.m_frame;

	double bFrame = k1.m_frame;

	double aValue = k0.m_value;

	double bValue = k1.m_value;

	if (frame <= aFrame)

		return aValue;

	else if (frame >= bFrame)

		return bValue;

	TPointD aSpeedTrunc = speed0;

	TPointD bSpeedTrunc = speed1;

	truncateSpeeds(aFrame, bFrame, aSpeedTrunc, bSpeedTrunc);

	return getCubicBezierY(frame,

						   TPointD(aFrame, aValue),

						   aSpeedTrunc,

						   bSpeedTrunc,

						   TPointD(bFrame, bValue));

}

//---------------------------------------------------------

DV_EXPORT_API void splitSpeedInOutSegment(

	TDoubleKeyframe &k,

	TDoubleKeyframe &k0,

	TDoubleKeyframe &k1)

{

	if (k.m_frame <= k0.m_frame) {

		k = k0;

		return;

	} else if (k.m_frame >= k1.m_frame) {

		k = k1;

		return;

	}

	TPointD aSpeed = k0.m_speedOut;

	TPointD bSpeed = k1.m_speedIn;

	truncateSpeeds(k0.m_frame, k1.m_frame, aSpeed, bSpeed);

	TPointD p0(k0.m_frame, k0.m_value);

	TPointD p3(k1.m_frame, k1.m_value);

	TPointD p1 = p0 + aSpeed;

	TPointD p2 = p3 + bSpeed;

	double t = invCubicBezierX(k.m_frame, p0, aSpeed, bSpeed, p3);

	t = tcrop(t, 0.0, 1.0);

	TPointD p01 = (1 - t) * p0 + t * p1;

	TPointD p12 = (1 - t) * p1 + t * p2;

	TPointD p23 = (1 - t) * p2 + t * p3;

	TPointD p012 = (1 - t) * p01 + t * p12;

	TPointD p123 = (1 - t) * p12 + t * p23;

	TPointD p = (1 - t) * p012 + t * p123;

	assert(fabs(p.x - k.m_frame) < 0.1e-3);

	k.m_value = p.y;

	k0.m_speedOut = p01 - p0;

	k.m_speedIn = p012 - p;

	k.m_speedOut = p123 - p;

	k1.m_speedIn = p23 - p3;

}

//---------------------------------------------------------

inline double getEaseInOutValue(

	const TActualDoubleKeyframe &k0,

	const TActualDoubleKeyframe &k1,

	double frame,

	bool percentage)

{

	double x3 = k1.m_frame - k0.m_frame;

	if (x3 <= 0.0)

		return k0.m_value;

	double x = frame - k0.m_frame;

	if (x <= 0)

		return k0.m_value;

	else if (x >= x3)

		return k1.m_value;

	double e0 = std::max(k0.m_speedOut.x, 0.0);

	double e1 = std::max(-k1.m_speedIn.x, 0.0);

	if (percentage) {

		e0 *= x3 * 0.01;

		e1 *= x3 * 0.01;

	}

	if (e0 + e1 >= x3) {

		double x = tcrop((e0 + x3 - e1) / 2, 0.0, x3);

		e0 = x;

		e1 = x3 - x;

	}

	double x1 = e0, x2 = x3 - e1;

	if (0 < x1 - x2 && x1 - x2 < 0.1e-5)

		x1 = x2 = (x1 + x2) * 0.5; // against rounding problems

	assert(0 <= x1 && x1 <= x2 && x2 <= x3);

	double v = 2 / (x3 + x2 - x1);

	double value = 0;

	if (x < x1) {

		double a = v / e0;

		value = 0.5 * a * x * x;

	} else if (x > x2) {

		double a = v / e1;

		value = 1 - 0.5 * a * (x3 - x) * (x3 - x);

	} else {

		double c = -0.5 * v * e0;

		value = x * v + c;

	}

	return (1 - value) * k0.m_value + value * k1.m_value;

}

//---------------------------------------------------------

inline double getExponentialValue(

	const TActualDoubleKeyframe &k0,

	const TActualDoubleKeyframe &k1,

	double frame)

{

	double aFrame = k0.m_frame;

	double bFrame = k1.m_frame;

	double deltaX = bFrame - aFrame;

	double aValue = k0.m_value;

	double bValue = k1.m_value;

	// if min(aValue,bValue)<=0 => error => linear

	if (aValue <= 0 || bValue <= 0)

		return getLinearValue(k0, k1, frame);

	double t = (frame - aFrame) / deltaX;

	// if aValue

	// if bValue

	if (bValue < aValue) {

		t = 1 - t;

		tswap(aValue, bValue);

	}

	return aValue * exp(t * log(bValue / aValue));

}

//---------------------------------------------------------

inline double getExpressionValue(

	const TActualDoubleKeyframe &k0,

	const TActualDoubleKeyframe &k1,

	double frame,

	const TMeasure *measure)

{

	double t = 0, rframe = frame - k0.m_frame;

	if (k1.m_frame > k0.m_frame)

		t = rframe / (k1.m_frame - k0.m_frame);

	TSyntax::Calculator *calculator = k0.m_expression.getCalculator();

	if (calculator) {

		calculator->setUnit((const_cast<tactualdoublekeyframe &="">(k0)).updateUnit(measure));</tactualdoublekeyframe>

		return calculator->compute(t, frame + 1, rframe + 1);

	} else if (measure)

		return measure->getDefaultValue();

	else

		return 0;

}

//---------------------------------------------------------

inline double getSimilarShapeValue(

	const TActualDoubleKeyframe &k0,

	const TActualDoubleKeyframe &k1,

	double frame,

	const TMeasure *measure)

{

	double offset = k0.m_similarShapeOffset;

	double rv0 = getExpressionValue(k0, k1, k0.m_frame + offset, measure);

	double rv1 = getExpressionValue(k0, k1, k1.m_frame + offset, measure);

	double rv = getExpressionValue(k0, k1, frame + offset, measure);

	double v0 = k0.m_value;

	double v1 = k1.m_value;

	if (rv1 != rv0)

		return v0 + (v1 - v0) * (rv - rv0) / (rv1 - rv0);

	else if (measure)

		return measure->getDefaultValue();

	else

		return 0;

}

//===================================================================

class TDoubleParam::Imp

{

public:

	const TSyntax::Grammar *m_grammar;

	string m_measureName;

	TMeasure *m_measure;

	double m_defaultValue, m_minValue, m_maxValue;

	DoubleKeyframeVector m_keyframes;

	bool m_cycleEnabled;

	std::set<tparamobserver *=""> m_observers;</tparamobserver>

	Imp(double v = 0.0)

		: m_grammar(0), m_measureName(), m_measure(0), m_defaultValue(v), m_minValue(-(std::numeric_limits<double>::max)()), m_maxValue((std::numeric_limits<double>::max)()), m_cycleEnabled(false)</double></double>

	{

	}

	~Imp() {}

	void copy(std::unique_ptr<imp> const& src)</imp>

	{

		m_grammar = src->m_grammar;

		m_measureName = src->m_measureName;

		m_measure = src->m_measure;

		m_defaultValue = src->m_defaultValue;

		m_minValue = src->m_minValue;

		m_maxValue = src->m_maxValue;

		m_keyframes = src->m_keyframes;

		m_cycleEnabled = src->m_cycleEnabled;

	}

	void notify(const TParamChange &change)

	{

		std::set<tparamobserver *="">::iterator it = m_observers.begin();</tparamobserver>

		for (; it != m_observers.end(); ++it)

			(*it)->onChange(change);

	}

	double getValue(int segmentIndex, double frame);

	double getSpeed(int segmentIndex, double frame);

	TPointD getSpeedIn(int kIndex);

	TPointD getSpeedOut(int kIndex);

};

//---------------------------------------------------------

double TDoubleParam::Imp::getValue(int segmentIndex, double frame)

{

	assert(0 <= segmentIndex && segmentIndex + 1 < (int)m_keyframes.size());

	const TActualDoubleKeyframe &k0 = m_keyframes[segmentIndex];

	const TActualDoubleKeyframe &k1 = m_keyframes[segmentIndex + 1];

	double value = m_defaultValue;

	bool convertUnit = false;

	switch (k0.m_type) {

	case TDoubleKeyframe::Constant:

		value = getConstantValue(k0, k1, frame);

		break;

	case TDoubleKeyframe::Linear:

		value = getLinearValue(k0, k1, frame);

		break;

	case TDoubleKeyframe::SpeedInOut:

		value = getSpeedInOutValue(k0, k1, getSpeedOut(segmentIndex), getSpeedIn(segmentIndex + 1), frame);

		break;

	case TDoubleKeyframe::EaseInOut:

		value = getEaseInOutValue(k0, k1, frame, false);

		break;

	case TDoubleKeyframe::EaseInOutPercentage:

		value = getEaseInOutValue(k0, k1, frame, true);

		break;

	case TDoubleKeyframe::Exponential:

		value = getExponentialValue(k0, k1, frame);

		break;

	case TDoubleKeyframe::Expression:

		value = getExpressionValue(k0, k1, frame, m_measure);

		convertUnit = true;

		break;

	case TDoubleKeyframe::File:

		value = k0.m_fileData.getValue(frame, m_defaultValue);

		convertUnit = true;

		break;

	case TDoubleKeyframe::SimilarShape:

		value = getSimilarShapeValue(k0, k1, frame, m_measure);

		break;

	}

	if (convertUnit)

		value = k0.convertFrom(m_measure, value);

	return value;

}

//---------------------------------------------------------

double TDoubleParam::Imp::getSpeed(int segmentIndex, double frame)

{

	const double h = 0.00001;

	return (getValue(segmentIndex, frame + h) - getValue(segmentIndex, frame - h)) / (2 * h);

}

//---------------------------------------------------------

TPointD TDoubleParam::Imp::getSpeedIn(int kIndex)

{

	assert(1 <= kIndex && kIndex < (int)m_keyframes.size());

	const TActualDoubleKeyframe &kf0 = m_keyframes[kIndex - 1];

	const TActualDoubleKeyframe &kf1 = m_keyframes[kIndex];

	assert(kf0.m_type == TDoubleKeyframe::SpeedInOut);

	if (!kf1.m_linkedHandles)

		return kf1.m_speedIn;

	TPointD speedIn = kf1.m_speedIn;

	if (kIndex + 1 >= (int)m_keyframes.size()) {

		// speedIn.y = 0;

	} else {

		if (kf1.m_type != TDoubleKeyframe::SpeedInOut &&

			(kf1.m_type != TDoubleKeyframe::Expression || !kf1.m_expression.isCycling())) {

			double speed = getSpeed(kIndex, kf1.m_frame);

			speedIn.y = speedIn.x * speed;

		}

	}

	return speedIn;

}

//---------------------------------------------------------

TPointD TDoubleParam::Imp::getSpeedOut(int kIndex)

{

	assert(0 <= kIndex && kIndex < (int)m_keyframes.size());

	const TDoubleKeyframe &kf1 = m_keyframes[kIndex];

	assert(kf1.m_type == TDoubleKeyframe::SpeedInOut);

	if (!kf1.m_linkedHandles)

		return kf1.m_speedOut;

	TPointD speedOut = kf1.m_speedOut;

	if (kIndex == 0) {

		// speedOut.y = 0;

	} else {

		const TDoubleKeyframe &kf0 = m_keyframes[kIndex - 1];

		if (kf0.m_type != TDoubleKeyframe::SpeedInOut) {

			double speed = getSpeed(kIndex - 1, kf1.m_frame);

			speedOut.y = speedOut.x * speed;

		}

	}

	return speedOut;

}

//---------------------------------------------------------

TPointD TDoubleParam::getSpeedIn(int kIndex) const { return m_imp->getSpeedIn(kIndex); }

TPointD TDoubleParam::getSpeedOut(int kIndex) const { return m_imp->getSpeedOut(kIndex); }

//=========================================================

PERSIST_IDENTIFIER(TDoubleParam, "doubleParam")

//---------------------------------------------------------

TDoubleParam::TDoubleParam(double v)

	: m_imp(new TDoubleParam::Imp(v))

{

}

//---------------------------------------------------------

TDoubleParam::TDoubleParam(const TDoubleParam &src)

	: TParam(src.getName()), m_imp(new TDoubleParam::Imp())

{

	m_imp->copy(src.m_imp);

}

//---------------------------------------------------------

TDoubleParam::~TDoubleParam()

{

}

//---------------------------------------------------------

TDoubleParam &TDoubleParam::operator=(const TDoubleParam &dp)

{

	setName(dp.getName());

	m_imp->copy(dp.m_imp);

	return *this;

}

//---------------------------------------------------------

void TDoubleParam::copy(TParam *src)

{

	TDoubleParam *p = dynamic_cast<tdoubleparam *="">(src);</tdoubleparam>

	if (!p)

		throw TException("invalid source for copy");

	setName(src->getName());

	m_imp->copy(p->m_imp);

	m_imp->notify(TParamChange(this, 0, 0, true, false, false));

}

//---------------------------------------------------------

void TDoubleParam::setValueRange(double min, double max, double step)

{

	if (min > max)

		min = max;

	m_imp->m_minValue = min;

	m_imp->m_maxValue = max;

	// m_imp->m_valueStep = step;

}

//---------------------------------------------------------

bool TDoubleParam::getValueRange(double &min, double &max, double &step) const

{

	min = m_imp->m_minValue;

	max = m_imp->m_maxValue;

	step = 1; // m_imp->m_valueStep;

	return min < max;

}

//---------------------------------------------------------

double TDoubleParam::getDefaultValue() const

{

	assert(m_imp);

	return m_imp->m_defaultValue;

}

//---------------------------------------------------------

void TDoubleParam::enableCycle(bool enabled)

{

	m_imp->m_cycleEnabled = enabled;

	m_imp->notify(TParamChange(this, 0, 0, true, false, false));

}

//---------------------------------------------------------

bool TDoubleParam::isCycleEnabled() const

{

	return m_imp->m_cycleEnabled;

}

//=========================================================

//=========================================================

double TDoubleParam::getValue(double frame, bool leftmost) const

{

	double value = 0;

	assert(m_imp);

	const DoubleKeyframeVector &keyframes = m_imp->m_keyframes;

	if (keyframes.empty()) {

		// no keyframes: return the default value

		value = m_imp->m_defaultValue;

	} else if (keyframes.size() == 1) {

		// a single keyframe. Type must be keyframe based (no expression/file)

		value = keyframes[0].m_value;

	} else {

		// keyframes range is [f0,f1]

		double f0 = keyframes.begin()->m_frame;

		double f1 = keyframes.back().m_frame;

		if (frame < f0)

			frame = f0;

		else if (frame > f1 && !m_imp->m_cycleEnabled)

			frame = f1;

		double valueOffset = 0;

		if (m_imp->m_cycleEnabled) {

			double dist = (f1 - f0);

			double dvalue = keyframes.back().m_value - keyframes.begin()->m_value;

			while (frame >= f1) {

				if (frame != f1 || !leftmost) {

					frame -= dist;

					valueOffset += dvalue;

				} else

					break;

			}

		}

		// frame is in [f0,f1]

		assert(f0 <= frame && frame <= f1);

		DoubleKeyframeVector::const_iterator b;

		b = std::lower_bound(keyframes.begin(), keyframes.end(), TDoubleKeyframe(frame));

		assert(b != keyframes.end());

		DoubleKeyframeVector::const_iterator a;

		if (b->m_frame == frame && (b + 1) != keyframes.end()) {

			a = b;

			b++;

		} else {

			assert(b != keyframes.begin());

			a = b - 1;

		}

		if (leftmost && frame - a->m_frame < 0.00001 && a != keyframes.begin()) {

			a--;

			b--;

		}

		// segment (a,b) contains frame

		assert(a != keyframes.end());

		assert(b != keyframes.end());

		assert(a->m_frame <= frame);

		assert(b->m_frame >= frame);

		int kIndex = std::distance(keyframes.begin(), a);

		vector<tactualdoublekeyframe> tmpKeyframe(3);</tactualdoublekeyframe>

		// if segment is keyframe based ....

		if (TDoubleKeyframe::isKeyframeBased(a->m_type)) {

			// .. and next segment is not then update the b value

			if ((b + 1) != keyframes.end() && !TDoubleKeyframe::isKeyframeBased(b->m_type)) {

				tmpKeyframe[0] = *b;

				if (b->m_type != TDoubleKeyframe::Expression || !b->m_expression.isCycling())

					tmpKeyframe[0].m_value = getValue(b->m_frame);

				b = tmpKeyframe.begin();

			}

			// .. and/or if prev segment is not then update the a value

			if (a != keyframes.begin() && !TDoubleKeyframe::isKeyframeBased(a[-1].m_type)) {

				tmpKeyframe[1] = *a;

				tmpKeyframe[1].m_value = getValue(a->m_frame, true);

				a = tmpKeyframe.begin() + 1;

			}

		}

		if (a->m_step > 1) {

			tmpKeyframe[2] = *b;

			b = tmpKeyframe.begin() + 2;

			int relPos = tfloor(b->m_frame - a->m_frame), step = std::min(a->m_step, relPos);

			tmpKeyframe[2].m_frame = a->m_frame + tfloor(relPos, step);

			if (frame > b->m_frame)

				frame = b->m_frame;

			frame = a->m_frame + tfloor(tfloor(frame - a->m_frame), step);

		}

		assert(0 <= kIndex && kIndex + 1 < (int)m_imp->m_keyframes.size());

		value = m_imp->m_defaultValue;

		bool convertUnit = false;

		switch (a->m_type) {

		case TDoubleKeyframe::Constant:

			value = getConstantValue(*a, *b, frame);

			break;

		case TDoubleKeyframe::Linear:

			value = getLinearValue(*a, *b, frame);

			break;

		case TDoubleKeyframe::SpeedInOut:

			value = getSpeedInOutValue(*a, *b, getSpeedOut(kIndex), getSpeedIn(kIndex + 1), frame);

			break;

		case TDoubleKeyframe::EaseInOut:

			value = getEaseInOutValue(*a, *b, frame, false);

			break;

		case TDoubleKeyframe::EaseInOutPercentage:

			value = getEaseInOutValue(*a, *b, frame, true);

			break;

		case TDoubleKeyframe::Exponential:

			value = getExponentialValue(*a, *b, frame);

			break;

		case TDoubleKeyframe::Expression:

			value = getExpressionValue(*a, *b, frame, m_imp->m_measure);

			convertUnit = true;

			break;

		case TDoubleKeyframe::File:

			value = a->m_fileData.getValue(frame, m_imp->m_defaultValue);

			convertUnit = true;

			break;

		case TDoubleKeyframe::SimilarShape:

			value = getSimilarShapeValue(*a, *b, frame, m_imp->m_measure);

			// convertUnit = true;

			break;

		default:

			value = 0.0;

		}

		value += valueOffset;

		if (convertUnit)

			value = a->convertFrom(m_imp->m_measure, value);

	}

	//if (cropped)

	//  value = tcrop(value, m_imp->m_minValue, m_imp->m_maxValue);

	return value;

}

//---------------------------------------------------------

bool TDoubleParam::setValue(double frame, double value)

{

	assert(m_imp);

	DoubleKeyframeVector &keyframes = m_imp->m_keyframes;

	DoubleKeyframeVector::iterator it;

	TActualDoubleKeyframe k(frame);

	it = std::lower_bound(keyframes.begin(), keyframes.end(), k);

	int index = 0;

	bool created = false;

	/*-- キーフレームが見つかった場合 --*/

	if (it != keyframes.end() && it->m_frame == frame) {

		// changing a keyframe value

		index = std::distance(keyframes.begin(), it);

		TActualDoubleKeyframe oldKeyframe = *it;

		if (oldKeyframe.m_type == TDoubleKeyframe::Expression ||

			oldKeyframe.m_type == TDoubleKeyframe::File)

			return false;

		it->m_value = value;

		m_imp->notify(TParamChange(this, 0, 0, true, false, false));

	}

	/*-- セグメントの部分なので、新たにキーフレームを作る --*/

	else {

		assert(it == keyframes.end() || it->m_frame > frame);

		// can't change value in a file/expression segment

		if (it != keyframes.end() && it > keyframes.begin() &&

			((it - 1)->m_type == TDoubleKeyframe::Expression ||

			 (it - 1)->m_type == TDoubleKeyframe::File))

			return false;

		// inserting a new keyframe

		k.m_value = value;

		k.m_isKeyframe = true;

		k.m_expression.setGrammar(m_imp->m_grammar);

		k.m_expression.setOwnerParameter(this);

		it = keyframes.insert(it, k);

		if (it == keyframes.begin())

			it->m_prevType = TDoubleKeyframe::None;

		else {

			it->m_prevType = it[-1].m_type;

			/*-- FxGuiでSegment内にKeyを打った場合は、Step値も引き継ぐ --*/

			it->m_step = it[-1].m_step;

		}

		if (it + 1 != keyframes.end())

			it[1].m_prevType = it->m_type;

		index = std::distance(keyframes.begin(), it);

		m_imp->notify(TParamChange(this, 0, 0, true, false, false));

		created = true;

	}

	assert(0 == index || keyframes[index - 1].m_frame < keyframes[index].m_frame);

	assert(getKeyframeCount() - 1 == index || keyframes[index + 1].m_frame > keyframes[index].m_frame);

	return created;

}

//---------------------------------------------------------

void TDoubleParam::setKeyframe(int index, const TDoubleKeyframe &k)

{

	DoubleKeyframeVector &keyframes = m_imp->m_keyframes;

	assert(0 <= index && index < (int)keyframes.size());

	TActualDoubleKeyframe &dst = keyframes[index];

	TActualDoubleKeyframe oldKeyframe = dst;

	(TDoubleKeyframe &)dst = k;

	dst.updateUnit(m_imp->m_measure);

	if (dst.m_type == TDoubleKeyframe::Expression || dst.m_type == TDoubleKeyframe::SimilarShape)

		dst.m_expression.setText(dst.m_expressionText);

	if (dst.m_type == TDoubleKeyframe::File)

		dst.m_fileData.setParams(dst.m_fileParams);

	m_imp->notify(TParamChange(this, 0, 0, true, false, false));

	assert(0 == index || keyframes[index - 1].m_frame < keyframes[index].m_frame);

	assert(getKeyframeCount() - 1 == index || keyframes[index + 1].m_frame > keyframes[index].m_frame);

	if (index == 0)

		dst.m_prevType = TDoubleKeyframe::None;

	else

		dst.m_prevType = keyframes[index - 1].m_type;

}

//---------------------------------------------------------

void TDoubleParam::setKeyframes(const std::map<int, tdoublekeyframe=""> &ks)</int,>

{

	DoubleKeyframeVector &keyframes = m_imp->m_keyframes;

	std::map<int, tdoublekeyframe="">::const_iterator it;</int,>

	for (it = ks.begin(); it != ks.end(); ++it) {

		int index = it->first;

		assert(0 <= index && index < (int)keyframes.size());

		TActualDoubleKeyframe oldKeyframe = keyframes[index];

		TActualDoubleKeyframe &dst = keyframes[index];

		(TDoubleKeyframe &)dst = it->second;

		dst.updateUnit(m_imp->m_measure);

		if (dst.m_type == TDoubleKeyframe::Expression || dst.m_type == TDoubleKeyframe::SimilarShape)

			dst.m_expression.setText(dst.m_expressionText);

		if (dst.m_type == TDoubleKeyframe::File)

			dst.m_fileData.setParams(dst.m_fileParams);

	}

	if (!keyframes.empty()) {

		keyframes[0].m_prevType = TDoubleKeyframe::None;

		for (int i = 1; i < (int)keyframes.size(); i++)

			keyframes[i].m_prevType = keyframes[i - 1].m_type;

	}

	m_imp->notify(TParamChange(this, 0, 0, true, false, false));

#ifndef NDEBUG

	for (int i = 0; i + 1 < (int)keyframes.size(); i++) {

		assert(keyframes[i].m_frame <= keyframes[i + 1].m_frame);

	}

#endif

}

//---------------------------------------------------------

void TDoubleParam::setKeyframe(const TDoubleKeyframe &k)

{

	DoubleKeyframeVector &keyframes = m_imp->m_keyframes;

	DoubleKeyframeVector::iterator it;

	it = std::lower_bound(keyframes.begin(), keyframes.end(), k);

	if (it != keyframes.end() && it->m_frame == k.m_frame) {

		// int index = std::distance(keyframes.begin(), it);

		TActualDoubleKeyframe &dst = *it;

		(TDoubleKeyframe &)dst = k;

		dst.updateUnit(m_imp->m_measure);

	} else {

		it = keyframes.insert(it, TActualDoubleKeyframe(k));

		// int index = std::distance(keyframes.begin(), it);

		//TDoubleKeyframe oldKeyframe = *it;

		it->m_expression.setGrammar(m_imp->m_grammar);

		it->m_expression.setOwnerParameter(this);

		it->updateUnit(m_imp->m_measure);

	}

	it->m_isKeyframe = true;

	if (it->m_type == TDoubleKeyframe::Expression)

		it->m_expression.setText(it->m_expressionText);

	if (it->m_type == TDoubleKeyframe::File)

		it->m_fileData.setParams(it->m_fileParams);

	if (it == keyframes.begin())

		it->m_prevType = TDoubleKeyframe::None;

	else

		it->m_prevType = it[-1].m_type;