#include "ttonecurveparam.h"

#include "texception.h"

#include "tstream.h"

#include <qlist></qlist>

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

PERSIST_IDENTIFIER(TToneCurveParam, "toneCurveParam")

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

TToneCurveParam::TToneCurveParam()

	: TParam()

{

	m_toneChannel = RGBA;

	std::vector<tpointd> points;</tpointd>

	//Inserisco dei punti fuori dal range(0-255) perche' mi consentono di gestire i primi punti come speciali.

	points.push_back(TPointD(-40, 0));

	points.push_back(TPointD(-20, 0));

	points.push_back(TPointD(-20, 0));

	points.push_back(TPointD(0, 0));

	points.push_back(TPointD(16, 16));

	points.push_back(TPointD(239, 239));

	points.push_back(TPointD(255, 255));

	points.push_back(TPointD(275, 255));

	points.push_back(TPointD(275, 255));

	points.push_back(TPointD(295, 255));

	m_rgbaParamSet = new TParamSet("redgreenbluealphachannel");

	m_rgbParamSet = new TParamSet("redgreenbluechannel");

	m_rParamSet = new TParamSet("redchannel");

	m_gParamSet = new TParamSet("greenchannel");

	m_bParamSet = new TParamSet("bluechannel");

	m_aParamSet = new TParamSet("alphachannel");

	m_isLinear = new TBoolParam(false);

	int i;

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

		m_rgbaParamSet->addParam(new TPointParam(points[i]), "point");

		m_rgbParamSet->addParam(new TPointParam(points[i]), "point");

		m_rParamSet->addParam(new TPointParam(points[i]), "point");

		m_gParamSet->addParam(new TPointParam(points[i]), "point");

		m_bParamSet->addParam(new TPointParam(points[i]), "point");

		m_aParamSet->addParam(new TPointParam(points[i]), "point");

	}

}

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

TParamSetP getClonedParamSet(TParamSetP srcParamSet)

{

	TParamSetP dstParamSet = new TParamSet(srcParamSet->getName());

	int i;

	for (i = 0; i < srcParamSet->getParamCount(); i++) {

		TParamP param = srcParamSet->getParam(i);

		dstParamSet->addParam(param->clone(), param->getName());

	}

	return dstParamSet;

}

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

TToneCurveParam::TToneCurveParam(const TToneCurveParam &src)

	: TParam(src.getName())

{

	m_rgbaParamSet = getClonedParamSet(src.getParamSet(RGBA));

	m_rgbParamSet = getClonedParamSet(src.getParamSet(RGB));

	m_rParamSet = getClonedParamSet(src.getParamSet(Red));

	m_gParamSet = getClonedParamSet(src.getParamSet(Green));

	m_bParamSet = getClonedParamSet(src.getParamSet(Blue));

	m_aParamSet = getClonedParamSet(src.getParamSet(Alpha));

	m_toneChannel = src.getCurrentChannel();

	m_isLinear = src.getIsLinearParam()->clone();

}

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

void TToneCurveParam::copy(TParam *src)

{

	TToneCurveParam *p = dynamic_cast<ttonecurveparam *="">(src);</ttonecurveparam>

	if (!p)

		throw TException("invalid source for copy");

	setName(src->getName());

	m_rgbaParamSet->copy(p->getParamSet(RGBA).getPointer());

	m_rgbParamSet->copy(p->getParamSet(RGB).getPointer());

	m_rParamSet->copy(p->getParamSet(Red).getPointer());

	m_gParamSet->copy(p->getParamSet(Green).getPointer());

	m_bParamSet->copy(p->getParamSet(Blue).getPointer());

	m_aParamSet->copy(p->getParamSet(Alpha).getPointer());

	m_isLinear->copy(p->getIsLinearParam().getPointer());

	m_toneChannel = p->getCurrentChannel();

}

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

void TToneCurveParam::addObserver(TParamObserver *observer)

{

	m_rgbaParamSet->addObserver(observer);

	m_rgbParamSet->addObserver(observer);

	m_rParamSet->addObserver(observer);

	m_gParamSet->addObserver(observer);

	m_bParamSet->addObserver(observer);

	m_aParamSet->addObserver(observer);

	m_isLinear->addObserver(observer);

}

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

void TToneCurveParam::removeObserver(TParamObserver *observer)

{

	m_rgbaParamSet->removeObserver(observer);

	m_rgbParamSet->removeObserver(observer);

	m_rParamSet->removeObserver(observer);

	m_gParamSet->removeObserver(observer);

	m_bParamSet->removeObserver(observer);

	m_aParamSet->removeObserver(observer);

	m_isLinear->removeObserver(observer);

}

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

TParamSetP TToneCurveParam::getParamSet(ToneChannel channel) const

{

	if (channel == RGBA)

		return m_rgbaParamSet;

	else if (channel == RGB)

		return m_rgbParamSet;

	else if (channel == Red)

		return m_rParamSet;

	else if (channel == Green)

		return m_gParamSet;

	else if (channel == Blue)

		return m_bParamSet;

	else if (channel == Alpha)

		return m_aParamSet;

	return 0;

}

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

TParamSetP TToneCurveParam::getCurrentParamSet() const

{

	return getParamSet(m_toneChannel);

}

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

void TToneCurveParam::setCurrentChannel(ToneChannel channel)

{

	m_toneChannel = channel;

}

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

QList<tpointd> TToneCurveParam::getValue(double frame) const</tpointd>

{

	int i;

	QList<tpointd> points;</tpointd>

	for (i = 0; i < getCurrentParamSet()->getParamCount(); i++) {

		TPointParamP pointParam = getCurrentParamSet()->getParam(i);

		points.push_back(pointParam->getValue(frame));

	}

	return points;

}

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

void TToneCurveParam::setValue(double frame, const QList<tpointd> &value, bool undoing)</tpointd>

{

	if (value.size() == 0)

		return;

	int paramCount = getCurrentParamSet()->getParamCount();

	assert(paramCount == value.size());

	int i = 0;

	for (i = 0; i < paramCount; i++) {

		TPointParamP param = getCurrentParamSet()->getParam(i);

		TPointD point = value.at(i);

		param->setValue(frame, point);

	}

}

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

bool TToneCurveParam::isLinear() const

{

	return m_isLinear->getValue();

}

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

void TToneCurveParam::setIsLinear(bool isLinear)

{

	m_isLinear->setValue(isLinear);

}

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

void TToneCurveParam::addValue(double frame, const QList<tpointd> &value, int index)</tpointd>

{

	getCurrentParamSet()->insertParam(new TPointParam(value.at(index - 1)), "point", index - 1);

	getCurrentParamSet()->insertParam(new TPointParam(value.at(index)), "point", index);

	getCurrentParamSet()->insertParam(new TPointParam(value.at(index + 1)), "point", index + 1);

}

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

void TToneCurveParam::removeValue(double frame, int index)

{

	getCurrentParamSet()->removeParam(getCurrentParamSet()->getParam(index - 1));

	getCurrentParamSet()->removeParam(getCurrentParamSet()->getParam(index - 1));

	getCurrentParamSet()->removeParam(getCurrentParamSet()->getParam(index - 1));

}

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

void TToneCurveParam::setDefaultValue(const QList<tpointd> &value)</tpointd>

{

	int pointCount = value.size();

	if (pointCount == 0)

		return;

	int paramCount = getCurrentParamSet()->getParamCount();

	assert(paramCount == pointCount);

	int i;

	for (i = 0; i < pointCount; i++) {

		TPointParamP param = getCurrentParamSet()->getParam(i);

		TPointD paramPoint(param->getValue(0));

		TPointD strokePoint(value.at(i));

		param->setDefaultValue(strokePoint);

	}

	m_isLinear->setDefaultValue(false);

}

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

string TToneCurveParam::getValueAlias(double frame, int precision)

{

	return getCurrentParamSet()->getValueAlias(frame, precision) + m_isLinear->getValueAlias(frame, precision);

}

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

bool TToneCurveParam::isKeyframe(double frame) const

{

	if (m_rgbaParamSet->isKeyframe(frame) || m_rgbParamSet->isKeyframe(frame) || m_rParamSet->isKeyframe(frame) ||

		m_gParamSet->isKeyframe(frame) || m_bParamSet->isKeyframe(frame) || m_aParamSet->isKeyframe(frame))

		return true;

	return false;

}

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

void TToneCurveParam::deleteKeyframe(double frame)

{

	m_rgbaParamSet->deleteKeyframe(frame);

	m_rgbParamSet->deleteKeyframe(frame);

	m_rParamSet->deleteKeyframe(frame);

	m_gParamSet->deleteKeyframe(frame);

	m_bParamSet->deleteKeyframe(frame);

	m_aParamSet->deleteKeyframe(frame);

}

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

void TToneCurveParam::clearKeyframes()

{

	m_rgbaParamSet->clearKeyframes();

	m_rgbParamSet->clearKeyframes();

	m_rParamSet->clearKeyframes();

	m_gParamSet->clearKeyframes();

	m_bParamSet->clearKeyframes();

	m_aParamSet->clearKeyframes();

}

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

void TToneCurveParam::assignKeyframe(double frame, const TSmartPointerT<tparam> &src,</tparam>

									 double srcFrame, bool changedOnly)

{

	m_rgbaParamSet->assignKeyframe(frame, src, srcFrame, changedOnly);

	m_rgbParamSet->assignKeyframe(frame, src, srcFrame, changedOnly);

	m_rParamSet->assignKeyframe(frame, src, srcFrame, changedOnly);

	m_gParamSet->assignKeyframe(frame, src, srcFrame, changedOnly);

	m_bParamSet->assignKeyframe(frame, src, srcFrame, changedOnly);

	m_aParamSet->assignKeyframe(frame, src, srcFrame, changedOnly);

}

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

void TToneCurveParam::getKeyframes(std::set<double> &frames) const</double>

{

	m_rgbaParamSet->getKeyframes(frames);

	m_rgbParamSet->getKeyframes(frames);

	m_rParamSet->getKeyframes(frames);

	m_gParamSet->getKeyframes(frames);

	m_bParamSet->getKeyframes(frames);

	m_aParamSet->getKeyframes(frames);

}

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

bool TToneCurveParam::hasKeyframes() const

{

	if (m_rgbaParamSet->hasKeyframes() || m_rgbParamSet->hasKeyframes() || m_rParamSet->hasKeyframes() ||

		m_gParamSet->hasKeyframes() || m_bParamSet->hasKeyframes() || m_aParamSet->hasKeyframes())

		return true;

	return false;

}

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

int TToneCurveParam::getNextKeyframe(double frame) const

{

	std::set<double> frames;</double>

	getKeyframes(frames);

	std::set<double>::iterator it = frames.upper_bound(frame);</double>

	if (it == frames.end())

		return -1;

	else

		return std::distance(frames.begin(), it);

}

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

int TToneCurveParam::getPrevKeyframe(double frame) const

{

	std::set<double> frames;</double>

	getKeyframes(frames);

	std::set<double>::iterator it = frames.lower_bound(frame);</double>

	if (it == frames.begin())

		return -1;

	else {

		--it;

		return std::distance(frames.begin(), it);

	}

}

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

double TToneCurveParam::keyframeIndexToFrame(int index) const

{

	std::set<double> frames;</double>

	getKeyframes(frames);

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

	std::set<double>::const_iterator it = frames.begin();</double>

	std::advance(it, index);

	return *it;

}

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

void TToneCurveParam::loadData(TIStream &is)

{

	string tagName;

	is.openChild(tagName);

	assert(tagName == "tonecurve");

	m_rgbaParamSet->removeAllParam();

	m_rgbaParamSet->loadData(is);

	m_rgbParamSet->removeAllParam();

	m_rgbParamSet->loadData(is);

	m_rParamSet->removeAllParam();

	m_rParamSet->loadData(is);

	m_gParamSet->removeAllParam();

	m_gParamSet->loadData(is);

	m_bParamSet->removeAllParam();

	m_bParamSet->loadData(is);

	m_aParamSet->removeAllParam();

	m_aParamSet->loadData(is);

	is.openChild(tagName);

	m_isLinear->loadData(is);

	is.closeChild();

	is.closeChild();

}

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

void TToneCurveParam::saveData(TOStream &os)

{

	os.openChild("tonecurve");

	m_rgbaParamSet->saveData(os);

	m_rgbParamSet->saveData(os);

	m_rParamSet->saveData(os);

	m_gParamSet->saveData(os);

	m_bParamSet->saveData(os);

	m_aParamSet->saveData(os);

	os.openChild("isLineaer");

	m_isLinear->saveData(os);

	os.closeChild();

	os.closeChild();

}