#include "toonzqt/functionpanel.h"

// TnzQt includes

#include "toonzqt/functionselection.h"

#include "toonzqt/functionsegmentviewer.h"

#include "toonzqt/imageutils.h"

#include "functionpaneltools.h"

#include "toonzqt/gutil.h"

// TnzLib includes

#include "toonz/tframehandle.h"

#include "toonz/doubleparamcmd.h"

#include "toonz/toonzfolders.h"

// TnzBase includes

#include "tdoubleparam.h"

#include "tdoublekeyframe.h"

#include "tunit.h"

// TnzCore includes

#include "tcommon.h"

// Qt includes

#include <qpainter></qpainter>

#include <qmouseevent></qmouseevent>

#include <qwheelevent></qwheelevent>

#include <qmenu></qmenu>

#include <qsettings></qsettings>

#include <cmath></cmath>

namespace

{

void drawCircle(QPainter &painter, double x, double y, double r)

{

	painter.drawEllipse(x - r, y - r, 2 * r, 2 * r);

}

void drawCircle(QPainter &painter, const QPointF &p, double r)

{

	painter.drawEllipse(p.x() - r, p.y() - r, 2 * r, 2 * r);

}

void drawSquare(QPainter &painter, double x, double y, double r)

{

	painter.drawRect(x - r, y - r, 2 * r, 2 * r);

}

void drawSquare(QPainter &painter, const QPointF &p, double r)

{

	drawSquare(painter, p.x(), p.y(), r);

}

void drawRoundedSquare(QPainter &painter, const QPointF &p, double r)

{

	painter.drawRoundRect(p.x() - r, p.y() - r, 2 * r, 2 * r, 99, 99);

}

double norm2(const QPointF &p) { return p.x() * p.x() + p.y() * p.y(); }

class FunctionPanelZoomer : public ImageUtils::ShortcutZoomer

{

	FunctionPanel *m_panel;

public:

	FunctionPanelZoomer(FunctionPanel *panel) : ShortcutZoomer(panel), m_panel(panel) {}

	bool zoom(bool zoomin, bool resetZoom)

	{

		if (resetZoom)

			m_panel->fitGraphToWindow();

		else {

			double f = 1.25;

			double sc = zoomin ? f : 1.0 / f;

			QPoint center(m_panel->width() / 2, m_panel->height() / 2);

			m_panel->zoom(sc, sc, center);

		}

		return true;

	}

};

} // namespace

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

//

// Ruler

//

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

class Ruler

{

	double m_minValue, m_step;

	int m_labelPeriod, m_labelOffset, m_tickCount;

	double m_unit, m_pan, m_vOrigin;

	int m_x0, m_x1;

	int m_minLabelDistance, m_minDistance;

	double m_minStep;

public:

	Ruler();

	// unit,pan define the world to viewport transformation: pixel = value * unit + pan

	// note: unit can be <0 (e.g. in the vertical rulers)

	// use vOrigin!=0 when there is a offset between values and labels

	// (e.g. frame=0 is visualized as 1)

	void setTransform(double unit, double pan, double vOrigin = 0)

	{

		m_unit = unit;

		m_pan = pan;

		m_vOrigin = vOrigin;

	}

	void setRange(int x0, int x1)

	{

		m_x0 = x0;

		m_x1 = x1;

	} // [x0,x1] is the pixel range

	// set minimum distance (pixel) between two consecutive labels

	void setMinLabelDistance(int distance) { m_minLabelDistance = distance; }

	// set minimum distance (pixel) between two consecutive ticks

	void setMinDistance(int distance) { m_minDistance = distance; }

	// use setMinStep to define a minimum tick (e.g. for integer rulers as 'frame' call setMinStep(1);)

	void setMinStep(double step) { m_minStep = step; }

	void compute(); // call compute() once, before calling the following methods

	int getTickCount() const { return m_tickCount; }

	double getTick(int index) const { return m_minValue + index * m_step; }

	bool isLabel(int index) const { return ((m_labelOffset + index) % m_labelPeriod) == 0; }

};

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

Ruler::Ruler()

	: m_minValue(0), m_step(1), m_labelPeriod(2), m_labelOffset(0), m_tickCount(0), m_unit(1), m_pan(0), m_x0(0), m_x1(100), m_minLabelDistance(20), m_minDistance(5), m_minStep(0)

{

}

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

void Ruler::compute()

{

	assert(m_x0 < m_x1);

	assert(m_unit != 0.0);

	assert(m_minLabelDistance > 0);

	assert(m_minDistance >= 0);

	// compute m_step (world distance between two adjacent ticks)

	// and m_labelPeriod (number of ticks between two adjacent labels)

	// the distance (world units) between two labels must be >= minLabelWorldDistance

	const double absUnit = std::abs(m_unit);

	const double minLabelWorldDistance = m_minLabelDistance / absUnit;

	const double minWorldDistance = m_minDistance / absUnit;

	// we want the minimum step with:

	//    step*labelPeriod (i.e. label distance) >=  minLabelWorldDistance

	//    step (i.e. tick distance) >= minWorldDistance

	// Note: labelPeriod alternates between 5 and 2 => labelPeriod' = 7-labelPeriod

	m_step = 1;

	m_labelPeriod = 5;

	if (m_step * m_labelPeriod >= minLabelWorldDistance && m_step >= minWorldDistance) {

		while (m_step >= minLabelWorldDistance && m_step / (7 - m_labelPeriod) >= minWorldDistance) {

			m_labelPeriod = 7 - m_labelPeriod;

			m_step /= m_labelPeriod;

		}

	} else {

		do {

			m_step *= m_labelPeriod;

			m_labelPeriod = 7 - m_labelPeriod; // m_labelPeriod alternates between 5 and 2

		} while (m_step * m_labelPeriod < minLabelWorldDistance || m_step < minWorldDistance);

	}

	if (m_step >= minLabelWorldDistance) {

		m_labelPeriod = 1;

	}

	if (m_step * m_labelPeriod < m_minStep) {

		m_step = m_minStep;

		m_labelPeriod = 1;

	} else if (m_step < m_minStep) {

		m_step *= m_labelPeriod;

		m_labelPeriod = 1;

	}

	// compute range

	double v0 = (m_x0 - m_pan) / m_unit; // left margin (world units)

	double v1 = (m_x1 - m_pan) / m_unit; // right margin (world units)

	if (m_unit < 0)

		tswap(v0, v1);

	int i0 = tfloor((v0 - m_vOrigin) / m_step); // largest tick <=v0 is i0 * m_step

	int i1 = tceil((v1 - m_vOrigin) / m_step);  // smallest tick >=v1 is i1 * m_step

	m_minValue = i0 * m_step + m_vOrigin;

	m_tickCount = i1 - i0 + 1;

	m_labelOffset = i0 >= 0 ? (i0 % m_labelPeriod) : (m_labelPeriod - ((-i0) % m_labelPeriod));

}

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

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

//

// FunctionPanel::Gadget

//

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

FunctionPanel::Gadget::Gadget(

	FunctionPanel::Handle handle,

	int kIndex,

	const QPointF &p,

	int rx, int ry,

	const QPointF &pointPos)

	: m_handle(handle), m_kIndex(kIndex), m_hitRegion(QRect((int)p.x() - rx, (int)p.y() - ry, 2 * rx, 2 * ry)), m_pos(p), m_pointPos(pointPos), m_channel(0), m_keyframePosition(0)

{

}

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

//

// FunctionPanel

//

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

FunctionPanel::FunctionPanel(QWidget *parent)

	: QDialog(parent), m_functionTreeModel(0), m_viewTransform(), m_valueAxisX(50), m_frameAxisY(50), m_graphViewportY(50), m_frameHandle(0), m_dragTool(0), m_currentFrameStatus(0), m_selection(0), m_curveShape(SMOOTH)

{

	setWindowTitle(tr("Function Curves"));

	m_viewTransform.translate(50, 200);

	m_viewTransform.scale(5, -1);

	setFocusPolicy(Qt::ClickFocus);

	setMouseTracking(true);

	m_highlighted.handle = None;

	m_highlighted.gIndex = -1;

	m_cursor.visible = false;

	m_cursor.frame = m_cursor.value = 0;

	m_curveLabel.text = "";

	m_curveLabel.curve = 0;

	//load the dialog size

	TFilePath fp(ToonzFolder::getMyModuleDir() + TFilePath(mySettingsFileName));

	QSettings mySettings(toQString(fp), QSettings::IniFormat);

	mySettings.beginGroup("Dialogs");

	setGeometry(mySettings.value("FunctionCurves", QRect(500, 500, 400, 300)).toRect());

	mySettings.endGroup();

}

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

FunctionPanel::~FunctionPanel()

{

	//save the dialog size

	TFilePath fp(ToonzFolder::getMyModuleDir() + TFilePath(mySettingsFileName));

	QSettings mySettings(toQString(fp), QSettings::IniFormat);

	mySettings.beginGroup("Dialogs");

	mySettings.setValue("FunctionCurves", geometry());

	mySettings.endGroup();

	delete m_dragTool;

}

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

double FunctionPanel::getPixelRatio(TDoubleParam *curve) const

{

	double framePixelSize = xToFrame(1) - xToFrame(0);

	assert(framePixelSize > 0);

	double valuePixelSize = fabs(yToValue(curve, 1) - yToValue(curve, 0));

	assert(valuePixelSize > 0);

	return framePixelSize / valuePixelSize;

}

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

double FunctionPanel::frameToX(double f) const

{

	return m_viewTransform.m11() * f + m_viewTransform.dx();

}

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

double FunctionPanel::xToFrame(double x) const

{

	return (x - m_viewTransform.dx()) / m_viewTransform.m11();

}

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

double FunctionPanel::valueToY(TDoubleParam *curve, double v) const

{

	const double bigNumber = 1.0e9;

	TMeasure *m = curve->getMeasure();

	if (m) {

		const TUnit *unit = m->getCurrentUnit();

		v = unit->convertTo(v);

	}

	return tcrop(m_viewTransform.m22() * v + m_viewTransform.dy(), -bigNumber, bigNumber);

}

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

double FunctionPanel::yToValue(TDoubleParam *curve, double y) const

{

	double v = (y - m_viewTransform.dy()) / m_viewTransform.m22();

	TMeasure *m = curve->getMeasure();

	if (m) {

		const TUnit *unit = m->getCurrentUnit();

		v = unit->convertFrom(v);

	}

	return v;

}

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

void FunctionPanel::pan(int dx, int dy)

{

	QTransform m;

	m.translate(dx, dy);

	m_viewTransform *= m;

	update();

}

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

void FunctionPanel::zoom(double sx, double sy, const QPoint ¢er)

{

	QTransform m;

	m.translate(center.x(), center.y());

	m.scale(sx, sy);

	m.translate(-center.x(), -center.y());

	m_viewTransform *= m;

	update();

}

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

QPointF FunctionPanel::getWinPos(TDoubleParam *curve, double frame, double value) const

{

	return QPointF(frameToX(frame), valueToY(curve, value));

}

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

QPointF FunctionPanel::getWinPos(TDoubleParam *curve, double frame) const

{

	return getWinPos(curve, frame, curve->getValue(frame));

}

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

QPointF FunctionPanel::getWinPos(TDoubleParam *curve, const TDoubleKeyframe &kf) const

{

	return getWinPos(curve, kf.m_frame, kf.m_value);

}

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

int FunctionPanel::getCurveDistance(TDoubleParam *curve, const QPoint &winPos)

{

	double frame = xToFrame(winPos.x());

	double value = curve->getValue(frame);

	double curveY = valueToY(curve, value);

	return std::abs(curveY - winPos.y());

}

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

FunctionTreeModel::Channel *FunctionPanel::findClosestChannel(const QPoint &winPos, int maxWinDistance)

{

	FunctionTreeModel::Channel *closestChannel = 0;

	int minDistance = maxWinDistance;

	int i;

	for (i = 0; i < m_functionTreeModel->getActiveChannelCount(); i++) {

		FunctionTreeModel::Channel *channel = m_functionTreeModel->getActiveChannel(i);

		TDoubleParam *curve = channel->getParam();

		int distance = getCurveDistance(curve, winPos);

		if (distance < minDistance) {

			closestChannel = channel;

			minDistance = distance;

		}

	}

	return closestChannel;

}

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

TDoubleParam *FunctionPanel::findClosestCurve(const QPoint &winPos, int maxWinDistance)

{

	FunctionTreeModel::Channel *closestChannel = findClosestChannel(winPos, maxWinDistance);

	return closestChannel ? closestChannel->getParam() : 0;

}

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

// return the gadget index (-1 if no gadget is close enough)

int FunctionPanel::findClosestGadget(const QPoint &winPos, Handle &handle, int maxDistance)

{

	// search only handles close enough (i.e. distance

	int minDistance = maxDistance;

	int k = -1;

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

		if (m_gadgets[i].m_hitRegion.contains(winPos)) {

			QPoint p;

			double d = (m_gadgets[i].m_hitRegion.center() - winPos).manhattanLength();

			if (d < minDistance) {

				k = i;

				minDistance = d;

			}

		}

	}

	if (k >= 0) {

		handle = m_gadgets[k].m_handle;

		return k; // m_gadgets[k].m_kIndex;

	} else {

		handle = None;

		return -1;

	}

}

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

TDoubleParam *FunctionPanel::getCurrentCurve() const

{

	FunctionTreeModel::Channel *currentChannel =

		m_functionTreeModel ? m_functionTreeModel->getCurrentChannel() : 0;

	if (!currentChannel)

		return 0;

	else

		return currentChannel->getParam();

}

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

QPainterPath FunctionPanel::getSegmentPainterPath(TDoubleParam *curve, int segmentIndex, int x0, int x1)

{

	double frame0 = xToFrame(x0), frame1 = xToFrame(x1);

	int kCount = curve->getKeyframeCount();

	int step = 1;

	if (kCount > 0) {

		if (segmentIndex < 0)

			frame1 = std::min(frame1, curve->keyframeIndexToFrame(0)); // before first keyframe

		else if (segmentIndex >= kCount - 1)

			frame0 = std::max(frame0, curve->keyframeIndexToFrame(kCount - 1)); // after last keyframe

		else {

			// between keyframes

			TDoubleKeyframe kf = curve->getKeyframe(segmentIndex);

			frame0 = std::max(frame0, kf.m_frame);

			double f = curve->keyframeIndexToFrame(segmentIndex + 1);

			frame1 = std::min(frame1, f);

			step = kf.m_step;

		}

	}

	if (frame0 >= frame1)

		return QPainterPath();

	double frame;

	double df = xToFrame(3) - xToFrame(0);

	if (m_curveShape == SMOOTH) {

		frame = frame0;

	} else //FRAME_BASED

	{

		frame = (double)tfloor(frame0);

		df = std::max(df, 1.0);

	}

	QPainterPath path;

	if (0 <= segmentIndex && segmentIndex < kCount && step > 1) {

		// step>1

		path.moveTo(getWinPos(curve, frame));

		int f0 = curve->keyframeIndexToFrame(segmentIndex);

		int vFrame = f0 + tfloor(tfloor(frame - f0), step);

		double vValue = curve->getValue(vFrame);

		assert(vFrame <= frame);

		assert(vFrame + step > frame);

		while (vFrame + step < frame1) {

			vValue = curve->getValue(vFrame);

			path.lineTo(getWinPos(curve, vFrame, vValue));

			vFrame += step;

			path.lineTo(getWinPos(curve, vFrame, vValue));

			vValue = curve->getValue(vFrame);

			path.lineTo(getWinPos(curve, vFrame, vValue));

		}

		path.lineTo(getWinPos(curve, frame1, vValue));

		path.lineTo(getWinPos(curve, frame1, curve->getValue(frame1, true)));

	} else {

		// step = 1

		path.moveTo(getWinPos(curve, frame));

		while (frame + df < frame1) {

			frame += df;

			path.lineTo(getWinPos(curve, frame));

		}

		path.lineTo(getWinPos(curve, frame1, curve->getValue(frame1, true)));

	}

	return path;

}

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

void FunctionPanel::drawCurrentFrame(QPainter &painter)

{

	int currentframe = 0;

	if (m_frameHandle)

		currentframe = m_frameHandle->getFrame();

	int x = frameToX(currentframe);

	if (m_currentFrameStatus == 0)

		painter.setPen(Qt::magenta);

	else if (m_currentFrameStatus == 1)

		painter.setPen(Qt::white);

	else

		painter.setPen(m_selectedColor);

	int y = m_graphViewportY + 1;

	painter.drawLine(x - 1, y, x - 1, height());

	painter.drawLine(x + 1, y, x + 1, height());

}

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

void FunctionPanel::drawFrameGrid(QPainter &painter)

{

	QFontMetrics fm(painter.font());

	// ruler background

	painter.setPen(Qt::NoPen);

	painter.setBrush(getRulerBackground());

	painter.drawRect(0, 0, width(), m_frameAxisY);

	// draw ticks and labels

	Ruler ruler;

	ruler.setTransform(m_viewTransform.m11(), m_viewTransform.dx(), -1);

	ruler.setRange(m_valueAxisX, width());

	ruler.setMinLabelDistance(fm.width("-8888") + 2);

	ruler.setMinDistance(5);

	ruler.setMinStep(1);

	ruler.compute();

	for (int i = 0; i < ruler.getTickCount(); i++) {

		double f = ruler.getTick(i);

		bool isLabel = ruler.isLabel(i);

		int x = frameToX(f);

		painter.setPen(m_textColor);

		int y = m_frameAxisY;

		painter.drawLine(x, y - (isLabel ? 4 : 2), x, y);

		painter.setPen(getFrameLineColor());

		painter.drawLine(x, m_graphViewportY, x, height());

		if (isLabel) {

			painter.setPen(m_textColor);

			QString labelText = QString::number(f + 1);

			painter.drawText(x - fm.width(labelText) / 2, y - 6, labelText);

		}

	}

}

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

void FunctionPanel::drawValueGrid(QPainter &painter)

{

	TDoubleParam *curve = getCurrentCurve();

	if (!curve)

		return;

	QFontMetrics fm(painter.font());

	// ruler background

	painter.setPen(Qt::NoPen);

	painter.setBrush(getRulerBackground());

	painter.drawRect(0, 0, m_valueAxisX, height());

	Ruler ruler;

	ruler.setTransform(m_viewTransform.m22(), m_viewTransform.dy());

	ruler.setRange(m_graphViewportY, height());

	ruler.setMinLabelDistance(fm.height() + 2);

	ruler.setMinDistance(5);

	ruler.compute();

	painter.setBrush(Qt::NoBrush);

	for (int i = 0; i < ruler.getTickCount(); i++) {

		double v = ruler.getTick(i);

		bool isLabel = ruler.isLabel(i);

		int y = tround(m_viewTransform.m22() * v + m_viewTransform.dy()); // valueToY(curve, v);

		painter.setPen(m_textColor);

		int x = m_valueAxisX;

		painter.drawLine(x - (isLabel ? 5 : 2), y, x, y);

		painter.setPen(getValueLineColor());

		painter.drawLine(x, y, width(), y);

		if (isLabel) {

			painter.setPen(m_textColor);

			QString labelText = QString::number(v);

			painter.drawText(std::max(0, x - 5 - fm.width(labelText)), y + fm.height() / 2, labelText);

		}

	}

	if (false && ruler.getTickCount() > 10) {

		double value = ruler.getTick(9);

		double dv = fabs(ruler.getTick(10));

		double frame = 10;

		double df = dv * getPixelRatio(curve);

		QPointF p0 = getWinPos(curve, frame, value);

		QPointF p1 = getWinPos(curve, frame + df, value + dv);

		painter.setPen(Qt::magenta);

		painter.drawRect(p0.x(), p0.y(), (p1 - p0).x(), (p1 - p0).y());

	}

}

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

void FunctionPanel::drawOtherCurves(QPainter &painter)

{

	painter.setRenderHint(QPainter::Antialiasing, false);

	painter.setBrush(Qt::NoBrush);

	int x0 = m_valueAxisX;

	int x1 = width();

	QPen solidPen;

	QPen dashedPen;

	QVector<qreal> dashes;</qreal>

	dashes << 4 << 4;

	dashedPen.setDashPattern(dashes);

	for (int i = 0; i < m_functionTreeModel->getActiveChannelCount(); i++) {

		FunctionTreeModel::Channel *channel = m_functionTreeModel->getActiveChannel(i);

		if (channel->isCurrent())

			continue;

		TDoubleParam *curve = channel->getParam();

		QColor color = curve == m_curveLabel.curve ? m_selectedColor : getOtherCurvesColor();

		solidPen.setColor(color);

		dashedPen.setColor(color);

		painter.setBrush(Qt::NoBrush);

		int kCount = curve->getKeyframeCount();

		if (kCount == 0) {

			// no control points

			painter.setPen(dashedPen);

			painter.drawPath(getSegmentPainterPath(curve, 0, x0, x1));

		}

		//draw control points and handles

		else {

			for (int k = -1; k < kCount; k++) {

				painter.setPen((k < 0 || k >= kCount - 1) ? dashedPen : solidPen);

				painter.drawPath(getSegmentPainterPath(curve, k, x0, x1));

			}

			painter.setPen(m_textColor);

			painter.setBrush(m_subColor);

			for (int k = 0; k < kCount; k++) {

				double frame = curve->keyframeIndexToFrame(k);

				QPointF p = getWinPos(curve, frame, curve->getValue(frame));

				painter.drawRect(p.x() - 1, p.y() - 1, 3, 3);

				QPointF p2 = getWinPos(curve, frame, curve->getValue(frame, true));

				if (p2.y() != p.y()) {

					painter.drawRect(p2.x() - 1, p2.y() - 1, 3, 3);

					painter.setPen(solidPen);

					painter.drawLine(p, p2);

					painter.setPen(m_textColor);

				}

			}

		}

	}

	painter.setBrush(Qt::NoBrush);

	painter.setPen(m_textColor);

	painter.setRenderHint(QPainter::Antialiasing, false);

}

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

void FunctionPanel::updateGadgets(TDoubleParam *curve)

{

	m_gadgets.clear();

	TDoubleKeyframe oldKf;

	oldKf.m_type = TDoubleKeyframe::None;

	int keyframeCount = curve->getKeyframeCount();

	for (int i = 0; i != keyframeCount; ++i) {

		const int pointHitRadius = 10, handleHitRadius = 6;

		TDoubleKeyframe kf = curve->getKeyframe(i);

		kf.m_value = curve->getValue(kf.m_frame); // Some keyframe values do NOT correspond to the

												  // actual displayed curve value (eg with expressions)

		// Build keyframe positions

		QPointF p = getWinPos(curve, kf.m_frame);

		QPointF pLeft = p;

		if (i == keyframeCount - 1 && curve->isCycleEnabled())					 // This is probably OBSOLETE. I don't think the

			p = getWinPos(curve, kf.m_frame, curve->getValue(kf.m_frame, true)); // GUI allows cycling single curves nowadays...

																				 // However, is the assignment correct?

		// Add keyframe gadget(s)

		m_gadgets.push_back(Gadget(Point, i, p, pointHitRadius, pointHitRadius));

		TPointD currentPointRight(kf.m_frame, kf.m_value);

		TPointD currentPointLeft(currentPointRight);

		// If the previous segment or the current segment are not keyframe based,

		// the curve can have two different values in kf.m_frame

		if (i > 0 && (!TDoubleKeyframe::isKeyframeBased(kf.m_type) ||						// Keyframe-based are the above mentioned curves

					  !TDoubleKeyframe::isKeyframeBased(curve->getKeyframe(i - 1).m_type))) // where values stored in keyframes are not used

		{																					// to calculate the actual curve values.

			currentPointLeft.y = curve->getValue(kf.m_frame, true);

			pLeft = getWinPos(curve, currentPointLeft);

			m_gadgets.push_back(Gadget(Point, i, pLeft, pointHitRadius, pointHitRadius));

		}

		// Add handle gadgets (eg the speed or ease handles)

		if (getSelection()->isSelected(curve, i)) {

			// Left handle

			switch (oldKf.m_type) {

			case TDoubleKeyframe::SpeedInOut: {

				TPointD speedIn = curve->getSpeedIn(i);

				if (norm2(speedIn) > 0) {

					QPointF q = getWinPos(curve, currentPointLeft + speedIn);

					m_gadgets.push_back(Gadget(SpeedIn, i, q, handleHitRadius, handleHitRadius, pLeft));

				}

				break;

			}

			case TDoubleKeyframe::EaseInOut: {

				QPointF q = getWinPos(curve, kf.m_frame + kf.m_speedIn.x);

				m_gadgets.push_back(Gadget(EaseIn, i, q, 6, 15));

				break;

			}

			case TDoubleKeyframe::EaseInOutPercentage: {

				double easeIn = kf.m_speedIn.x * (kf.m_frame - oldKf.m_frame) * 0.01;

				QPointF q = getWinPos(curve, kf.m_frame + easeIn);

				m_gadgets.push_back(Gadget(EaseInPercentage, i, q, 6, 15));

				break;

			}

			}

			// Right handle

			if (i != keyframeCount - 1) {

				switch (kf.m_type) {

				case TDoubleKeyframe::SpeedInOut: {

					TPointD speedOut = curve->getSpeedOut(i);

					if (norm2(speedOut) > 0) {

						QPointF q = getWinPos(curve, currentPointRight + speedOut);

						m_gadgets.push_back(Gadget(SpeedOut, i, q, handleHitRadius, handleHitRadius, p));

					}

					break;

				}

				case TDoubleKeyframe::EaseInOut: {

					QPointF q = getWinPos(curve, kf.m_frame + kf.m_speedOut.x);

					m_gadgets.push_back(Gadget(EaseOut, i, q, 6, 15));

					break;

				}

				case TDoubleKeyframe::EaseInOutPercentage: {

					double segmentWidth = curve->keyframeIndexToFrame(i + 1) - kf.m_frame;

					double easeOut = segmentWidth * kf.m_speedOut.x * 0.01;

					QPointF q = getWinPos(curve, kf.m_frame + easeOut);

					m_gadgets.push_back(Gadget(EaseOutPercentage, i, q, 6, 15));

					break;

				}

				}

			}

		}

		oldKf = kf;

	}

	// Add group gadgets (ie those that can be added when multiple channels share the same keyframe data)

	int channelCount = m_functionTreeModel->getActiveChannelCount();

	// Using a map of vectors. Yes, really. The *ideal* way would be that of copying the first keyframes

	// vector, and then comparing it with the others from each channel - keeping the common data only...

	typedef std::map<double, std::vector<tdoublekeyframe="">> KeyframeTable; // frame -> { keyframes }</double,>

	KeyframeTable keyframes;

	for (int i = 0; i != channelCount; ++i) {

		FunctionTreeModel::Channel *channel = m_functionTreeModel->getActiveChannel(i);

		if (!channel)

			continue;

		TDoubleParam *curve = channel->getParam();

		for (int j = 0; j != curve->getKeyframeCount(); ++j) {

			TDoubleKeyframe kf = curve->getKeyframe(j); // Well... this stuff gets called upon *painting*  o_o'

			keyframes[kf.m_frame].push_back(kf);		// It's bound to be slow. Do we really need it?

		}

	}

	int groupHandleY = m_graphViewportY - 6;

	KeyframeTable::iterator it, iEnd(keyframes.end()), iLast(keyframes.empty() ? iEnd : --iEnd);

	for (KeyframeTable::iterator it = keyframes.begin(); it != keyframes.end(); ++it) {

		assert(!it->second.empty());

		double frame = it->first; // redundant, already in the key... oh well

		QPointF p(frameToX(frame), groupHandleY);

		Gadget gadget((FunctionPanel::Handle)100, -1, p, 6, 6); // No idea what the '100' type value mean...

		gadget.m_keyframePosition = frame;

		m_gadgets.push_back(gadget);

		TDoubleKeyframe kf = it->second[0];

		if ((int)it->second.size() < channelCount)

			continue;

		// All channels had this keyframe - so, add further gadgets about stuff...

		for (int i = 1; i < channelCount; ++i) {

			// Find out if keyframes data differs

			const TDoubleKeyframe &kf2 = it->second[i];

			if (kf.m_type != kf2.m_type || kf.m_speedOut.x != kf2.m_speedOut.x)

				kf.m_type = TDoubleKeyframe::None;

			if (kf.m_prevType != kf2.m_prevType || kf.m_speedIn.x != kf2.m_speedIn.x)

				kf.m_prevType = TDoubleKeyframe::None;

		}

		// NOTE: EaseInOutPercentage are currently NOT SUPPORTED - they would be harder to code and

		//       controversial, since the handle position depends on the *segment size* too.

		//       So, keyframe data could be shared, but adjacent segment lengths could not...

		if (it != iLast &&

			(kf.m_type == TDoubleKeyframe::SpeedInOut || kf.m_type == TDoubleKeyframe::EaseInOut) &&

			kf.m_speedOut.x != 0) {

			QPointF p(frameToX(frame + kf.m_speedOut.x), groupHandleY);

			Gadget gadget((FunctionPanel::Handle)101, -1, p, 6, 15); // type value...

			gadget.m_keyframePosition = frame;

			m_gadgets.push_back(gadget);

		}

		if ((kf.m_prevType == TDoubleKeyframe::SpeedInOut || kf.m_prevType == TDoubleKeyframe::EaseInOut) &&

			kf.m_speedIn.x != 0) {

			QPointF p(frameToX(frame + kf.m_speedIn.x), groupHandleY);

			Gadget gadget((FunctionPanel::Handle)102, -1, p, 6, 15); // type value...

			gadget.m_keyframePosition = frame;

			m_gadgets.push_back(gadget);

		}

	}

}

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

void FunctionPanel::drawCurrentCurve(QPainter &painter)

{

	FunctionTreeModel::Channel *channel =

		m_functionTreeModel ? m_functionTreeModel->getCurrentChannel() : 0;

	if (!channel)

		return;

	TDoubleParam *curve = channel->getParam();

	painter.setRenderHint(QPainter::Antialiasing, true);

	QColor color = Qt::red;

	QPen solidPen(color);

	QPen dashedPen(color);

	QVector<qreal> dashes;</qreal>

	dashes << 4 << 4;

	dashedPen.setDashPattern(dashes);

	painter.setBrush(Qt::NoBrush);

	int x0 = m_valueAxisX;

	int x1 = width();

	// draw curve

	int kCount = curve->getKeyframeCount();

	if (kCount == 0) {

		// no control points

		painter.setPen(dashedPen);

		painter.drawPath(getSegmentPainterPath(curve, 0, x0, x1));

	} else {

		for (int k = -1; k < kCount; k++) {

			if (k < 0 || k >= kCount - 1) {

				painter.setPen(dashedPen);

				painter.drawPath(getSegmentPainterPath(curve, k, x0, x1));

			} else {

				TDoubleKeyframe::Type segmentType = curve->getKeyframe(k).m_type;