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

// boost includes

#include <boost bind.hpp=""></boost>

using namespace ToolUtils;

using namespace DragSelectionTool;

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

//    Global variables

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

namespace

{

VectorSelectionTool l_vectorSelectionTool(TTool::Vectors);

TEnv::IntVar l_strokeSelectConstantThickness("SelectionToolConstantThickness", 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, double &maxThickness)</int>

{

	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)

{

	if (!vi)

		return false;

	double t, dist2 = 0;

	double maxDist = 5 * pixelSize;

	double maxDist2 = maxDist * maxDist;

	vi->getNearestStroke(pos, t, index, dist2);

	return (dist2 < maxDist2 * 4);

}

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

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(</int>

		m_strokeIndexes.begin(), m_strokeIndexes.end());

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

	m_computeRegion = false;

}

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

void VectorFreeDeformer::deformImage()

{

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

	QMutexLocker lock(m_vi->getMutex());

	std::set<int>::iterator it1 = m_strokeIndexes.begin();</int>

	std::vector<tstroke *="">::iterator it2 = m_originalStrokes.begin();</tstroke>

	for (it1; it1 != m_strokeIndexes.end(); ++it1, ++it2) {

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

		TStroke *originalStroke = *it2;

		assert(stroke->getControlPointCount() == originalStroke->getControlPointCount());

		int j;

		for (j = 0; j < stroke->getControlPointCount(); 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</tstroke>

												   : m_newStrokes;

	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,</tstroke>

	TPointD center, 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();

}

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

void DragSelectionTool::UndoChangeStrokes::redo() const

{

	transform(m_newStrokes, m_newBBox, m_newCenter, m_newDeformValues);

}

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

int DragSelectionTool::UndoChangeStrokes::getSize() const

{

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

}

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

// UndoChangeOutlineStyle

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

class UndoChangeOutlineStyle : 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, FourPoints bbox) const;</tstroke::outlineoptions>

	void undo() const;

	void redo() const;

	int getSize() const;

};

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

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, FourPoints bbox) const</tstroke::outlineoptions>

{

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

}

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

void UndoChangeOutlineStyle::redo() const

{

	transform(m_newOptions, m_newBBox);

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

}

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

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)

{

	SelectionTool *tool = getTool();

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

	if (!m_vfdScopedBlock.get()) {

		tcg::unique_ptr<vfdscopedblock> &vfdScopedBlock = m_isDragging ? m_vfdScopedBlock : localVfdScopedBlock;</vfdscopedblock>

		vfdScopedBlock.reset(new VFDScopedBlock(tool));

	}

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

	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.get())

		m_undo->setFlip(isFlip());

	freeDeformer->deformImage();

	tool->invalidate();

	if (!m_isDragging)

		tool->notifyImageChanged();

	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.get()) {

		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(), boost::bind(

															::currentOrNotSelected, boost::cref(*tool), _1)),

			   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;

			tcg::unique_ptr<undochangestrokes> undo(new UndoChangeStrokes(</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(), boost::bind(								  // NOTE: current frame is not here - it should be,

												&TTool::notifyImageChanged, m_tool, _1)); //       but it's currently unnecessary, in fact...

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

{

	tcg::unique_ptr<vfdscopedblock> vfdScopedBlock(m_vfdScopedBlock.release());</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();

}

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

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

{

	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)

{

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

	applyTransform(tool->getBBox());

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

}

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

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)

{

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

		m_moveSelection->leftButtonDrag(pos, e);

}

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

// VectorScaleTool

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

DragSelectionTool::VectorScaleTool::VectorScaleTool(VectorSelectionTool *tool, int type)

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

{

}

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

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

{

	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(getSimmetricPointIndex(index));

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

			FourPoints newBbox = m_scale->bboxScaleInCenter(index, oldBbox, newp, scaleValue, frameCenter, false);

			tool->setBBox(newBbox, i);

			if (!scaleInCenter)

				tool->setCenter(m_scale->getNewCenter(index, oldBbox, scaleValue), i);

		}

	}

	tool->setBBox(bbox);

	applyTransform(bbox);

	return scaleValue;

}

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

void DragSelectionTool::VectorScaleTool::leftButtonDown(const TPointD &pos, const TMouseEvent &e)

{

	m_scale->leftButtonDown(pos, e);

	VectorDeformTool::leftButtonDown(pos, e);

}

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

void DragSelectionTool::VectorScaleTool::leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

{

	m_scale->leftButtonDrag(pos, e);

}

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

// VectorChangeThicknessTool

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

DragSelectionTool::VectorChangeThicknessTool::VectorChangeThicknessTool(VectorSelectionTool *tool)

	: DragTool(tool), m_curPos(), m_firstPos(), m_thicknessChange(0)

{