#include "toonzqt/tonecurvefield.h"
#include "toonzqt/fxhistogramrender.h"
#include "toonzqt/intpairfield.h"
#include "toonzqt/checkbox.h"
 
#include <QPainter>
#include <QPainterPath>
#include <QStackedWidget>
#include <QMouseEvent>
#include <QApplication>
#include <QHBoxLayout>
#include <QComboBox>
#include <QLabel>
 
using namespace DVGui;
 
//-----------------------------------------------------------------------------
namespace
{
//-----------------------------------------------------------------------------
 
double getPercentAtPoint(QPointF point, QPainterPath path)
{
	int i;
	for (i = 1; i < 100; i++) {
		double p = double(i) * 0.01;
		QPointF pathPoint = path.pointAtPercent(p);
		if (abs(pathPoint.x() - point.x()) < 3 && abs(pathPoint.y() - point.y()) < 3)
			return p;
	}
	return 0;
}
 
//-----------------------------------------------------------------------------
 
QList<QPointF> getIntersectedPoint(QRectF rect, QPainterPath path)
{
	int y0 = rect.top();
	int y1 = rect.bottom();
	QList<QPointF> points;
	double g = 1.0 / 256.0;
	QPointF prec = path.pointAtPercent(0);
	QPointF point = path.pointAtPercent(g);
	int j = 0;
	for (j = 2; j < 256; j++) {
		QPointF next = path.pointAtPercent(double(j) * g);
		if (prec.y() >= y0 && prec.y() <= y1) {
			if (point.y() < y0)
				points.push_back(QPointF(prec.x(), y0));
			else if (point.y() > y1)
				points.push_back(QPointF(prec.x(), y1));
		}
		if (next.y() >= y0 && next.y() <= y1) {
			if (point.y() < y0)
				points.push_back(QPointF(next.x(), y0));
			else if (point.y() > y1)
				points.push_back(QPointF(next.x(), y1));
		}
		prec = point;
		point = next;
	}
	return points;
}
 
//-----------------------------------------------------------------------------
 
double qtNorm2(const QPointF &p)
{
	return p.x() * p.x() + p.y() * p.y();
}
 
double qtNorm(const QPointF &p)
{
	return sqrt(qtNorm2(p));
}
 
QPointF qtNormalize(const QPointF &p)
{
	double n = qtNorm(p);
	assert(n != 0.0);
	return (1.0 / n) * p;
}
 
double qtDistance2(const QPointF &p1, const QPointF &p2)
{
	return qtNorm2(p2 - p1);
}
 
double qtDistance(const QPointF &p1, const QPointF &p2)
{
	return qtNorm(p2 - p1);
}
 
//-----------------------------------------------------------------------------
 
QPointF getNewFirstHandlePoint(const QPointF &p, const QPointF &nextP, const QPointF &oldHandlePoint)
{
	bool canMove = (nextP.x() - p.x() > 16);
	int yDistance = nextP.y() - p.y();
	double sign = (yDistance != 0) ? yDistance / abs(yDistance) : 1;
	double t = qtDistance(p, oldHandlePoint);
	if (!canMove) {
		QPointF normalizedP = (yDistance != 0) ? qtNormalize(nextP - p) : QPoint(1, 1);
		return QPointF(p + QPointF(t * normalizedP));
	} else if (abs(oldHandlePoint.x() - p.x()) < 16)
		return QPointF(p.x() + 16, p.y() + sign * sqrt(t * t - 16 * 16));
	return oldHandlePoint;
}
 
//-----------------------------------------------------------------------------
 
QPointF getNewSecondHandlePoint(const QPointF &p, const QPointF &nextP, const QPointF &oldHandlePoint)
{
	bool canMove = (nextP.x() - p.x() > 16);
	int yDistance = p.y() - nextP.y();
	double sign = (yDistance != 0) ? yDistance / abs(yDistance) : 1;
	double s = qtDistance(oldHandlePoint, nextP);
	if (!canMove) {
		QPointF normalizedP = (yDistance != 0) ? qtNormalize(nextP - p) : QPoint(1, 1);
		return QPointF(nextP - QPointF(s * normalizedP));
	} else if (abs(nextP.x() - oldHandlePoint.x()) < 16)
		return QPointF(nextP.x() - 16, nextP.y() + sign * sqrt(s * s - 16 * 16));
	return oldHandlePoint;
}
 
//-----------------------------------------------------------------------------
} //anonymous namespace
//-----------------------------------------------------------------------------
 
//=============================================================================
// ChennelCurveEditor
//=============================================================================
 
ChennelCurveEditor::ChennelCurveEditor(QWidget *parent, HistogramView *histogramView)
	: QWidget(parent), m_histogramView(histogramView), m_currentControlPointIndex(-1), m_mouseButton(Qt::NoButton), m_curveHeight(256), m_LeftRightMargin(42), m_TopMargin(9), m_BottomMargin(48), m_isLinear(false)
{
	setFixedSize(m_curveHeight + 2 * m_LeftRightMargin + 2,
				 m_curveHeight + m_TopMargin + m_BottomMargin);
	setAttribute(Qt::WA_KeyCompression);
	setFocusPolicy(Qt::StrongFocus);
	setMouseTracking(true);
 
	m_histogramView->setDrawnWidget(this);
	m_histogramView->setGraphHeight(m_curveHeight);
	m_histogramView->setGraphAlphaMask(120);
	m_verticalChannelBar = new ChannelBar(0, m_histogramView->getChannelBarColor(), false);
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::setPoints(QList<TPointD> points)
{
	if (!m_points.isEmpty())
		m_points.clear();
	int i;
	for (i = 0; i < points.size(); i++) {
		QPointF p = strokeToViewPoint(points.at(i));
		m_points.push_back(p);
	}
	/*--ポイント位置に合わせてスライダも更新する--*/
	int firstIndex = 3;
	int lastIndex = m_points.size() - 4;
	emit firstLastXPostionChanged(viewToStrokePoint(m_points.at(firstIndex)).x,
								  viewToStrokePoint(m_points.at(lastIndex)).x);
	update();
}
 
//-----------------------------------------------------------------------------
 
QList<TPointD> ChennelCurveEditor::getPoints()
{
	QList<TPointD> points;
	if (m_points.isEmpty())
		return points;
	int i;
	for (i = 0; i < m_points.size(); i++)
		points.push_back(viewToStrokePoint(m_points.at(i)));
	return points;
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::setFirstLastXPosition(std::pair<int, int> values, bool isDragging)
{
	if (!isDragging) {
		emit controlPointChanged(false);
		return;
	}
 
	QPointF newX0 = strokeToViewPoint(TPointD(values.first, 0));
	QPointF newX1 = strokeToViewPoint(TPointD(values.second, 0));
 
	int indexX0 = 3;
	int indexX1 = m_points.size() - 4;
	QPointF x0 = m_points.at(indexX0);
	QPointF x1 = m_points.at(indexX1);
	if (x0.x() != newX0.x()) {
		QPointF delta(newX0.x() - x0.x(), 0);
		moveCentralControlPoint(indexX0, delta);
		update();
	}
	if (x1.x() != newX1.x()) {
		QPointF delta(newX1.x() - x1.x(), 0);
		moveCentralControlPoint(indexX1, delta);
		update();
	}
	m_currentControlPointIndex = -1;
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::setLinear(bool isLinear)
{
	if (m_isLinear == isLinear)
		return;
	m_isLinear = isLinear;
	update();
}
 
//-----------------------------------------------------------------------------
 
QPointF ChennelCurveEditor::checkPoint(const QPointF p)
{
	QPointF checkedP = p;
	int y0 = m_TopMargin + 1;
	int y1 = m_curveHeight + m_TopMargin;
	if (p.y() < y0)
		checkedP = QPointF(checkedP.x(), y0);
	if (p.y() > y1)
		checkedP = QPointF(checkedP.x(), y1);
	int x0 = m_LeftRightMargin + 1;
	int x1 = m_curveHeight + m_LeftRightMargin;
	if (p.x() < x0)
		checkedP = QPointF(x0, checkedP.y());
	if (p.x() > x1)
		checkedP = QPointF(x1, checkedP.y());
	return checkedP;
}
 
//-----------------------------------------------------------------------------
 
QPointF ChennelCurveEditor::strokeToViewPoint(const TPointD p)
{
	double x = p.x + m_LeftRightMargin + 1;
	double y = height() - m_BottomMargin - p.y;
	return QPointF(x, y);
}
 
//-----------------------------------------------------------------------------
 
TPointD ChennelCurveEditor::viewToStrokePoint(const QPointF &p)
{
	double x = p.x() - m_LeftRightMargin - 1;
	double y = m_curveHeight - (p.y() - m_TopMargin);
	return TThickPoint(x, y);
}
 
//-----------------------------------------------------------------------------
 
int ChennelCurveEditor::getClosestPointIndex(const QPointF &pos, double &minDistance2) const
{
	int closestPointIndex = -1;
	minDistance2 = 0;
	int i;
	for (i = 0; i < (int)m_points.size(); i++) {
		double distance2 = qtDistance2(pos, m_points.at(i));
		if (closestPointIndex < 0 || distance2 < minDistance2) {
			minDistance2 = distance2;
			closestPointIndex = i;
		}
	}
	return closestPointIndex;
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::movePoint(int index, const QPointF delta)
{
	QPointF p = m_points.at(index);
	p += delta;
	setPoint(index, p);
 
	int firstIndex = 3;
	int lastIndex = m_points.size() - 4;
	if (index == firstIndex)
		emit firstLastXPostionChanged(viewToStrokePoint(p).x, viewToStrokePoint(m_points.at(lastIndex)).x);
	if (index == lastIndex)
		emit firstLastXPostionChanged(viewToStrokePoint(m_points.at(firstIndex)).x, viewToStrokePoint(p).x);
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::setPoint(int index, const QPointF p)
{
	m_points.removeAt(index);
	m_points.insert(index, p);
 
	int firstIndex = 3;
	int lastIndex = m_points.size() - 4;
	if (index == firstIndex)
		emit firstLastXPostionChanged(viewToStrokePoint(p).x, viewToStrokePoint(m_points.at(lastIndex)).x);
	if (index == lastIndex)
		emit firstLastXPostionChanged(viewToStrokePoint(m_points.at(firstIndex)).x, viewToStrokePoint(p).x);
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::moveCurrentControlPoint(const QPointF delta)
{
	assert(m_currentControlPointIndex != -1);
	int pointCount = m_points.size();
	/*- セグメントを動かした場合 -*/
	if (isCentralControlPoint(m_currentControlPointIndex))
		moveCentralControlPoint(m_currentControlPointIndex, delta);
	/*- 左のハンドルを動かした場合 -*/
	else if (isLeftControlPoint(m_currentControlPointIndex)) {
		QPointF p0 = m_points.at(m_currentControlPointIndex) + QPointF(0, delta.y());
		setPoint(m_currentControlPointIndex, p0);
		if (m_currentControlPointIndex < pointCount - 5) {
			QPointF p2 = m_points.at(m_currentControlPointIndex + 2) - QPointF(0, delta.y());
			setPoint(m_currentControlPointIndex + 2, p2);
		}
		emit controlPointChanged(true);
	}
	/*- 右のハンドルを動かした場合 -*/
	else {
		assert(isRightControlPoint(m_currentControlPointIndex));
		QPointF p0 = m_points.at(m_currentControlPointIndex) + QPointF(0, delta.y());
		setPoint(m_currentControlPointIndex, p0);
		if (m_currentControlPointIndex > 4) {
			QPointF p2 = m_points.at(m_currentControlPointIndex - 2) - QPointF(0, delta.y());
			setPoint(m_currentControlPointIndex - 2, p2);
		}
		emit controlPointChanged(true);
	}
	update();
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::moveCentralControlPoint(int index, const QPointF delta)
{
	int pointCount = m_points.size();
 
	assert(index < pointCount - 3 && index > 2);
 
	QPointF p = m_points.at(index);
	QPointF d = delta;
	//Trovo il valore di delta im modo tale che il punto di controllo non sia trascinato fuori dal range consentito
	int newX = p.x() + delta.x();
	int newY = p.y() + delta.y();
	QPointF newPoint = checkPoint(QPoint(newX, newY));
	d = newPoint - p;
 
	QPointF nextP = m_points.at(index + 3);
	QPointF precP = m_points.at(index - 3);
	double nextDistance = nextP.x() - (p.x() + d.x());
	double precDistance = (p.x() + d.x()) - precP.x();
 
	//Caso particolare: Punto di controllo corrente == primo visibile,
	//								  Punto di controllo successivo == l'ultimo visibile
	if (index == 3 && index + 3 == pointCount - 4) {
		setPoint(index + 1, getNewFirstHandlePoint(p, nextP, m_points.at(index + 1)));
		setPoint(index + 2, getNewSecondHandlePoint(p, nextP, m_points.at(index + 2)));
		if (nextDistance < 0)
			d = QPointF(nextP.x() - p.x(), d.y());
	}
	//Caso particolare: Punto di controllo corrente == ultimo visibile,
	//								  Punto di controllo precedente == primo visibile
	else if (index - 3 == 3 && index == pointCount - 4) {
		setPoint(index - 2, getNewFirstHandlePoint(precP, p, m_points.at(index - 2)));
		setPoint(index - 1, getNewSecondHandlePoint(precP, p, m_points.at(index - 1)));
		if (precDistance < 0)
			d = QPointF(precP.x() - p.x(), d.y());
	}
	//Altrimenti calcolo il nuovo delta
	else if (nextDistance < 16)
		d = QPointF(nextP.x() - p.x() - 16, d.y());
	else if (precDistance < 16)
		d = QPointF(precP.x() - p.x() + 16, d.y());
 
	//Punto di controllo speciale: il primo visualizzato.
	if (index == 3) {
		QPointF dY = QPointF(0, d.y());
		movePoint(index - 1, dY);
		movePoint(index - 2, dY);
		movePoint(index - 3, dY);
	}
	//Punto di controllo speciale: l'ultimo visualizzato.
	if (index == pointCount - 4) {
		QPointF dY = QPointF(0, d.y());
		movePoint(index + 1, dY);
		movePoint(index + 2, dY);
		movePoint(index + 3, dY);
	}
	if (index > 3)
		movePoint(index - 1, d);
	if (index < pointCount - 4)
		movePoint(index + 1, d);
	movePoint(index, d);
	emit controlPointChanged(true);
}
 
//-----------------------------------------------------------------------------
 
/* Se due punti di controllo sono troppo vicini uno dei due viene eliminato.
	 Ritorna vero se un punto viene eliminato.
 
Prima di richiamare il metodo nel move andava fatto questo controllo!!!
//Se il punto di controllo successivo, o precente, e' l'utlimo, o il primo, blocco il
// movimento altrimenti elimino il punto di controllo successivo e richiamo il move.
int nextPX = m_points.at(index+3).x();
if(nextPX>m_margin && nextPX<=w && newX>nextPX)
{
	if(index+3 == pointCount-4) d = QPointF(0, d.y());
	else
	{
		moveCentralControlPoint(index, d);
		return;
	}
}
int precPX = m_points.at(index-3).x();
if(precPX>=m_margin && precPX<=w && newX<precPX)
{
	if(index-3 == 3) d = QPointF(0, d.y());
	else
	{
		moveCentralControlPoint(index, d);
		return;
	}
}
 
bool ChennelCurveEditor::eraseControlPointWhileMove(int index, const QPointF delta)
{
	int pointCount = m_points.size();
	QPointF p = m_points.at(index);
	QPointF nextP = m_points.at(index+3);
	QPointF precP = m_points.at(index-3);
	double nextDistance = abs((p.x()+delta.x())-nextP.x());
	double precDistance = abs((p.x()+delta.x())-precP.x());
 
	if(nextDistance>16 && precDistance>16) return false;
 
	//Se vado troppo vicino al punto di controllo precedente, o successivo, lo elimino.
	if(nextDistance<=16)
	{
		//Caso particolare: il successivo e' l'ultimo visibile; non posso eliminare l'ultimo punto di controllo visibile.
		if(index+3 == pointCount-4)
		{
			//Se il punto di controllo in index e' il primo visibile sto gestendo il
			// primo e l'ultimo punto, entrambi non possono essere eliminati.
			if(index == 3)
			{
				setPoint(index+1,nextP);
				setPoint(index+2,p+delta);
				return false;
			}
			else	//Altrimenti elimino il penultimo.
			{
				removeControlPoint(index);
				m_currentControlPointIndex += 3;
				return true;
			}
		}
		removeControlPoint(index+3);
		return true;
	}
	if(precDistance<=16)
	{
		//Caso particolare: il precedente e' il primo visibile; non posso eliminare il primo punto di controllo visibile.
		if(index-3 == 3)
		{
			//Se il punto di controllo in index e' l'ultimo visibile sto gestendo il
			// primo e l'ultimo punto, entrambi non possono essere eliminati.
			if(index == pointCount-4)
			{
				setPoint(index-1,precP);
				setPoint(index-2,p+delta);
				return false;
			}
			else	//Altrimenti elimino il secondo.
			{
				removeControlPoint(index);
				return true;
			}
		}
		removeControlPoint(index-3);
		m_currentControlPointIndex += 3;
		return true;
	}
	return false;
}
*/
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::addControlPoint(double percent)
{
	QPainterPath path = getPainterPath();
	QPointF p = path.pointAtPercent(percent);
 
	//Cerco il punto di controllo precedente
	int pointCount = m_points.size();
	int beforeControlPointIndex;
	for (beforeControlPointIndex = pointCount - 1; beforeControlPointIndex >= 0; beforeControlPointIndex--) {
		QPointF point = m_points.at(beforeControlPointIndex);
		if (isCentralControlPoint(beforeControlPointIndex) && point.x() < p.x())
			break;
	}
 
	if (beforeControlPointIndex == 0 || beforeControlPointIndex == pointCount - 4)
		return;
 
	QPointF p0 = checkPoint(m_points.at(beforeControlPointIndex));
	//Se sono troppo vicino al punto di controllo precedente ritorno
	if (abs(p.x() - p0.x()) <= 16)
		return;
	double beforeControlPointPercent = getPercentAtPoint(p0, path);
	QPointF p1 = checkPoint(m_points.at(beforeControlPointIndex + 1));
	QPointF p2 = checkPoint(m_points.at(beforeControlPointIndex + 2));
	QPointF p3 = checkPoint(m_points.at(beforeControlPointIndex + 3));
	//Se sono troppo vicino al punto di controllo successivo ritorno
	if (abs(p3.x() - p.x()) <= 16)
		return;
	double nextControlPointPercent = getPercentAtPoint(p3, path);
 
	//Calcolo la velocita' e quindi il coiffciente angolare.
	double t = percent * 100 / (nextControlPointPercent - beforeControlPointPercent);
	double s = t - 1;
	QPointF speed = 3.0 * ((p1 - p0) * s * s + 2 * (p2 - p0) * s * t + (p3 - p2) * t * t);
	double m = speed.y() / speed.x();
 
	int newControlPointIndex = beforeControlPointIndex + 3;
	m_points.insert(newControlPointIndex - 1, QPointF(p.x() - 16, p.y() - 16 * m));
	m_points.insert(newControlPointIndex, p);
	m_points.insert(newControlPointIndex + 1, QPointF(p.x() + 16, p.y() + 16 * m));
 
	m_currentControlPointIndex = newControlPointIndex;
	emit controlPointAdded(newControlPointIndex);
	update();
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::removeCurrentControlPoint()
{
	removeControlPoint(m_currentControlPointIndex);
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::removeControlPoint(int index)
{
	//Non posso eliminare il primo punto di controllo visibile quindi lo rimetto in condizione iniziale
	if (index <= 4) {
		setPoint(0, strokeToViewPoint(TPointD(-40, 0)));
		setPoint(1, strokeToViewPoint(TPointD(-20, 0)));
		setPoint(2, strokeToViewPoint(TPointD(-20, 0)));
		setPoint(3, strokeToViewPoint(TPointD(0, 0)));
		setPoint(4, strokeToViewPoint(TPointD(16, 16)));
		update();
		emit controlPointChanged(false);
		return;
	}
	//Non posso eliminare il l'ultimo punto di controllo visibile quindi lo rimetto in condizione iniziale
	if (index >= m_points.size() - 5) {
		int i = m_points.size() - 5;
		setPoint(i, strokeToViewPoint(TPointD(239, 239)));
		setPoint(i + 1, strokeToViewPoint(TPointD(255, 255)));
		setPoint(i + 2, strokeToViewPoint(TPointD(275, 255)));
		setPoint(i + 3, strokeToViewPoint(TPointD(275, 255)));
		setPoint(i + 4, strokeToViewPoint(TPointD(295, 255)));
		update();
		emit controlPointChanged(false);
		return;
	}
 
	int firstIndex = 0;
	if (isCentralControlPoint(index))
		firstIndex = index - 1;
	else if (isLeftControlPoint(index))
		firstIndex = index;
	else
		firstIndex = index - 2;
 
	m_points.removeAt(firstIndex);
	m_points.removeAt(firstIndex);
	m_points.removeAt(firstIndex);
 
	emit controlPointRemoved(firstIndex + 1);
	m_currentControlPointIndex = firstIndex - 2;
	update();
}
 
//-----------------------------------------------------------------------------
 
QPainterPath ChennelCurveEditor::getPainterPath()
{
	int pointCount = m_points.size();
	if (pointCount == 0)
		return QPainterPath();
 
	QPointF p0 = m_points.at(0);
	QPainterPath path(p0);
	int i;
	for (i = 1; i < pointCount; i++) {
		QPointF p1 = m_points.at(i);
		QPointF p2 = m_points.at(++i);
		QPointF p3 = m_points.at(++i);
		path.moveTo(p0);
		if (!m_isLinear)
			path.cubicTo(p1, p2, p3);
		else
			path.lineTo(p3);
		p0 = p3;
	}
 
	//Cerco le eventuali intersezioni con il bordo.
	QRectF rect(m_LeftRightMargin, m_TopMargin, m_curveHeight, m_curveHeight);
	QRectF r = path.boundingRect();
	if (!rect.contains(QRect(rect.left(), r.top(), rect.width(), r.height()))) {
		QList<QPointF> points = getIntersectedPoint(rect, path);
		//Se trovo punti di intersezione (per come e' definita la curva devono essere pari)
		// faccio l'unione del path calcolato e di nuovi path lineari.
		int j = 0;
		for (j = 0; j < points.size(); j++) {
			QPointF p0 = points.at(j);
			QPointF p1 = points.at(++j);
			QPainterPath line(p0);
			line.lineTo(p1);
			path.addPath(line);
		}
	}
 
	return path;
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::paintEvent(QPaintEvent *e)
{
	QPainter painter(this);
 
	//Disegno il reticolato
	painter.setRenderHint(QPainter::Antialiasing, false);
	painter.setPen(QColor(250, 250, 250));
	int i;
	int d = m_curveHeight * 0.25;
	for (i = 1; i < 16; i++) {
		// linee orizzontali
		int delta = m_TopMargin + 16 * i;
		int j;
		for (j = 1; j < 4; j++)
			painter.drawLine(QPoint((j - 1) * d + m_LeftRightMargin + 1, delta), QPoint(j * d + m_LeftRightMargin - 1, delta));
		painter.drawLine(QPoint((4 - 1) * d + m_LeftRightMargin + 1, delta), QPoint(4 * d + m_LeftRightMargin, delta));
		// linee verticali
		delta = m_LeftRightMargin + 1 + 16 * i;
		if (i % 4 == 0)
			continue;
		for (j = 1; j < 5; j++)
			painter.drawLine(QPoint(delta, (j - 1) * d + m_TopMargin), QPoint(delta, j * d + m_TopMargin - 1));
	}
 
	//Disegno l'histogram.
	m_histogramView->draw(&painter, QPoint(m_LeftRightMargin - 10, 0));
 
	//Disegno la barra verticale a sinistra.
	m_verticalChannelBar->draw(&painter, QPoint(0, -2)); //-1 == m_topMargin- il margine della barra(=10+1).
 
	QRectF r = rect().adjusted(m_LeftRightMargin, m_TopMargin, -m_LeftRightMargin, -m_BottomMargin);
	//Disegno la curva entro i limiti del grafo
	painter.setClipRect(r, Qt::IntersectClip);
	QPainterPath path = getPainterPath();
	if (path.isEmpty())
		return;
	painter.setRenderHint(QPainter::Antialiasing, true);
	painter.setPen(Qt::black);
	painter.setBrush(Qt::NoBrush);
	painter.drawPath(path);
 
	//Disegno i punti di controllo (esclusi i primi tre e gli ultimi tre)
	r = r.adjusted(-5, -5, 5, 5);
	int n = m_points.size();
	QPointF p = m_points.at(3);
	for (i = 3; i < n - 3; i++) {
		QBrush brush(Qt::white);
		int rad = 3;
		QPointF nextP = m_points.at(i + 1);
		if (isCentralControlPoint(i))
			rad = 4;
		else if (m_isLinear) {
			p = nextP;
			continue;
		}
		if (m_currentControlPointIndex == i)
			brush = QBrush(Qt::black);
		painter.setBrush(brush);
		painter.setPen(Qt::black);
 
		if (!m_isLinear) {
			if (isLeftControlPoint(i))
				painter.drawLine(p, nextP);
			else if (isCentralControlPoint(i) && i < n - 4)
				painter.drawLine(p, nextP);
		}
		QPainterPath circle;
		QRectF pointRect(p.x() - rad, p.y() - rad, 2 * rad, 2 * rad);
		if (r.contains(pointRect))
#if QT_VERSION >= 0x050000
			painter.setClipRect(pointRect.adjusted(-1, -1, 1, 1));
#else
			painter.setClipRect(pointRect.adjusted(-1, -1, 1, 1), Qt::UniteClip);
#endif
		circle.addEllipse(pointRect);
		painter.fillPath(circle, brush);
		painter.drawPath(circle);
		p = nextP;
	}
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::mouseMoveEvent(QMouseEvent *e)
{
	if (m_mouseButton == Qt::LeftButton && m_currentControlPointIndex != -1) {
		QPoint pos = e->pos();
		QPointF posF = QPointF(pos.x(), pos.y());
		moveCurrentControlPoint(posF - m_points.at(m_currentControlPointIndex));
	}
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::mousePressEvent(QMouseEvent *e)
{
	m_mouseButton = e->button();
	setFocus();
	if (m_mouseButton == Qt::LeftButton) {
		QPoint pos = e->pos();
		QPointF posF = QPointF(pos.x(), pos.y());
		double minDistance;
		int controlPointIndex = getClosestPointIndex(posF, minDistance);
 
		//Se la distanza e' piccola seleziono il control point corrente
		if (minDistance < 20)
			m_currentControlPointIndex = controlPointIndex;
		else {
			m_currentControlPointIndex = -1;
			//Se sono sufficentemente lontano da un punto di controllo, ma abbastanza vicino alla curva
			// aggiungo un punto di controllo
			double percent = getPercentAtPoint(posF, getPainterPath());
			if (percent != 0 && minDistance > 20)
				addControlPoint(percent);
		}
		update();
	}
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::mouseReleaseEvent(QMouseEvent *e)
{
	/*-- マウスドラッグ中はプレビューを更新しない。ここで初めて更新 --*/
	if (m_mouseButton == Qt::LeftButton &&
		m_currentControlPointIndex != -1 &&
		e->button() == Qt::LeftButton)
		emit controlPointChanged(false);
	m_mouseButton = Qt::NoButton;
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::keyPressEvent(QKeyEvent *e)
{
	if (e->key() == Qt::Key_Delete)
		removeCurrentControlPoint();
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::enterEvent(QEvent *)
{
	m_mouseButton = Qt::NoButton;
}
 
//-----------------------------------------------------------------------------
 
void ChennelCurveEditor::leaveEvent(QEvent *)
{
	m_mouseButton = Qt::NoButton;
}
 
//--------------------------------------------------------
 
bool ChennelCurveEditor::eventFilter(QObject *object, QEvent *event)
{
	if (event->type() == QEvent::Shortcut ||
		event->type() == QEvent::ShortcutOverride) {
		if (!object->inherits("FxSettings")) {
			event->accept();
			return true;
		}
	}
	return false;
}
 
//--------------------------------------------------------
 
void ChennelCurveEditor::focusInEvent(QFocusEvent *fe)
{
	QWidget::focusInEvent(fe);
	qApp->installEventFilter(this);
}
 
//--------------------------------------------------------
 
void ChennelCurveEditor::focusOutEvent(QFocusEvent *fe)
{
	m_currentControlPointIndex = -1;
	emit focusOut();
	QWidget::focusOutEvent(fe);
	qApp->removeEventFilter(this);
	update();
}
 
//=============================================================================
// ToneCurveField
//=============================================================================
 
ToneCurveField::ToneCurveField(QWidget *parent, FxHistogramRender *fxHistogramRender)
	: QWidget(parent), m_toneCurveStackedWidget(0)
{
	setFixedWidth(368);
 
	int currentChannelIndex = 0;
 
	QVBoxLayout *mainLayout = new QVBoxLayout(this);
	mainLayout->setMargin(0);
	mainLayout->setSpacing(0);
 
	QStringList channels;
	channels << "RGBA"
			 << "RGB"
			 << "Red"
			 << "Green"
			 << "Blue"
			 << "Alpha";
	int channelCount = channels.size();
 
	//lista canali: label+comboBox
	QWidget *channelListWidget = new QWidget(this);
	QHBoxLayout *channelListLayout = new QHBoxLayout(channelListWidget);
	channelListLayout->setMargin(0);
	channelListLayout->setSpacing(0);
	QLabel *channelLabel = new QLabel(tr("Channel:"), channelListWidget);
	channelListLayout->addWidget(channelLabel);
	m_channelListChooser = new QComboBox(channelListWidget);
	m_channelListChooser->setFixedSize(100, 20);
	m_channelListChooser->addItems(channels);
	m_channelListChooser->setCurrentIndex(currentChannelIndex);
	channelListLayout->addWidget(m_channelListChooser);
	channelListWidget->setLayout(channelListLayout);
	mainLayout->addWidget(channelListWidget, 0, Qt::AlignCenter);
 
	//stack widget dei grafi
	m_toneCurveStackedWidget = new QStackedWidget(this);
	Histograms *histograms = new Histograms(0, true);
	fxHistogramRender->setHistograms(histograms);
	int i;
	for (i = 0; i < channelCount; i++) {
		ChennelCurveEditor *c = new ChennelCurveEditor(this, histograms->getHistogramView(i));
		m_toneCurveStackedWidget->addWidget(c);
		connect(c, SIGNAL(firstLastXPostionChanged(int, int)), this, SLOT(onFirstLastXPostionChanged(int, int)));
	}
 
	QWidget *w = new QWidget(this);
	QHBoxLayout *layout = new QHBoxLayout(w);
	layout->setMargin(0);
	layout->setSpacing(0);
	layout->addWidget(m_toneCurveStackedWidget);
	w->setLayout(layout);
	mainLayout->addWidget(w, 0, Qt::AlignHCenter);
	m_toneCurveStackedWidget->setCurrentIndex(currentChannelIndex);
 
	//stack widget degli slider
	m_sliderStackedWidget = new QStackedWidget(this);
	for (i = 0; i < channelCount; i++) {
		IntPairField *intPairSlider = new IntPairField(this);
		intPairSlider->setFixedHeight(20);
		intPairSlider->setLabelsEnabled(false);
		intPairSlider->setRange(0, 255);
		intPairSlider->setValues(std::make_pair(0, 255));
		m_sliderStackedWidget->addWidget(intPairSlider);
		connect(intPairSlider, SIGNAL(valuesChanged(bool)), this, SLOT(sliderValueChanged(bool)));
	}
	mainLayout->addWidget(m_sliderStackedWidget);
	m_sliderStackedWidget->setCurrentIndex(currentChannelIndex);
 
	mainLayout->addSpacing(10);
	m_isLinearCheckBox = new CheckBox(QString("Linear"), this);
	mainLayout->addWidget(m_isLinearCheckBox, 0, Qt::AlignHCenter);
	connect(m_isLinearCheckBox, SIGNAL(clicked(bool)), SLOT(setLinearManually(bool)));
	connect(m_isLinearCheckBox, SIGNAL(toggled(bool)), SLOT(setLinear(bool)));
 
	connect(m_channelListChooser, SIGNAL(currentIndexChanged(int)), m_toneCurveStackedWidget, SLOT(setCurrentIndex(int)));
	connect(m_channelListChooser, SIGNAL(currentIndexChanged(int)), m_sliderStackedWidget, SLOT(setCurrentIndex(int)));
	connect(m_channelListChooser, SIGNAL(currentIndexChanged(int)), this, SIGNAL(currentChannelIndexChanged(int)));
 
	setLayout(mainLayout);
}
 
//-----------------------------------------------------------------------------
 
void ToneCurveField::setCurrentChannel(int currentChannel)
{
	m_channelListChooser->setCurrentIndex(currentChannel);
}
 
//-----------------------------------------------------------------------------
 
ChennelCurveEditor *ToneCurveField::getChannelEditor(int channel) const
{
	ChennelCurveEditor *c = dynamic_cast<ChennelCurveEditor *>(m_toneCurveStackedWidget->widget(channel));
	assert(c);
	return c;
}
 
//-----------------------------------------------------------------------------
 
ChennelCurveEditor *ToneCurveField::getCurrentChannelEditor() const
{
	return getChannelEditor(m_toneCurveStackedWidget->currentIndex());
}
 
//-----------------------------------------------------------------------------
 
IntPairField *ToneCurveField::getCurrentSlider() const
{
	return dynamic_cast<IntPairField *>(m_sliderStackedWidget->currentWidget());
}
 
//-----------------------------------------------------------------------------
 
void ToneCurveField::sliderValueChanged(bool isDragging)
{
	std::pair<int, int> values = getCurrentSlider()->getValues();
	getCurrentChannelEditor()->setFirstLastXPosition(values, isDragging);
}
 
//-----------------------------------------------------------------------------
 
void ToneCurveField::onFirstLastXPostionChanged(int x0, int x1)
{
	std::pair<int, int> values = getCurrentSlider()->getValues();
	if (values.first != x0 || values.second != x1)
		getCurrentSlider()->setValues(std::make_pair(x0, x1));
}
 
//-----------------------------------------------------------------------------
 
void ToneCurveField::setIsLinearCheckBox(bool isChecked)
{
	if (m_isLinearCheckBox->isChecked() == isChecked)
		return;
	m_isLinearCheckBox->setChecked(isChecked);
}
 
//-----------------------------------------------------------------------------
 
void ToneCurveField::setLinear(bool isLinear)
{
	int i;
	for (i = 0; i < m_sliderStackedWidget->count(); i++)
		getChannelEditor(i)->setLinear(isLinear);
}
 
//-----------------------------------------------------------------------------
 
void ToneCurveField::setLinearManually(bool isLinear)
{
	emit isLinearChanged(isLinear);
}