#include "vectorselectiontool.h"

// TnzTools includes

#include "tools/toolhandle.h"

#include "tools/imagegrouping.h"

#include "tools/cursors.h"

// TnzQt includes

#include "toonzqt/selectioncommandids.h"

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/imageutils.h"

// TnzLib includes

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tstageobject.h"

// TnzBase includes

#include "tenv.h"

// TnzCore includes

#include "drawutil.h"

using namespace ToolUtils;

using namespace DragSelectionTool;

//********************************************************************************

//    Global variables

//********************************************************************************

namespace {

VectorSelectionTool l_vectorSelectionTool(TTool::Vectors);

TEnv::IntVar l_strokeSelectConstantThickness("SelectionToolConstantThickness",

                                             0);

TEnv::IntVar l_strokeSelectIncludeIntersection(

    "SelectionToolIncludeIntersection", 0);

const int l_dragThreshold = 10;  //!< Distance, in pixels, the user has to

                                 //!  move from a button press to trigger a

                                 //!  selection drag.

}  // namespace

//********************************************************************************

//    Local namespace  stuff

//********************************************************************************

namespace {

FourPoints getFourPointsFromVectorImage(const TVectorImageP &img,

                                        const std::set<int> &styleIds,</int>

                                        double &maxThickness) {

  FourPoints p;

  if (styleIds.empty()) {

    p = img->getBBox();

    for (UINT i = 0; i < img->getStrokeCount(); i++) {

      TStroke *s = img->getStroke(i);

      for (int j = 0; j < s->getControlPointCount(); j++) {

        double thick = s->getControlPoint(j).thick;

        if (maxThickness < thick) maxThickness = thick;

      }

    }

  } else {

    TRectD bbox;

    for (UINT i = 0; i < img->getStrokeCount(); i++) {

      TStroke *s = img->getStroke(i);

      if (!styleIds.count(s->getStyle())) continue;

      if (bbox.isEmpty())

        bbox = s->getBBox();

      else

        bbox += s->getBBox();

      for (int j = 0; j < s->getControlPointCount(); j++) {

        double thick = s->getControlPoint(j).thick;

        if (maxThickness < thick) maxThickness = thick;

      }

    }

    p = bbox;

  }

  return p;

}

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

bool getStrokeIndexFromPos(UINT &index, const TVectorImageP &vi,

                           const TPointD &pos, double pixelSize, TAffine aff) {

  if (!vi) return false;

  double t, dist2 = 0;

  double maxDist   = 5 * pixelSize;

  double maxDist2  = maxDist * maxDist;

  double checkDist = maxDist2 * 4;

  if (vi->getNearestStroke(pos, t, index, dist2)) {

    TStroke *strokeRef = vi->getStroke(index);

    TThickPoint cursor = strokeRef->getThickPoint(t);

    double len         = cursor.thick * pixelSize * sqrt(aff.det());

    checkDist          = std::max(checkDist, (len * len));

  }

  return (dist2 < checkDist);

}

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

static bool currentOrNotSelected(const VectorSelectionTool &tool,

                                 const TFrameId &fid) {

  return (tool.getCurrentFid() == fid ||

          (tool.isSelectedFramesType() &&

           tool.getSelectedFrames().count(fid) == 0));

}

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

inline void notifySelectionChanged() {

  TTool::getApplication()->getCurrentSelection()->notifySelectionChanged();

}

}  // namespace

//********************************************************************************

//    VectorFreeDeformer  implementation

//********************************************************************************

VectorFreeDeformer::VectorFreeDeformer(TVectorImageP vi,

                                       std::set<int> strokeIndexes)</int>

    : FreeDeformer()

    , m_vi(vi)

    , m_strokeIndexes(strokeIndexes)

    , m_preserveThickness(false)

    , m_computeRegion(false)

    , m_flip(false) {

  TRectD r;

  std::set<int>::iterator it, iEnd = m_strokeIndexes.end();</int>

  for (it = m_strokeIndexes.begin(); it != iEnd; ++it) {

    TStroke *stroke = m_vi->getStroke(*it);

    r += stroke->getBBox();

    m_originalStrokes.push_back(new TStroke(*stroke));

  }

  m_originalP00 = r.getP00();

  m_originalP11 = r.getP11();

  m_newPoints.push_back(m_originalP00);

  m_newPoints.push_back(r.getP10());

  m_newPoints.push_back(m_originalP11);

  m_newPoints.push_back(r.getP01());

}

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

VectorFreeDeformer::~VectorFreeDeformer() {

  clearPointerContainer(m_originalStrokes);

}

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

void VectorFreeDeformer::setPreserveThickness(bool preserveThickness) {

  m_preserveThickness = preserveThickness;

}

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

void VectorFreeDeformer::setComputeRegion(bool computeRegion) {

  m_computeRegion = computeRegion;

}

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

void VectorFreeDeformer::setFlip(bool flip) { m_flip = flip; }

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

void VectorFreeDeformer::setPoint(int index, const TPointD &p) {

  m_newPoints[index] = p;

}

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

void VectorFreeDeformer::setPoints(const TPointD &p0, const TPointD &p1,

                                   const TPointD &p2, const TPointD &p3) {

  m_newPoints[0] = p0;

  m_newPoints[1] = p1;

  m_newPoints[2] = p2;

  m_newPoints[3] = p3;

}

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

void VectorFreeDeformer::deformRegions() {

  if (m_strokeIndexes.empty() || !m_computeRegion) return;

  std::vector<int> selectedIndexes(m_strokeIndexes.begin(),</int>

                                   m_strokeIndexes.end());

  m_vi->notifyChangedStrokes(selectedIndexes, m_originalStrokes, m_flip);

  m_computeRegion = false;

}

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

void VectorFreeDeformer::deformImage() {

  // debug

  assert(m_strokeIndexes.size() == m_originalStrokes.size());

  // release

  if (m_strokeIndexes.size() != m_originalStrokes.size()) {

    return;

  }

  QMutexLocker lock(m_vi->getMutex());

  std::size_t i = 0;

  for (auto it = m_strokeIndexes.begin(), end = m_strokeIndexes.end();

       it != end; ++it) {

    TStroke *stroke         = m_vi->getStroke(*it);

    TStroke *originalStroke = m_originalStrokes[i++];

    assert(stroke->getControlPointCount() ==

           originalStroke->getControlPointCount());

    for (int j = 0, count = stroke->getControlPointCount(); j < count; ++j) {

      TThickPoint p = deform(originalStroke->getControlPoint(j));

      stroke->setControlPoint(j, p);

    }

  }

  if (m_computeRegion) deformRegions();

}

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

TThickPoint VectorFreeDeformer::deform(TThickPoint point) {

  double vs  = m_originalP11.x - m_originalP00.x;

  double s   = (vs == 0) ? 0 : (point.x - m_originalP00.x) / vs;

  double vt  = m_originalP11.y - m_originalP00.y;

  double t   = (vt == 0) ? 0 : (point.y - m_originalP00.y) / vt;

  TPointD A  = m_newPoints[0];

  TPointD B  = m_newPoints[1];

  TPointD C  = m_newPoints[2];

  TPointD D  = m_newPoints[3];

  TPointD AD = (1 - t) * A + t * D;

  TPointD BC = (1 - t) * B + t * C;

  TPointD p  = (1 - s) * AD + s * BC;

  double thickness = point.thick;

  if (!m_preserveThickness) {

    double eps          = 1.e-2;

    TPointD p0x         = TPointD(p.x - eps, p.x);

    TPointD p1x         = TPointD(p.x + eps, p.x);

    TPointD p0y         = TPointD(p.x, p.y - eps);

    TPointD p1y         = TPointD(p.x, p.y + eps);

    m_preserveThickness = true;

    TThickPoint newp0x  = deform(p0x);

    TThickPoint newp1x  = deform(p1x);

    TThickPoint newp0y  = deform(p0y);

    TThickPoint newp1y  = deform(p1y);

    m_preserveThickness = false;

    double newA         = fabs(cross(newp1x - newp0x, newp1y - newp0y));

    double a            = 4 * eps * eps;

    thickness *= sqrt(newA / a);

  }

  return TThickPoint(p, thickness);

}

//********************************************************************************

//    UndoChangeStrokes  implementation

//********************************************************************************

DragSelectionTool::UndoChangeStrokes::UndoChangeStrokes(

    TXshSimpleLevel *level, const TFrameId &frameId, VectorSelectionTool *tool,

    const StrokeSelection &selection)

    : ToolUtils::TToolUndo(level, frameId)

    , m_tool(tool)

    , m_selectionCount(tool->getSelectionCount())  // Not related to selection

    , m_oldBBox(tool->getBBox())

    , m_oldCenter(tool->getCenter())

    , m_oldDeformValues(tool->m_deformValues)

    , m_newDeformValues()

    , m_flip(false) {

  TVectorImageP vi = m_level->getFrame(m_frameId, false);

  if (!vi) {

    assert(vi);

    return;

  }

  const StrokeSelection::IndexesContainer &indexes = selection.getSelection();

  m_indexes.assign(indexes.begin(), indexes.end());

  registerStrokes(true);

}

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

DragSelectionTool::UndoChangeStrokes::UndoChangeStrokes(

    TXshSimpleLevel *level, const TFrameId &frameId, VectorSelectionTool *tool,

    const LevelSelection &selection)

    : ToolUtils::TToolUndo(level, frameId)

    , m_tool(tool)

    , m_selectionCount(tool->getSelectionCount())  // Not related to selection

    , m_oldBBox(tool->getBBox())

    , m_oldCenter(tool->getCenter())

    , m_oldDeformValues(tool->m_deformValues)

    , m_newDeformValues()

    , m_flip(false) {

  TVectorImageP vi = m_level->getFrame(m_frameId, false);

  if (!vi) {

    assert(vi);

    return;

  }

  m_indexes = getSelectedStrokes(*vi, selection);

  registerStrokes(true);

}

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

DragSelectionTool::UndoChangeStrokes::~UndoChangeStrokes() {

  clearPointerContainer(m_oldStrokes);

  clearPointerContainer(m_newStrokes);

}

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

void DragSelectionTool::UndoChangeStrokes::registerStrokes(bool beforeModify) {

  TVectorImageP vi = m_level->getFrame(m_frameId, false);

  if (!vi) {

    assert(vi);

    return;

  }

  std::vector<tstroke *=""> &strokes = beforeModify ? m_oldStrokes : m_newStrokes;</tstroke>

  TRectD bbox;

  int s, sCount = int(m_indexes.size());

  for (s = 0; s != sCount; ++s) {

    TStroke *stroke = vi->getStroke(m_indexes[s]);

    bbox += stroke->getBBox();

    strokes.push_back(new TStroke(*stroke));

  }

  if (beforeModify && !bbox.isEmpty()) {

    ImageUtils::getFillingInformationOverlappingArea(vi, m_regionsData, bbox);

  } else {

    m_newBBox         = m_tool->getBBox();

    m_newCenter       = m_tool->getCenter();

    m_newDeformValues = m_tool->m_deformValues;

  }

}

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

void DragSelectionTool::UndoChangeStrokes::transform(

    const std::vector<tstroke *=""> &strokes, FourPoints bbox, TPointD center,</tstroke>

    DragSelectionTool::DeformValues deformValues) const {

  TVectorImageP image = m_level->getFrame(m_frameId, true);

  if (!image) {

    assert(image);

    return;

  }

  int s, sCount = int(m_indexes.size());

  for (s = 0; s != sCount; ++s) {

    int index = m_indexes[s];

    TStroke *sourcesStroke = strokes[s], *stroke = image->getStroke(index);

    int cp, cpCount = stroke->getControlPointCount();

    for (cp = 0; cp != cpCount; ++cp)

      stroke->setControlPoint(cp, sourcesStroke->getControlPoint(cp));

  }

  image->notifyChangedStrokes(m_indexes, strokes, m_flip);

  if (!m_tool->isSelectionEmpty() &&

      m_selectionCount == m_tool->getSelectionCount()) {

    m_tool->setBBox(bbox);

    m_tool->setCenter(center);

  } else

    m_tool->computeBBox();

  m_tool->notifyImageChanged(m_frameId);

  m_tool->m_deformValues = deformValues;

  TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();

  TTool::getApplication()->getCurrentTool()->notifyToolChanged();

}

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

void DragSelectionTool::UndoChangeStrokes::restoreRegions() const {

  TVectorImageP vi = m_level->getFrame(m_frameId, true);

  if (!vi) {

    assert(vi);

    return;

  }

  ImageUtils::assignFillingInformation(*vi, m_regionsData);

}

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

void DragSelectionTool::UndoChangeStrokes::undo() const {

  transform(m_oldStrokes, m_oldBBox, m_oldCenter, m_oldDeformValues);

  restoreRegions();

  m_tool->notifyImageChanged();

}

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

void DragSelectionTool::UndoChangeStrokes::redo() const {

  transform(m_newStrokes, m_newBBox, m_newCenter, m_newDeformValues);

  m_tool->notifyImageChanged();

}

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

int DragSelectionTool::UndoChangeStrokes::getSize() const {

  return sizeof(*this) + sizeof(*m_tool);

}

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

// UndoChangeOutlineStyle

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

class UndoChangeOutlineStyle final : public ToolUtils::TToolUndo {

  std::vector<tstroke::outlineoptions> m_oldOptions, m_newOptions;</tstroke::outlineoptions>

  FourPoints m_oldBBox, m_newBBox;

  VectorSelectionTool *m_tool;

  std::vector<int> m_indexes;</int>

  int m_selectionCount;

public:

  UndoChangeOutlineStyle(TXshSimpleLevel *level, const TFrameId &frameId,

                         VectorSelectionTool *tool);

  ~UndoChangeOutlineStyle() {}

  void registerStrokes(bool beforeModify = false);

  void transform(const std::vector<tstroke::outlineoptions> &options,</tstroke::outlineoptions>

                 FourPoints bbox) const;

  void undo() const override;

  void redo() const override;

  int getSize() const override;

};

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

UndoChangeOutlineStyle::UndoChangeOutlineStyle(TXshSimpleLevel *level,

                                               const TFrameId &frameId,

                                               VectorSelectionTool *tool)

    : ToolUtils::TToolUndo(level, frameId)

    , m_tool(tool)

    , m_oldBBox(tool->getBBox())

    , m_selectionCount(tool->getSelectionCount()) {

  TVectorImageP image = m_level->getFrame(m_frameId, false);

  assert(!!image);

  if (!image) return;

  StrokeSelection *strokeSelection =

      dynamic_cast<strokeselection *="">(tool->getSelection());</strokeselection>

  int i;

  for (i = 0; i < (int)image->getStrokeCount(); i++) {

    if (!strokeSelection->isSelected(i) && !m_tool->isLevelType() &&

        !m_tool->isSelectedFramesType())

      continue;

    m_indexes.push_back(i);

  }

  registerStrokes(true);

}

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

void UndoChangeOutlineStyle::registerStrokes(bool beforeModify) {

  TVectorImageP image = m_level->getFrame(m_frameId, false);

  assert(!!image);

  if (!image) return;

  int i;

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

    if (beforeModify)

      m_oldOptions.push_back(image->getStroke(m_indexes[i])->outlineOptions());

    else

      m_newOptions.push_back(image->getStroke(m_indexes[i])->outlineOptions());

  }

  if (!beforeModify) m_newBBox = m_tool->getBBox();

}

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

void UndoChangeOutlineStyle::transform(

    const std::vector<tstroke::outlineoptions> &options,</tstroke::outlineoptions>

    FourPoints bbox) const {

  TVectorImageP image = m_level->getFrame(m_frameId, true);

  assert(!!image);

  if (!image) return;

  int i;

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

    int index                                 = m_indexes[i];

    image->getStroke(index)->outlineOptions() = options[i];

  }

  if (!m_tool->isSelectionEmpty() &&

      m_selectionCount == m_tool->getSelectionCount())

    m_tool->setBBox(bbox);

  else

    m_tool->computeBBox();

  m_tool->notifyImageChanged(m_frameId);

  TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();

  TTool::getApplication()->getCurrentTool()->notifyToolChanged();

}

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

void UndoChangeOutlineStyle::undo() const {

  transform(m_oldOptions, m_oldBBox);

  TTool::getApplication()->getCurrentTool()->notifyToolChanged();

  m_tool->notifyImageChanged();

}

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

void UndoChangeOutlineStyle::redo() const {

  transform(m_newOptions, m_newBBox);

  TTool::getApplication()->getCurrentTool()->notifyToolChanged();

  m_tool->notifyImageChanged();

}

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

int UndoChangeOutlineStyle::getSize() const {

  // NOTE: This is definitely wrong... sizeof(vector) DOES NOT correspond to its

  // actual size - as it is internally allocated with new!!

  return sizeof(*this) + sizeof(*m_tool);

}

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

// VectorDeformTool::VFDScopedBlock

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

struct VectorDeformTool::VFDScopedBlock  //! Type bounding the scope of free

                                         //! deformers in the tool.

{

  VFDScopedBlock(SelectionTool *tool) : m_tool(tool) {

    m_tool->setNewFreeDeformer();

  }

  ~VFDScopedBlock() { m_tool->clearDeformers(); }

private:

  SelectionTool *m_tool;  //!< [\p external]  Tool owning the deformers.

};

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

// VectorDeformTool

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

DragSelectionTool::VectorDeformTool::VectorDeformTool(VectorSelectionTool *tool)

    : DeformTool(tool), m_undo() {

  if (!TTool::getApplication()->getCurrentObject()->isSpline()) {

    m_undo.reset(new UndoChangeStrokes(

        TTool::getApplication()->getCurrentLevel()->getSimpleLevel(),

        tool->getCurrentFid(), tool, tool->strokeSelection()));

  }

}

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

DragSelectionTool::VectorDeformTool::~VectorDeformTool() {

  // DO NOT REMOVE - DESTRUCTS TYPES INCOMPLETE IN THE HEADER

}

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

void DragSelectionTool::VectorDeformTool::applyTransform(FourPoints bbox,

                                                         bool onFastDragging) {

  SelectionTool *tool = getTool();

  std::unique_ptr<vfdscopedblock> localVfdScopedBlock;</vfdscopedblock>

  if (!m_vfdScopedBlock) {

    std::unique_ptr<vfdscopedblock> &vfdScopedBlock =</vfdscopedblock>

        m_isDragging ? m_vfdScopedBlock : localVfdScopedBlock;

    vfdScopedBlock.reset(new VFDScopedBlock(tool));

  }

  VectorFreeDeformer *freeDeformer =

      static_cast<vectorfreedeformer *="">(tool->getFreeDeformer());</vectorfreedeformer>

  const bool stayedTheSame = bbox.getP00() == freeDeformer->getPoint(0) &&

                             bbox.getP10() == freeDeformer->getPoint(1) &&

                             bbox.getP11() == freeDeformer->getPoint(2) &&

                             bbox.getP01() == freeDeformer->getPoint(3);

  freeDeformer->setPoints(bbox.getP00(), bbox.getP10(), bbox.getP11(),

                          bbox.getP01());

  freeDeformer->setComputeRegion(!m_isDragging);

  freeDeformer->setPreserveThickness(tool->isConstantThickness());

  freeDeformer->setFlip(isFlip());

  if (!TTool::getApplication()->getCurrentObject()->isSpline() && m_undo)

    m_undo->setFlip(isFlip());

  freeDeformer->deformImage();

  tool->invalidate();

  if (!m_isDragging) tool->notifyImageChanged();

  if (!stayedTheSame) tool->m_deformValues.m_isSelectionModified = true;

  if (!m_isDragging && (tool->isLevelType() || tool->isSelectedFramesType()))

    transformWholeLevel();

}

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

void DragSelectionTool::VectorDeformTool::addTransformUndo() {

  if (TTool::getApplication()->getCurrentObject()->isSpline())

    TUndoManager::manager()->add(

        new UndoPath(getTool()

                         ->getXsheet()

                         ->getStageObject(getTool()->getObjectId())

                         ->getSpline()));

  else if (m_undo) {

    m_undo->registerStrokes();

    TUndoManager::manager()->add(m_undo.release());

  }

}

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

void DragSelectionTool::VectorDeformTool::transformWholeLevel() {

  VectorSelectionTool *tool = dynamic_cast<vectorselectiontool *="">(m_tool);</vectorselectiontool>

  assert(tool);

  assert(!tool->levelSelection().isEmpty());

  TXshSimpleLevel *level =

      TTool::getApplication()->getCurrentLevel()->getSimpleLevel();

  std::vector<tframeid> fids;</tframeid>

  level->getFids(fids);

  // Remove unwanted fids

  fids.erase(std::remove_if(

                 fids.begin(), fids.end(),

                 [tool](const TFrameId &fid) { return currentOrNotSelected(*tool, fid); }),

             fids.end());

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

  {

    addTransformUndo();  // For current frame

    int f, fCount = int(fids.size());

    for (f = 0; f != fCount; ++f) {

      const TFrameId &fid = fids[f];

      int t               = f + 1;  // Current frame's data is always at index 0

                                    // The others are thus shifted by 1

      // Skip nonselected frames

      if (tool->getCurrentFid() == fid ||

          (tool->isSelectedFramesType() &&

           tool->getSelectedFrames().count(fid) == 0))

        continue;

      TVectorImageP vi = level->getFrame(fid, true);

      if (!vi) continue;

      std::unique_ptr<undochangestrokes> undo(</undochangestrokes>

          new UndoChangeStrokes(level, fid, tool, tool->levelSelection()));

      std::set<int> strokesIndices;</int>

      for (int s = 0; s < (int)vi->getStrokeCount(); ++s)

        strokesIndices.insert(s);

      FourPoints bbox = tool->getBBox(t);

      VectorFreeDeformer *freeDeformer =

          static_cast<vectorfreedeformer *="">(tool->getFreeDeformer(t));</vectorfreedeformer>

      freeDeformer->setPoints(bbox.getPoint(0), bbox.getPoint(1),

                              bbox.getPoint(2), bbox.getPoint(3));

      freeDeformer->setComputeRegion(true);

      freeDeformer->setPreserveThickness(tool->isConstantThickness());

      freeDeformer->setFlip(isFlip());

      freeDeformer->deformImage();

      undo->registerStrokes();

      TUndoManager::manager()->add(undo.release());

    }

  }

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

  // Finally, notify changed frames

  std::for_each(fids.begin(), fids.end(),

  // NOTE: current frame is not here - it should be,

  // but it's currently unnecessary, in fact...

  [this](const TFrameId &fid) { m_tool->notifyImageChanged(fid); });

  // notifyImageChanged(fid) must be invoked OUTSIDE of the loop - since it

  // seems to imply notifyImageChanged()

  // on CURRENT image - which seems wrong, but it's too low-level and I'm not

  // changing it.

  // This reasonably leads to computeBBox(), but bboxes are taken as INPUT to

  // this transformation...            >:(

}

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

bool DragSelectionTool::VectorDeformTool::isFlip() {

  TPointD scaleValue = getTool()->m_deformValues.m_scaleValue;

  return m_startScaleValue.x * scaleValue.x < 0 ||

         m_startScaleValue.y * scaleValue.y < 0;

}

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

void DragSelectionTool::VectorDeformTool::leftButtonUp(const TPointD &pos,

                                                       const TMouseEvent &e) {

  std::unique_ptr<vfdscopedblock> vfdScopedBlock(std::move(m_vfdScopedBlock));</vfdscopedblock>

  SelectionTool *tool = getTool();

  VectorFreeDeformer *deformer =

      dynamic_cast<vectorfreedeformer *="">(tool->getFreeDeformer());</vectorfreedeformer>

  if (!deformer) return;

  deformer->setComputeRegion(true);

  deformer->setFlip(isFlip());

  deformer->deformRegions();

  if (!tool->isLevelType() && !tool->isSelectedFramesType())

    addTransformUndo();

  else

    transformWholeLevel();

  m_isDragging = false;

  tool->notifyImageChanged();

  VectorSelectionTool *selectionTool =

      dynamic_cast<vectorselectiontool *="">(m_tool);</vectorselectiontool>

  selectionTool->setResetCenter(true);

}

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

// VectorRotationTool

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

DragSelectionTool::VectorRotationTool::VectorRotationTool(

    VectorSelectionTool *tool)

    : VectorDeformTool(tool), m_rotation(new Rotation(this)) {}

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

void DragSelectionTool::VectorRotationTool::transform(TAffine aff,

                                                      double angle) {

  SelectionTool *tool = getTool();

  FourPoints newBbox(tool->getBBox() * aff);

  TPointD center = m_rotation->getStartCenter();

  int i;

  for (i = 0; i < tool->getBBoxsCount(); i++) {

    aff = TRotation(center, angle);

    tool->setBBox(tool->getBBox(i) * aff, i);

  }

  applyTransform(newBbox);

}

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

void DragSelectionTool::VectorRotationTool::leftButtonDrag(

    const TPointD &pos, const TMouseEvent &e) {

  VectorSelectionTool *tool = dynamic_cast<vectorselectiontool *="">(m_tool);</vectorselectiontool>

  tool->setResetCenter(false);

  m_rotation->leftButtonDrag(pos, e);

}

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

void DragSelectionTool::VectorRotationTool::draw() { m_rotation->draw(); }

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

// VectorFreeDeformTool

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

DragSelectionTool::VectorFreeDeformTool::VectorFreeDeformTool(

    VectorSelectionTool *tool)

    : VectorDeformTool(tool), m_freeDeform(new FreeDeform(this)) {}

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

void DragSelectionTool::VectorFreeDeformTool::leftButtonDrag(

    const TPointD &pos, const TMouseEvent &e) {

  VectorSelectionTool *tool = dynamic_cast<vectorselectiontool *="">(m_tool);</vectorselectiontool>

  tool->setResetCenter(false);

  m_freeDeform->leftButtonDrag(pos, e);

}

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

// VectorMoveSelectionTool

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

DragSelectionTool::VectorMoveSelectionTool::VectorMoveSelectionTool(

    VectorSelectionTool *tool)

    : VectorDeformTool(tool), m_moveSelection(new MoveSelection(this)) {}

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

void DragSelectionTool::VectorMoveSelectionTool::transform(TAffine aff) {

  SelectionTool *tool = getTool();

  int i;

  for (i = 0; i < (int)tool->getBBoxsCount(); i++)

    tool->setBBox(tool->getBBox(i) * aff, i);

  getTool()->setCenter(aff * tool->getCenter());

  applyTransform(tool->getBBox());

}

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

void DragSelectionTool::VectorMoveSelectionTool::leftButtonDown(

    const TPointD &pos, const TMouseEvent &e) {

  m_moveSelection->leftButtonDown(pos, e);

  VectorDeformTool::leftButtonDown(pos, e);

}

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

void DragSelectionTool::VectorMoveSelectionTool::leftButtonDrag(

    const TPointD &pos, const TMouseEvent &e) {

  VectorSelectionTool *tool = dynamic_cast<vectorselectiontool *="">(m_tool);</vectorselectiontool>

  tool->setResetCenter(false);

  if (e.isCtrlPressed() ||

      norm2(pos - getStartPos()) > l_dragThreshold * getTool()->getPixelSize())

    m_moveSelection->leftButtonDrag(pos, e);

  else  // snap to the original position

    m_moveSelection->leftButtonDrag(getStartPos(), e);

}

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

// VectorScaleTool

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

DragSelectionTool::VectorScaleTool::VectorScaleTool(VectorSelectionTool *tool,

                                                    ScaleType type)

    : VectorDeformTool(tool), m_scale(new Scale(this, type)) {}

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

TPointD DragSelectionTool::VectorScaleTool::transform(int index, TPointD newPos,

                                                      bool onFastDragging) {

  SelectionTool *tool = getTool();

  TPointD scaleValue  = tool->m_deformValues.m_scaleValue;

  std::vector<fourpoints> startBboxs = m_scale->getStartBboxs();</fourpoints>

  TPointD center                     = m_scale->getStartCenter();

  FourPoints bbox = m_scale->bboxScaleInCenter(index, startBboxs[0], newPos,

                                               scaleValue, center, true);

  if (bbox == startBboxs[0]) return scaleValue;

  bool scaleInCenter = m_scale->scaleInCenter();

  // Se non ho scalato rispetto al centro calcolo la posizione del nuovo centro

  if (!scaleInCenter)

    tool->setCenter(m_scale->getNewCenter(index, startBboxs[0], scaleValue));

  if (tool->isLevelType() || tool->isSelectedFramesType()) {

    int i;

    for (i = 1; i < (int)tool->getBBoxsCount(); i++) {

      FourPoints oldBbox = startBboxs[i];

      TPointD frameCenter =

          scaleInCenter ? center

                        : oldBbox.getPoint(getSymmetricPointIndex(index));

      TPointD newp =

          m_scale->getScaledPoint(index, oldBbox, scaleValue, frameCenter);

      FourPoints newBbox = m_scale->bboxScaleInCenter(