#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"

#include "toonz/preferences.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 final : public ImageUtils::ShortcutZoomer {

  FunctionPanel *m_panel;

public:

  FunctionPanelZoomer(FunctionPanel *panel)

      : ShortcutZoomer(panel), m_panel(panel) {}

  bool zoom(bool zoomin, bool resetZoom) override {

    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) std::swap(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, bool isFloating)

    : 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)

    , m_isFloating(isFloating) {

  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;

  if (m_isFloating) {

    // load the dialog size

    TFilePath fp(ToonzFolder::getMyModuleDir() + TFilePath("popups.ini"));

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

    setGeometry(

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

  }

}

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

FunctionPanel::~FunctionPanel() {

  if (m_isFloating) {

    // save the dialog size

    TFilePath fp(ToonzFolder::getMyModuleDir() + TFilePath("popups.ini"));

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

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

  }

  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="">></double,>

      KeyframeTable;  // frame -> { keyframes }

  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);

    }

  }