#include "functionpaneltools.h"

// TnzQt includes

#include "toonzqt/functionselection.h"

// TnzLib includes

#include "toonz/tframehandle.h"

// TnzCore includes

#include "tundo.h"

// Qt includes

#include <qpainter></qpainter>

#include <qmouseevent></qmouseevent>

#include <qmultimap></qmultimap>

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

MoveFrameDragTool::MoveFrameDragTool(FunctionPanel *panel,

                                     TFrameHandle *frameHandle)

    : m_panel(panel), m_frameHandle(frameHandle) {}

void MoveFrameDragTool::drag(QMouseEvent *e) {

  double frame = m_panel->xToFrame(e->pos().x());

  m_panel->getSelection()->deselectAllKeyframes();

  m_frameHandle->setFrame(frame);

}

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

PanDragTool::PanDragTool(FunctionPanel *panel, bool xLocked, bool yLocked)

    : m_panel(panel), m_xLocked(xLocked), m_yLocked(yLocked) {}

void PanDragTool::click(QMouseEvent *e) { m_oldPos = e->pos(); }

void PanDragTool::drag(QMouseEvent *e) {

  QPoint delta = e->pos() - m_oldPos;

  if (m_xLocked) delta.setX(0);

  if (m_yLocked) delta.setY(0);

  m_panel->pan(delta);

  m_oldPos = e->pos();

}

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

/*--- Ruler部分ドラッグによるズーム ---*/

void ZoomDragTool::click(QMouseEvent *e) {

  m_startPos = m_oldPos = m_startPos = e->pos();

}

void ZoomDragTool::drag(QMouseEvent *e) {

  QPoint delta = e->pos() - m_oldPos;

  m_oldPos     = e->pos();

  double sx = 1, sy = 1;

  // reflect horizontal drag for frame zoom

  double zoomFactor =

      exp(-0.0075 * ((m_zoomType == FrameZoom) ? -delta.x() : delta.y()));

  if (m_zoomType == FrameZoom)

    sx = zoomFactor;

  else

    sy = zoomFactor;

  m_panel->zoom(sx, sy, m_startPos);

}

void ZoomDragTool::release(QMouseEvent *e) {

  if ((e->pos() - m_startPos).manhattanLength() < 2) {

    double frame = m_panel->xToFrame(e->pos().x());

    if (m_panel->getFrameHandle()) m_panel->getFrameHandle()->setFrame(frame);

  }

}

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

void RectSelectTool::click(QMouseEvent *e) {

  m_startPos = e->pos();

  m_rect     = QRect();

}

void RectSelectTool::drag(QMouseEvent *e) {

  m_rect = QRect(m_startPos, e->pos()).normalized();

  m_panel->getSelection()->deselectAllKeyframes();

  for (int i = 0; i < m_curve->getKeyframeCount(); i++) {

    QPointF p = m_panel->getWinPos(m_curve, m_curve->getKeyframe(i));

    if (m_rect.contains(tround(p.x()), tround(p.y())))

      m_panel->getSelection()->select(m_curve, i);

  }

  m_panel->update();

}

void RectSelectTool::release(QMouseEvent *e) { m_panel->update(); }

void RectSelectTool::draw(QPainter &painter) {

  painter.setPen(Qt::white);

  painter.setBrush(QColor(255, 255, 255, 127));

  if (!m_rect.isEmpty()) painter.drawRect(m_rect);

}

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

MovePointDragTool::MovePointDragTool(FunctionPanel *panel, TDoubleParam *curve)

    : m_panel(panel)

    , m_deltaFrame(0)

    , m_speed0Length(0)

    , m_speed0Index(-1)

    , m_speed1Length(0)

    , m_speed1Index(-1)

    , m_groupEnabled(false)

    , m_selection(0) {

  // This undo block is closed in the destructor

  TUndoManager::manager()->beginBlock();

  if (curve) {

    KeyframeSetter *setter = new KeyframeSetter(curve);

    m_setters.push_back(setter);

  } else {

    m_groupEnabled           = true;

    FunctionTreeModel *model = panel->getModel();

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

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

      if (channel && channel->getParam()) {

        TDoubleParam *curve    = channel->getParam();

        KeyframeSetter *setter = new KeyframeSetter(curve);

        m_setters.push_back(setter);

      }

    }

  }

}

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

MovePointDragTool::~MovePointDragTool() {

  for (int i = 0; i < (int)m_setters.size(); i++) delete m_setters[i];

  m_setters.clear();

  TUndoManager::manager()->endBlock();

}

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

void MovePointDragTool::addKeyframe2(int kIndex) {

  assert(m_setters.size() == 1);

  if (m_setters.size() == 1) m_setters[0]->selectKeyframe(kIndex);

}

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

void MovePointDragTool::createKeyframe(double frame) {

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

    KeyframeSetter *setter = m_setters[i];

    int kIndex             = setter->createKeyframe(tround(frame));

    setter->selectKeyframe(kIndex);

  }

}

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

void MovePointDragTool::selectKeyframes(double frame) {

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

    KeyframeSetter *setter = m_setters[i];

    TDoubleParam *curve    = setter->getCurve();

    setter->setPixelRatio(m_panel->getPixelRatio(curve));

    int kIndex = curve->getClosestKeyframe(frame);

    if (kIndex >= 0) {

      double kf = curve->keyframeIndexToFrame(kIndex);

      if (fabs(kf - frame) < 0.01) setter->selectKeyframe(kIndex);

    }

  }

}

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

void MovePointDragTool::setSelection(FunctionSelection *selection) {

  if (selection) {

    assert(m_setters.size() == 1);

    if (m_setters.size() == 1) {

      TDoubleParam *curve = m_setters[0]->getCurve();

      assert(curve);

      if (curve) {

        m_selection = selection;

        for (int i = 0; i < curve->getKeyframeCount(); i++)

          if (selection->isSelected(curve, i)) addKeyframe2(i);

      }

    }

  } else

    m_selection = selection;

}

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

void MovePointDragTool::click(QMouseEvent *e) {

  m_startPos = m_oldPos = e->pos();

  m_deltaFrame          = 0;

  double frame          = m_panel->xToFrame(e->pos().x());

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

    KeyframeSetter *setter = m_setters[i];

    TDoubleParam *curve    = setter->getCurve();

    setter->setPixelRatio(m_panel->getPixelRatio(curve));

    if (!m_groupEnabled) {

      int kIndex = curve->getClosestKeyframe(frame);

      if (kIndex >= 0) {

        double kf = curve->keyframeIndexToFrame(kIndex);

        if (fabs(kf - frame) < 1) setter->selectKeyframe(kIndex);

      }

    }

  }

}

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

void MovePointDragTool::drag(QMouseEvent *e) {

  QPoint pos = e->pos();

  // if shift is pressed then apply constraints (only horizontal or vertical

  // moves)

  if (e->modifiers() & Qt::ShiftModifier) {

    QPoint delta = e->pos() - m_startPos;

    if (abs(delta.x()) > abs(delta.y()))

      pos.setY(m_startPos.y());

    else

      pos.setX(m_startPos.x());

  }

  if (m_groupEnabled) pos.setY(m_startPos.y());

  QPoint oldPos = m_oldPos;

  m_oldPos      = pos;

  // compute frame increment. it must be an integer

  double totalDFrame =

      tround(m_panel->xToFrame(pos.x()) - m_panel->xToFrame(m_startPos.x()));

  double dFrame = totalDFrame - m_deltaFrame;

  m_deltaFrame  = totalDFrame;

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

    KeyframeSetter *setter = m_setters[i];

    TDoubleParam *curve    = setter->getCurve();

    // compute value increment

    double dValue = m_panel->yToValue(curve, pos.y()) -

                    m_panel->yToValue(curve, oldPos.y());

    setter->moveKeyframes(dFrame, dValue);

  }

  if (m_selection != 0 && m_setters.size() == 1) {

    KeyframeSetter *setter = m_setters[0];

    m_selection->deselectAllKeyframes();

    for (int i = 0; i < setter->getCurve()->getKeyframeCount(); i++)

      if (setter->isSelected(i)) m_selection->select(setter->getCurve(), i);

  }

  m_panel->update();

}

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

void MovePointDragTool::release(QMouseEvent *e) {}

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

MoveHandleDragTool::MoveHandleDragTool(FunctionPanel *panel,

                                       TDoubleParam *curve, int kIndex,

                                       Handle handle)

    : m_panel(panel)

    , m_curve(curve)

    , m_kIndex(kIndex)

    , m_handle(handle)

    , m_deltaFrame(0)

    , m_setter(curve, kIndex)

    , m_segmentWidth(0)

    , m_channelGroup(0) {}

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

void MoveHandleDragTool::click(QMouseEvent *e) {

  m_startPos = e->pos();

  // m_startPos = m_oldPos = e->pos();

  m_deltaFrame       = 0;

  m_keyframe         = m_curve->getKeyframe(m_kIndex);

  m_keyframe.m_value = m_curve->getValue(m_keyframe.m_frame);

  if (m_handle == FunctionPanel::SpeedIn)

    m_keyframe.m_value = m_curve->getValue(m_keyframe.m_frame, true);

  if (m_channelGroup) {

    for (int i = 0; i < m_channelGroup->getChildCount(); i++) {

      TreeModel::Item *child = m_channelGroup->getChild(i);

      FunctionTreeModel::Channel *channel =

          dynamic_cast<functiontreemodel::channel *="">(child);</functiontreemodel::channel>

      if (channel && m_curve != channel->getParam()) {

        if (channel->getParam()->isKeyframe(m_keyframe.m_frame)) {

        }

      }

    }

  }

  if (m_handle == FunctionPanel::EaseInPercentage && m_kIndex > 0) {

    double previousFrame = m_curve->keyframeIndexToFrame(m_kIndex - 1);

    m_segmentWidth       = m_keyframe.m_frame - previousFrame;

  }

  if (m_handle == FunctionPanel::EaseOutPercentage &&

      m_kIndex + 1 < m_curve->getKeyframeCount()) {

    double nextFrame = m_curve->keyframeIndexToFrame(m_kIndex + 1);

    m_segmentWidth   = nextFrame - m_keyframe.m_frame;

  }

  TPointD speed;

  if (m_keyframe.m_linkedHandles) {

    if (m_handle == FunctionPanel::SpeedIn &&

        m_kIndex + 1 < m_curve->getKeyframeCount() &&

        (m_keyframe.m_type != TDoubleKeyframe::SpeedInOut &&

         (m_keyframe.m_type != TDoubleKeyframe::Expression ||

          m_keyframe.m_expressionText.find("cycle") == std::string::npos)))

      speed = m_curve->getSpeedIn(m_kIndex);

    else if (m_handle == FunctionPanel::SpeedOut &&

             m_keyframe.m_prevType != TDoubleKeyframe::SpeedInOut &&

             m_kIndex > 0)

      speed = m_curve->getSpeedOut(m_kIndex);

  }

  if (norm2(speed) > 0.001) {

    QPointF a = m_panel->getWinPos(m_curve, speed) -

                m_panel->getWinPos(m_curve, TPointD());

    double aa = 1.0 / sqrt(a.x() * a.x() + a.y() * a.y());

    m_nSpeed  = QPointF(-a.y() * aa, a.x() * aa);

  } else

    m_nSpeed = QPointF();

  m_setter.setPixelRatio(m_panel->getPixelRatio(m_curve));

}

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

void MoveHandleDragTool::drag(QMouseEvent *e) {

  if (!m_curve) return;

  QPoint pos = e->pos();

  // if shift is pressed then apply constraints (only horizontal or vertical

  // moves)

  if (e->modifiers() & Qt::ShiftModifier) {

    QPoint delta = e->pos() - m_startPos;

    if (abs(delta.x()) > abs(delta.y()))

      pos.setY(m_startPos.y());

    else

      pos.setX(m_startPos.x());

  }

  // QPoint oldPos = m_oldPos;

  // m_oldPos = pos;

  QPointF p0 = m_panel->getWinPos(m_curve, m_keyframe);

  QPointF posF(pos);

  if (m_nSpeed != QPointF(0, 0)) {

    QPointF delta = posF - p0;

    posF -= m_nSpeed * (delta.x() * m_nSpeed.x() + delta.y() * m_nSpeed.y());

    if ((m_handle == FunctionPanel::SpeedIn && posF.x() > p0.x()) ||

        (m_handle == FunctionPanel::SpeedOut && posF.x() < p0.x()))

      posF = p0;

  } else {

    if ((m_handle == FunctionPanel::SpeedIn && posF.x() > p0.x()) ||

        (m_handle == FunctionPanel::SpeedOut && posF.x() < p0.x()))

      posF.setX(p0.x());

  }

  double frame = m_panel->xToFrame(posF.x());

  double value = m_panel->yToValue(m_curve, posF.y());

  TPointD handlePos(frame - m_keyframe.m_frame, value - m_keyframe.m_value);

  switch (m_handle) {

  case FunctionPanel::SpeedIn:

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

    }

    m_setter.setSpeedIn(handlePos);

    break;

  case FunctionPanel::SpeedOut:

    m_setter.setSpeedOut(handlePos);

    break;

  case FunctionPanel::EaseIn:

    m_setter.setEaseIn(handlePos.x);

    break;

  case FunctionPanel::EaseOut:

    m_setter.setEaseOut(handlePos.x);

    break;

  case FunctionPanel::EaseInPercentage:

    if (m_segmentWidth > 0)

      m_setter.setEaseIn(100.0 * handlePos.x / m_segmentWidth);

    break;

  case FunctionPanel::EaseOutPercentage:

    if (m_segmentWidth > 0)

      m_setter.setEaseOut(100.0 * handlePos.x / m_segmentWidth);

    break;

  case 100:

  case 101:

  case 102:

    break;

  default:

    assert(0);

  }

  m_panel->update();

}

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

void MoveHandleDragTool::release(QMouseEvent *e) {}

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

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

MoveGroupHandleDragTool::MoveGroupHandleDragTool(FunctionPanel *panel,

                                                 double keyframePosition,

                                                 Handle handle)

    : m_panel(panel), m_keyframePosition(keyframePosition), m_handle(handle) {

  TUndoManager::manager()->beginBlock();

}

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

MoveGroupHandleDragTool::~MoveGroupHandleDragTool() {

  for (int i = 0; i < (int)m_setters.size(); i++) delete m_setters[i].second;

  m_setters.clear();

  TUndoManager::manager()->endBlock();

}

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

void MoveGroupHandleDragTool::click(QMouseEvent *e) {

  for (int i = 0; i < (int)m_setters.size(); i++) delete m_setters[i].second;

  m_setters.clear();

  FunctionTreeModel *model = m_panel->getModel();

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

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

    if (channel && channel->getParam()) {

      TDoubleParam *curve    = channel->getParam();

      int kIndex             = curve->getClosestKeyframe(m_keyframePosition);

      KeyframeSetter *setter = new KeyframeSetter(curve, kIndex);

      setter->setPixelRatio(m_panel->getPixelRatio(curve));

      TDoubleKeyframe kf = curve->getKeyframe(kIndex);

      m_setters.push_back(std::make_pair(kf, setter));

    }

  }

}

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

void MoveGroupHandleDragTool::drag(QMouseEvent *e) {

  //  if(!m_curve) return;

  QPoint pos = e->pos();

  QPointF posF(pos);

  /*

if(m_nSpeed != QPointF(0,0))

{

QPointF delta = posF-p0;

posF -= m_nSpeed*(delta.x()*m_nSpeed.x()+delta.y()*m_nSpeed.y());

if(  m_handle == FunctionPanel::SpeedIn && posF.x()>p0.x()

|| m_handle == FunctionPanel::SpeedOut && posF.x()

posF = p0;

}

else

{

if(  m_handle == FunctionPanel::SpeedIn && posF.x()>p0.x()

|| m_handle == FunctionPanel::SpeedOut && posF.x()

posF.setX(p0.x());

}

*/

  double frame = m_panel->xToFrame(posF.x());

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

    TDoubleKeyframe kf     = m_setters[i].first;

    KeyframeSetter *setter = m_setters[i].second;

    if (m_handle == 101)  // why the magic numbers... use enums!

    {

      kf.m_speedOut.x = frame - kf.m_frame;

      switch (kf.m_type) {

      case TDoubleKeyframe::SpeedInOut:

        setter->setSpeedOut(kf.m_speedOut);

        break;

      case TDoubleKeyframe::EaseInOut:

        setter->setEaseOut(kf.m_speedOut.x);

        break;

      default:

        assert(false);

      }

    } else if (m_handle == 102)  // aagghhrrr

    {

      kf.m_speedIn.x = frame - kf.m_frame;

      switch (kf.m_prevType) {

      case TDoubleKeyframe::SpeedInOut:

        setter->setSpeedIn(kf.m_speedIn);

        break;

      case TDoubleKeyframe::EaseInOut:

        setter->setEaseIn(kf.m_speedIn.x);

        break;

      default:

        assert(false);

      }

    }

  }

  /*

switch(m_handle)

{

case FunctionPanel::SpeedIn:

if(m_keyframe.m_type != TDoubleKeyframe::SpeedInOut)

{

}

m_setter.setSpeedIn(handlePos);

break;

case FunctionPanel::SpeedOut:m_setter.setSpeedOut(handlePos); break;

case FunctionPanel::EaseIn:m_setter.setEaseIn(handlePos.x); break;

case FunctionPanel::EaseOut:m_setter.setEaseOut(handlePos.x); break;

case FunctionPanel::EaseInPercentage:

if(m_segmentWidth>0)

m_setter.setEaseIn(100.0*handlePos.x/m_segmentWidth);

break;

case FunctionPanel::EaseOutPercentage:

if(m_segmentWidth>0)

m_setter.setEaseOut(100.0*handlePos.x/m_segmentWidth);

break;

case 100:

case 101:

case 102:

break;

default:assert(0);

}

*/

  m_panel->update();

}

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

void MoveGroupHandleDragTool::release(QMouseEvent *e) {

  for (int i = 0; i < (int)m_setters.size(); i++) delete m_setters[i].second;

  m_setters.clear();

}

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

StretchPointDragTool::StretchPointDragTool(FunctionPanel *panel,

                                           TDoubleParam *curve, int leftId,

                                           int rightId, bool moveLeft)

    : m_panel(panel), m_curve(curve), m_moveLeft(moveLeft) {

  // This undo block is closed in the destructor

  TUndoManager::manager()->beginBlock();

  for (int k = leftId; k <= rightId; k++) {

    KeyframeSetter *setter = new KeyframeSetter(curve);

    setter->selectKeyframe(k);

    m_keys.append({k, curve->getKeyframe(k).m_frame,

                   curve->getKeyframe(k).m_speedIn,

                   curve->getKeyframe(k).m_speedOut, setter});

  }

  m_previousRange =

      m_keys.value(rightId).orgFramePos - m_keys.value(leftId).orgFramePos;

}

StretchPointDragTool::~StretchPointDragTool() {

  TUndoManager::manager()->endBlock();

}

void StretchPointDragTool::click(QMouseEvent *e) {

  m_clickedFrame = m_panel->xToFrame(e->pos().x());

}

void StretchPointDragTool::drag(QMouseEvent *e) {

  double currentPosFrame = m_panel->xToFrame(e->pos().x());

  // moved distance

  double dFrame = currentPosFrame - m_clickedFrame;

  double orgRange = m_keys.last().orgFramePos - m_keys.first().orgFramePos;

  // frame range after stretched

  double stretchedRange = (m_moveLeft) ? orgRange - dFrame : orgRange + dFrame;

  // the frame range should not be smaller than [selected key amount] - 1.

  stretchedRange = std::max(stretchedRange, (double)m_keys.size() - 1.);

  // selection should not extend the neighbor unselected key

  if (m_moveLeft && m_keys.first().kIndex > 0) {

    double maxRange = m_keys.last().orgFramePos -

                      m_curve->getKeyframe(m_keys.first().kIndex - 1).m_frame -

                      1.;

    stretchedRange = std::min(stretchedRange, maxRange);

  } else if (!m_moveLeft &&

             m_keys.last().kIndex < m_curve->getKeyframeCount() - 1) {

    double maxRange = m_curve->getKeyframe(m_keys.last().kIndex + 1).m_frame -

                      m_keys.first().orgFramePos - 1.;

    stretchedRange = std::min(stretchedRange, maxRange);

  }

  if (stretchedRange == m_previousRange) return;

  // compute the key frame positions (int) after stretching

  QMultiMap<int, int=""> keyPlacement;  // frame(int) - kIndex multimap</int,>

  // if the frame range is equal to [selected key amount] - 1, keys will be

  // "packed" in every frames.

  if ((int)std::round(stretchedRange) == m_keys.size() - 1) {

    int f = (m_moveLeft) ? (int)(m_keys.last().orgFramePos - stretchedRange)

                         : (int)m_keys.first().orgFramePos;

    for (auto keyInfo : m_keys) {

      keyPlacement.insert(f, keyInfo.kIndex);

      f++;

    }

  } else {  // other cases

    // stretch ratio

    double stretchRatio = stretchedRange / orgRange;

    double pivot =

        (m_moveLeft) ? m_keys.last().orgFramePos : m_keys.first().orgFramePos;

    // compute preferable key frame positions (double) after stretching

    QMap<int, double=""> stretchedKeyPlacement;  // kIndex - frame(double)</int,>

    for (auto keyInfo : m_keys) {

      double sf =

          pivot * (1. - stretchRatio) + keyInfo.orgFramePos * stretchRatio;

      stretchedKeyPlacement.insert(keyInfo.kIndex, sf);

    }

    // now, put keys in integer frame positions, minimizing error.

    // first, put the keys at both ends

    int kFrom = m_keys.first().kIndex;

    int kTo   = m_keys.last().kIndex;

    keyPlacement.insert((int)std::round(stretchedKeyPlacement.value(kFrom)),

                        kFrom);

    keyPlacement.insert((int)std::round(stretchedKeyPlacement.value(kTo)), kTo);

    for (int i = 1; i < m_keys.size() - 1;

         i++) {  // put other intermediate keys

      keyInfo info = m_keys.at(i);

      // if the nearest integer position is vacant, put the key and continue

      int tmp_f = (int)std::round(stretchedKeyPlacement.value(info.kIndex));

      if (!keyPlacement.contains(tmp_f)) {

        keyPlacement.insert(tmp_f, info.kIndex);

        continue;

      }

      // evaluate errors with two candidate - insert key at round down or round

      // up postions. inserting the key may push out the existing key.

      int f1 = (int)std::floor(stretchedKeyPlacement.value(info.kIndex));

      int f2 = f1 + 1;

      {

        bool ok1 = true;

        bool ok2 = true;

        // a list after inserting the key at round down position

        QMultiMap<int, int=""> candidate1 =</int,>

            keyPlacement;  // frame(int) - kIndex multimap

        int moveId = candidate1.value(f1);

        candidate1.insert(f1, info.kIndex);

        while (1) {

          // move the key to the previous frame

          candidate1.remove(f1, moveId);

          // if the frame is vacant, put the key and break

          if (!candidate1.contains(f1 - 1)) {

            candidate1.insert(f1 - 1, moveId);

            break;

          }

          // if the frame is occupied, switch the current moving key and "push

          // out" it

          int occupiedId = candidate1.value(f1 - 1);

          candidate1.insert(f1 - 1, moveId);

          moveId = occupiedId;

          f1 -= 1;

          // the moving key should not be the first one

          if (moveId == kFrom) {

            ok1 = false;

            break;

          }

        }

        // a list after inserting the key at round up position

        QMultiMap<int, int=""> candidate2 =</int,>

            keyPlacement;  // frame(int) - kIndex multimap

        moveId = candidate2.value(f2);

        candidate2.insert(f2, info.kIndex);

        while (1) {

          // move the key to the nexy frame

          candidate2.remove(f2, moveId);

          // if the frame is vacant, put the key and break

          if (!candidate2.contains(f2 + 1)) {

            candidate2.insert(f2 + 1, moveId);

            break;

          }

          // if the frame is occupied, switch the current moving key and "push

          // out" it

          int occupiedId = candidate2.value(f2 + 1);

          candidate2.insert(f2 + 1, moveId);

          moveId = occupiedId;

          f2 += 1;

          // the moving key should not be the last one

          if (moveId == kTo) {

            ok2 = false;

            break;

          }

        }

        if (!ok2)

          keyPlacement = candidate1;

        else if (!ok1)

          keyPlacement = candidate2;

        else {

          double error1                         = 0.;

          QMultiMap<int, int="">::const_iterator i = candidate1.constBegin();</int,>

          while (i != candidate1.constEnd()) {

            error1 += std::abs((double)i.key() -

                               stretchedKeyPlacement.value(i.value()));

            ++i;

          }

          double error2 = 0.;

          i             = candidate2.constBegin();

          while (i != candidate2.constEnd()) {

            error2 += std::abs((double)i.key() -

                               stretchedKeyPlacement.value(i.value()));

            ++i;

          }

          if (error1 <= error2)

            keyPlacement = candidate1;

          else

            keyPlacement = candidate2;

        }

      }

    }

  }

  // each setter will move key frame

  bool extending = stretchedRange > m_previousRange;

  QList<double> segRatio;</double>

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

    double orgSegLength =

        m_keys.at(i + 1).orgFramePos - m_keys.at(i).orgFramePos;

    double newSegLength = (double)(keyPlacement.key(m_keys.at(i + 1).kIndex) -

                                   keyPlacement.key(m_keys.at(i).kIndex));

    segRatio.append(newSegLength / orgSegLength);

  }

  // dragging left + shrink or dragging right + extend cases

  // move from right key to left key

  int start = (m_moveLeft != extending) ? m_keys.size() - 1 : 0;

  int end   = (m_moveLeft != extending) ? -1 : m_keys.size();

  int dki   = (m_moveLeft != extending) ? -1 : 1;

  for (int ki = start; ki != end; ki += dki) {

    int kId      = m_keys[ki].kIndex;

    int curFrame = (int)std::round(m_curve->getKeyframe(kId).m_frame);

    int dstFrame = keyPlacement.key(kId);

    if (curFrame != dstFrame) {

      m_keys[ki].setter->moveKeyframes(dstFrame - curFrame, 0.);

    }

    m_keys[ki].setter->selectKeyframe(kId);

    if (ki != 0 && segRatio[ki - 1] != 1.) {

      if (m_keys[ki].setter->isSpeedInOut(kId - 1))

        m_keys[ki].setter->setSpeedIn(

            TPointD(m_keys[ki].orgSpeedIn.x * segRatio[ki - 1],

                    m_keys[ki].orgSpeedIn.y));

      else if (m_keys[ki].setter->isEaseInOut(kId - 1))

        m_keys[ki].setter->setEaseIn(m_keys[ki].orgSpeedIn.x *

                                     segRatio[ki - 1]);

    }

    if (ki != m_keys.size() - 1 && segRatio[ki] != 1.) {

      if (m_keys[ki].setter->isSpeedInOut(kId))

        m_keys[ki].setter->setSpeedOut(TPointD(

            m_keys[ki].orgSpeedOut.x * segRatio[ki], m_keys[ki].orgSpeedOut.y));

      else if (m_keys[ki].setter->isEaseInOut(kId))

        m_keys[ki].setter->setEaseOut(m_keys[ki].orgSpeedOut.x * segRatio[ki]);

    }

  }

  m_previousRange = stretchedRange;

  m_panel->update();

}

void StretchPointDragTool::release(QMouseEvent *e) {

  for (int i = 0; i < (int)m_keys.size(); i++) delete m_keys[i].setter;

  m_keys.clear();

}