#include "tools/tool.h"

#include "tools/cursors.h"

#include "tproperty.h"

#include "toonz/stageobjectutil.h"

#include "tstroke.h"

#include "tgl.h"

#include "tenv.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/toonzscene.h"

#include "toonz/txshcolumn.h"

#include "toonz/stage.h"

#include "toonz/tcamera.h"

#include "tools/toolhandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tframehandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/tfxhandle.h"

#include "toonz/tstageobjectcmd.h"

#include "edittoolgadgets.h"

// For Qt translation support

#include <qcoreapplication></qcoreapplication>

#include <qdebug></qdebug>

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

// Scale Constraints

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

namespace ScaleConstraints

{

enum { None = 0,

	   AspectRatio,

	   Mass };

}

TEnv::IntVar LockCenterX("EditToolLockCenterX", 0);

TEnv::IntVar LockCenterY("EditToolLockCenterY", 0);

TEnv::IntVar LockPositionX("EditToolLockPositionX", 0);

TEnv::IntVar LockPositionY("EditToolLockPositionY", 0);

TEnv::IntVar LockRotation("EditToolLockRotation", 0);

TEnv::IntVar LockShearH("EditToolLockShearH", 0);

TEnv::IntVar LockShearV("EditToolLockShearV", 0);

TEnv::IntVar LockScaleH("EditToolLockScaleH", 0);

TEnv::IntVar LockScaleV("EditToolLockScaleV", 0);

TEnv::IntVar LockGlobalScale("EditToolLockGlobalScale", 0);

TEnv::IntVar ShowEWNSposition("EditToolShowEWNSposition", 1);

TEnv::IntVar ShowZposition("EditToolShowZposition", 1);

TEnv::IntVar ShowSOposition("EditToolShowSOposition", 1);

TEnv::IntVar ShowRotation("EditToolShowRotation", 1);

TEnv::IntVar ShowGlobalScale("EditToolShowGlobalScale", 1);

TEnv::IntVar ShowHVscale("EditToolShowHVscale", 1);

TEnv::IntVar ShowShear("EditToolShowShear", 0);

TEnv::IntVar ShowCenterPosition("EditToolShowCenterPosition", 0);

TEnv::StringVar Active("EditToolActiveAxis", "Position");

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

namespace

{

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

using EditToolGadgets::DragTool;

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

// DragCenterTool

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

class DragCenterTool : public DragTool

{

	TStageObjectId m_objId;

	int m_frame;

	bool m_lockCenterX;

	bool m_lockCenterY;

	TPointD m_firstPos;

	TPointD m_oldCenter;

	TPointD m_center;

	TAffine m_affine;

public:

	DragCenterTool(bool lockCenterX, bool lockCenterY)

		: m_objId(TTool::getApplication()->getCurrentTool()->getTool()->getObjectId()), m_frame(TTool::getApplication()->getCurrentTool()->getTool()->getFrame()), m_lockCenterX(lockCenterX), m_lockCenterY(lockCenterY)

	{

	}

	void leftButtonDown(const TPointD &pos, const TMouseEvent &)

	{

		if (m_lockCenterX && m_lockCenterY)

			return;

		TXsheet *xsh = TTool::getApplication()->getCurrentTool()->getTool()->getXsheet();

		m_center = m_oldCenter = xsh->getCenter(m_objId, m_frame);

		m_firstPos = pos;

		m_affine = xsh->getPlacement(m_objId, m_frame).inv() * xsh->getParentPlacement(m_objId, m_frame);

		m_affine.a13 = m_affine.a23 = 0;

	}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &)

	{

		if (m_lockCenterX && m_lockCenterY)

			return;

		double factor = 1.0 / Stage::inch;

		TPointD delta = pos - m_firstPos;

		if (m_lockCenterX)

			delta = TPointD(0.0, delta.y);

		else if (m_lockCenterY)

			delta = TPointD(delta.x, 0.0);

		m_center = m_oldCenter + (m_affine * delta) * factor;

		TTool::getApplication()->getCurrentTool()->getTool()->getXsheet()->setCenter(m_objId, m_frame, m_center);

	}

	void leftButtonUp(const TPointD &pos, const TMouseEvent &)

	{

		if ((m_lockCenterX && m_lockCenterY) || m_firstPos == pos)

			return;

		UndoStageObjectCenterMove *undo = new UndoStageObjectCenterMove(m_objId, m_frame, m_oldCenter, m_center);

		TTool::Application *app = TTool::getApplication();

		undo->setObjectHandle(app->getCurrentObject());

		undo->setXsheetHandle(app->getCurrentXsheet());

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

	}

};

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

// DragChannelTool

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

class DragChannelTool : public DragTool

{

protected:

	TStageObjectValues m_before, m_after;

	bool m_globalKeyframesEnabled;

	bool m_isStarted;

	TPointD m_firstPos;

public:

	DragChannelTool(TStageObject::Channel a0, bool globalKeyframesEnabled)

		: m_globalKeyframesEnabled(globalKeyframesEnabled), m_isStarted(false), m_firstPos()

	{

		TTool::Application *app = TTool::getApplication();

		m_before.setFrameHandle(app->getCurrentFrame());

		m_before.setObjectHandle(app->getCurrentObject());

		m_before.setXsheetHandle(app->getCurrentXsheet());

		m_before.add(a0);

		if (m_globalKeyframesEnabled) {

			m_before.add(TStageObject::T_Angle);

			m_before.add(TStageObject::T_X);

			m_before.add(TStageObject::T_Y);

			m_before.add(TStageObject::T_Z);

			m_before.add(TStageObject::T_SO);

			m_before.add(TStageObject::T_ScaleX);

			m_before.add(TStageObject::T_ScaleY);

			m_before.add(TStageObject::T_Scale);

			m_before.add(TStageObject::T_Path);

			m_before.add(TStageObject::T_ShearX);

			m_before.add(TStageObject::T_ShearY);

		}

		m_after = m_before;

	}

	DragChannelTool(TStageObject::Channel a0, TStageObject::Channel a1, bool globalKeyframesEnabled)

		: m_globalKeyframesEnabled(globalKeyframesEnabled), m_isStarted(false), m_firstPos()

	{

		TTool::Application *app = TTool::getApplication();

		m_before.setFrameHandle(app->getCurrentFrame());

		m_before.setObjectHandle(app->getCurrentObject());

		m_before.setXsheetHandle(app->getCurrentXsheet());

		m_before.add(a0);

		m_before.add(a1);

		if (m_globalKeyframesEnabled) {

			m_before.add(TStageObject::T_Angle);

			m_before.add(TStageObject::T_X);

			m_before.add(TStageObject::T_Y);

			m_before.add(TStageObject::T_Z);

			m_before.add(TStageObject::T_SO);

			m_before.add(TStageObject::T_ScaleX);

			m_before.add(TStageObject::T_ScaleY);

			m_before.add(TStageObject::T_Scale);

			m_before.add(TStageObject::T_Path);

			m_before.add(TStageObject::T_ShearX);

			m_before.add(TStageObject::T_ShearY);

		}

		m_after = m_before;

	}

	void enableGlobalKeyframes(bool enabled) { m_globalKeyframesEnabled = enabled; }

	void start()

	{

		m_isStarted = true;

		m_before.updateValues();

		m_after = m_before;

	}

	TPointD getCenter()

	{

		TTool *tool = TTool::getApplication()->getCurrentTool()->getTool();

		TStageObjectId objId = tool->getObjectId();

		int frame = tool->getFrame();

		TXsheet *xsh = tool->getXsheet();

		return xsh->getParentPlacement(objId, frame).inv() * xsh->getPlacement(objId, frame) * (Stage::inch * xsh->getCenter(objId, frame));

	}

	double getOldValue(int index) const

	{

		return m_before.getValue(index);

	}

	double getValue(int index) const

	{

		return m_after.getValue(index);

	}

	void setValue(double v)

	{

		m_after.setValue(v);

		m_after.applyValues();

	}

	void setValues(double v0, double v1)

	{

		m_after.setValues(v0, v1);

		m_after.applyValues();

	}

	void leftButtonUp(const TPointD &pos, const TMouseEvent &)

	{

		if (!m_isStarted || m_firstPos == pos)

			return;

		else

			m_isStarted = false;

		TTool::Application *app = TTool::getApplication();

		UndoStageObjectMove *undo = new UndoStageObjectMove(m_before, m_after);

		undo->setObjectHandle(app->getCurrentObject());

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

		app->getCurrentScene()->setDirtyFlag(true);

	}

};

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

// DragPositionTool

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

class DragPositionTool : public DragChannelTool

{

	bool m_lockPositionX;

	bool m_lockPositionY;

public:

	DragPositionTool(bool lockPositionX, bool lockPositionY, bool globalKeyframesEnabled)

		: DragChannelTool(TStageObject::T_X, TStageObject::T_Y, globalKeyframesEnabled), m_lockPositionX(lockPositionX), m_lockPositionY(lockPositionY)

	{

	}

	void leftButtonDown(const TPointD &pos, const TMouseEvent &)

	{

		if (m_lockPositionX && m_lockPositionY)

			return;

		start();

		m_firstPos = pos;

	}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

	{

		if (m_lockPositionX && m_lockPositionY)

			return;

		TPointD delta = pos - m_firstPos;

		if (m_lockPositionX)

			delta = TPointD(0, delta.y);

		else if (m_lockPositionY)

			delta = TPointD(delta.x, 0);

		if (e.isShiftPressed()) {

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

				delta.y = 0;

			else

				delta.x = 0;

		}

		double factor = 1.0 / Stage::inch;

		setValues(getOldValue(0) + delta.x * factor, getOldValue(1) + delta.y * factor);

	}

};

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

// DragSplinePositionTool

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

class DragSplinePositionTool : public DragChannelTool

{

	const TStroke *m_spline;

	std::vector<double> m_lengthAtCPs;</double>

	double m_offset;

	double m_splineLength;

	double m_tolerance;

public:

	DragSplinePositionTool(const TStroke *spline, bool globalKeyframesEnabled)

		: DragChannelTool(TStageObject::T_Path, globalKeyframesEnabled), m_spline(spline), m_offset(0.0), m_splineLength(0), m_tolerance(0)

	{

	}

	double getLengthAtPos(const TPointD &pos) const

	{

		assert(m_spline);

		double t = m_spline->getW(pos);

		return m_spline->getLength(t);

		/*

    double length = m_spline->getLength();

    if(length>0) return 100 * m_spline->getLength(t) / length;

    else return 0.0;

    */

	}

	double paramValueToLength(double s) const

	{

		return s * m_splineLength * 0.01;

	}

	double lengthToParamValue(double len) const

	{

		if (m_splineLength > 0)

			return 100 * len / m_splineLength;

		else

			return 0.0;

	}

	void leftButtonDown(const TPointD &pos, const TMouseEvent &)

	{

		m_firstPos = pos;

		start();

		assert(m_spline);

		m_tolerance = sqrt(tglGetPixelSize2()) * 10;

		m_splineLength = m_spline->getLength();

		m_lengthAtCPs.clear();

		int n = m_spline->getControlPointCount();

		for (int i = 0; i < n; i += 4)

			m_lengthAtCPs.push_back(m_spline->getLengthAtControlPoint(i));

		m_offset = paramValueToLength(getOldValue(0)) - getLengthAtPos(pos);

	}

	bool snapLengthToControlPoint(double &len) const

	{

		int n = (int)m_lengthAtCPs.size();

		if (n <= 0)

			return false;

		double cpLen = len;

		int k = 0;

		while (k < n && m_lengthAtCPs[k] <= len)

			k++;

		if (k >= n) {

			// len is >= all CP lengths. The closest is the last

			cpLen = m_lengthAtCPs.back();

		} else if (k == 0) {

			// len is < all CP lengths. the closest is the first

			cpLen = m_lengthAtCPs.front();

		} else {

			// m_lengthAtCPs[k-1]<=len && len < m_lengthAtCPs[k]

			double cpLen0 = m_lengthAtCPs[k - 1];

			double cpLen1 = m_lengthAtCPs[k];

			assert(cpLen0 <= len && len < cpLen1);

			cpLen = (len - cpLen0 < cpLen1 - len) ? cpLen0 : cpLen1;

		}

		if (fabs(cpLen - len) < m_tolerance) {

			len = cpLen;

			return true;

		} else

			return false;

	}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &)

	{

		double len = tcrop(getLengthAtPos(pos) + m_offset, 0.0, m_splineLength);

		snapLengthToControlPoint(len);

		setValue(lengthToParamValue(len));

	}

};

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

// DragRotationTool

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

class DragRotationTool : public DragChannelTool

{

	TPointD m_lastPos;

	TPointD m_center;

	bool m_lockRotation;

public:

	DragRotationTool(bool lockRotation, bool globalKeyframesEnabled)

		: DragChannelTool(TStageObject::T_Angle, globalKeyframesEnabled), m_lockRotation(lockRotation)

	{

	}

	void leftButtonDown(const TPointD &pos, const TMouseEvent &)

	{

		if (m_lockRotation)

			return;

		m_firstPos = pos;

		m_lastPos = pos;

		m_center = getCenter();

		start();

	}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &)

	{

		if (m_lockRotation)

			return;

		TPointD a = m_lastPos - m_center;

		TPointD b = pos - m_center;

		m_lastPos = pos;

		/*

    if(cameraFlag)

      {

       // m_viewer->updateViewMatrix();

       b = m_viewer->mouseToTool(gb) - m_curCenter;

       a = m_viewer->mouseToTool(gc) - m_curCenter;

      }

    */

		double a2 = norm2(a), b2 = norm2(b);

		const double eps = 1e-8;

		if (a2 < eps || b2 < eps)

			return;

		double dang = 180 * asin(cross(a, b) / sqrt(a2 * b2)) / TConsts::pi;

		setValue(getValue(0) + dang);

	}

};

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

// DragIsotropicScaleTool

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

class DragIsotropicScaleTool : public DragChannelTool

{

	TPointD m_center;

	double m_r0;

	bool m_lockGlobalScale;

public:

	DragIsotropicScaleTool(bool lockGlobalScale, bool globalKeyframesEnabled)

		: DragChannelTool(TStageObject::T_Scale, globalKeyframesEnabled), m_lockGlobalScale(lockGlobalScale), m_r0(0)

	{

	}

	void leftButtonDown(const TPointD &pos, const TMouseEvent &)

	{

		if (m_lockGlobalScale)

			return;

		m_firstPos = pos;

		m_center = getCenter();

		start();

		m_r0 = norm(m_firstPos - m_center);

	}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

	{

		if (m_lockGlobalScale)

			return;

		if (m_r0 < 0.001)

			return;

		// TPointD a = m_firstPos - m_center;

		double r1 = norm(pos - m_center);

		if (r1 < 0.0001)

			return;

		setValue(getOldValue(0) * r1 / m_r0);

	}

};

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

// DragScaleTool

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

class DragScaleTool : public DragChannelTool

{

	TPointD m_center;

	int m_constraint;

	bool m_lockScaleH;

	bool m_lockScaleV;

public:

	DragScaleTool(int constraint, bool lockScaleH, bool lockScaleV, bool globalKeyframesEnabled)

		: DragChannelTool(TStageObject::T_ScaleX, TStageObject::T_ScaleY, globalKeyframesEnabled), m_constraint(constraint), m_lockScaleH(lockScaleH), m_lockScaleV(lockScaleV)

	{

	}

	void leftButtonDown(const TPointD &pos, const TMouseEvent &)

	{

		if (m_lockScaleH && m_lockScaleV)

			return;

		m_firstPos = pos;

		m_center = getCenter();

		start();

	}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

	{

		if (m_lockScaleH && m_lockScaleV)

			return;

		TPointD center = m_center + TPointD(40, 40);

		TPointD a = m_firstPos - center;

		TPointD b = pos - center;

		const double eps = 1e-8;

		if (norm2(a) < eps || norm2(b) < eps)

			return;

		double fx = b.x / a.x;

		if (fabs(fx) > 1)

			fx = tsign(fx) * sqrt(abs(fx));

		double fy = b.y / a.y;

		if (fabs(fy) > 1)

			fy = tsign(fy) * sqrt(abs(fy));

		int constraint = m_constraint;

		if (constraint == ScaleConstraints::None && e.isShiftPressed())

			constraint = ScaleConstraints::AspectRatio;

		if (constraint == ScaleConstraints::AspectRatio) {

			TPointD c = pos - m_firstPos;

			if (fabs(c.x) > fabs(c.y))

				fy = fx;

			else

				fx = fy;

		} else if (constraint == ScaleConstraints::Mass) {

			double bxay = b.x * a.y;

			double byax = b.y * a.x;

			if (fabs(bxay) < eps || fabs(byax) < eps)

				return;

			fx = bxay / byax;

			fy = byax / bxay;

		}

		if (fabs(fx) > eps && fabs(fy) > eps) {

			double oldv0 = getOldValue(0);

			double oldv1 = getOldValue(1);

			if (fabs(oldv0) < 0.001)

				oldv0 = 0.001;

			if (fabs(oldv1) < 0.001)

				oldv1 = 0.001;

			double valueX = oldv0 * fx;

			double valueY = oldv1 * fy;

			if (m_lockScaleH)

				valueX = oldv0;

			else if (m_lockScaleV)

				valueY = oldv1;

			setValues(valueX, valueY);

		}

	}

};

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

// DragShearTool

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

class DragShearTool : public DragChannelTool

{

	TPointD m_center;

	bool m_lockShearH;

	bool m_lockShearV;

public:

	DragShearTool(bool lockShearH, bool lockShearV, bool globalKeyframesEnabled)

		: DragChannelTool(TStageObject::T_ShearX, TStageObject::T_ShearY, globalKeyframesEnabled), m_lockShearH(lockShearH), m_lockShearV(lockShearV)

	{

	}

	void leftButtonDown(const TPointD &pos, const TMouseEvent &)

	{

		if (m_lockShearH && m_lockShearV)

			return;

		m_firstPos = pos;

		m_center = getCenter();

		start();

	}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

	{

		if (m_lockShearH && m_lockShearV)

			return;

		TPointD a = m_firstPos - m_center;

		TPointD b = pos - m_center;

		double fx = a.x - b.x;

		double fy = b.y - a.y;

		if (m_lockShearH)

			fx = 0;

		else if (m_lockShearV)

			fy = 0;

		if (e.isShiftPressed()) {

			if (fabs(fx) > fabs(fy))

				fy = 0;

			else

				fx = 0;

		}

		setValues(getOldValue(0) + 0.01 * fx, getOldValue(1) + 0.01 * fy);

	}

};

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

// DragZTool

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

class DragZTool : public DragChannelTool

{

	TPoint m_lastPos;

	TTool::Viewer *m_viewer;

	double m_dz;

public:

	DragZTool(TTool::Viewer *viewer, bool globalKeyframesEnabled)

		: DragChannelTool(TStageObject::T_Z, globalKeyframesEnabled), m_viewer(viewer) {}

	void leftButtonDown(const TPointD &pos, const TMouseEvent &e)

	{

		m_lastPos = e.m_pos;

		m_firstPos = pos;

		m_dz = 0;

		start();

	}

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

	{

		double dz = m_viewer->projectToZ(e.m_pos - m_lastPos);

		m_lastPos = e.m_pos;

		if (dz != 0.0) {

			m_dz += dz;

			setValue(getOldValue(0) + m_dz);

		}

	}

};

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

} // namespace

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

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

// EditTool

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

class EditTool : public TTool

{

	Q_DECLARE_TR_FUNCTIONS(EditTool)

	DragTool *m_dragTool;

	bool m_firstTime;

	enum {

		None = -1,

		Translation = 1,

		Rotation,

		Scale,

		ScaleX,

		ScaleY,

		ScaleXY,

		Center,

		ZTranslation,

		Shear,

	};

	//DragInfo m_dragInfo;

	TPointD m_lastPos;

	TPointD m_curPos;

	TPointD m_firstPos;

	TPointD m_curCenter;

	bool m_active;

	bool m_keyFrameAdded;

	int m_what;

	int m_highlightedDevice;

	double m_oldValues[2];

	double m_currentScaleFactor;

	FxGadgetController *m_fxGadgetController;

	TEnumProperty m_scaleConstraint;

	TEnumProperty m_autoSelect;

	TBoolProperty m_globalKeyframes;

	TBoolProperty m_lockCenterX;

	TBoolProperty m_lockCenterY;

	TBoolProperty m_lockPositionX;

	TBoolProperty m_lockPositionY;

	TBoolProperty m_lockRotation;

	TBoolProperty m_lockShearH;

	TBoolProperty m_lockShearV;

	TBoolProperty m_lockScaleH;

	TBoolProperty m_lockScaleV;

	TBoolProperty m_lockGlobalScale;

	TBoolProperty m_showEWNSposition;

	TBoolProperty m_showZposition;

	TBoolProperty m_showSOposition;

	TBoolProperty m_showRotation;

	TBoolProperty m_showGlobalScale;

	TBoolProperty m_showHVscale;

	TBoolProperty m_showShear;

	TBoolProperty m_showCenterPosition;

	TEnumProperty m_activeAxis;

	TPropertyGroup m_prop;

public:

	EditTool();

	~EditTool();

	ToolType getToolType() const { return TTool::ColumnTool; }

	bool doesApply() const; // ritorna vero se posso deformare l'oggetto corrente

	void saveOldValues();

	const TStroke *getSpline() const;

	void rotate();

	void move();

	void moveCenter();

	void scale();

	void isoScale();

	void squeeze();

	void shear(const TPointD &pos, bool single);

	void updateTranslation();

	void leftButtonDown(const TPointD &pos, const TMouseEvent &);

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &);

	void leftButtonUp(const TPointD &pos, const TMouseEvent &);

	void mouseMove(const TPointD &, const TMouseEvent &e);

	void draw();

	void transform(const TAffine &aff);

	void onActivate();

	void onDeactivate();

	bool onPropertyChanged(std::string propertyName);

	void computeBBox();

	int getCursorId() const;

	TPropertyGroup *getProperties(int targetType)

	{

		return &m_prop;

	}

	void updateMatrix()

	{

		setMatrix(getCurrentObjectParentMatrix2()); // getCurrentObjectParentMatrix());

	}

	void drawText(const TPointD &p, double unit, std::string text);

};

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

EditTool::EditTool()

	: TTool("T_Edit"), m_active(false), m_what(Translation), m_highlightedDevice(None), m_currentScaleFactor(1), m_fxGadgetController(0), m_keyFrameAdded(false), m_scaleConstraint("Scale Constraint:") // W_ToolOptions_ScaleConstraint

	  ,

	  m_autoSelect("Auto Select Column") // W_ToolOptions_AutoSelect

	  ,

	  m_globalKeyframes("Global Key", false) // W_ToolsOptions_GlobalKeyframes

	  ,

	  m_lockCenterX("Lock Center E/W", false), m_lockCenterY("Lock Center N/S", false), m_lockPositionX("Lock Position E/W", false), m_lockPositionY("Lock Position N/S", false), m_lockRotation("Lock Rotation", false), m_lockShearH("Lock Shear H", false), m_lockShearV("Lock Shear V", false), m_lockScaleH("Lock Scale H", false), m_lockScaleV("Lock Scale V", false), m_lockGlobalScale("Lock Global Scale", false), m_showEWNSposition("E/W and N/S Positions", true), m_showZposition("Z Position", true), m_showSOposition("SO", true), m_showRotation("Rotation", true), m_showGlobalScale("Global Scale", true), m_showHVscale("Horizontal and Vertical Scale", true), m_showShear("Shear", true), m_showCenterPosition("Center Position", true), m_dragTool(0), m_firstTime(true), m_activeAxis("Active Axis")

{

	bind(TTool::AllTargets);

	m_prop.bind(m_scaleConstraint);

	m_prop.bind(m_autoSelect);

	m_prop.bind(m_globalKeyframes);

	m_prop.bind(m_lockCenterX);

	m_prop.bind(m_lockCenterY);

	m_prop.bind(m_lockPositionX);

	m_prop.bind(m_lockPositionY);

	m_prop.bind(m_lockRotation);

	m_prop.bind(m_lockShearH);

	m_prop.bind(m_lockShearV);

	m_prop.bind(m_lockScaleH);

	m_prop.bind(m_lockScaleV);

	m_prop.bind(m_lockGlobalScale);

	m_prop.bind(m_showEWNSposition);

	m_prop.bind(m_showZposition);

	m_prop.bind(m_showSOposition);

	m_prop.bind(m_showRotation);

	m_prop.bind(m_showGlobalScale);

	m_prop.bind(m_showHVscale);

	m_prop.bind(m_showShear);

	m_prop.bind(m_showCenterPosition);

	m_scaleConstraint.addValue(L"None");

	m_scaleConstraint.addValue(L"A/R");

	m_scaleConstraint.addValue(L"Mass");

	m_scaleConstraint.setValue(L"None");

	m_autoSelect.addValue(L"None");

	m_autoSelect.addValue(L"Column");

	m_autoSelect.addValue(L"Pegbar");

	m_autoSelect.setValue(L"None");

	m_globalKeyframes.setId("GlobalKey");

	m_autoSelect.setId("AutoSelect");

	m_prop.bind(m_activeAxis);

	m_activeAxis.addValue(L"Position");

	m_activeAxis.addValue(L"Rotation");

	m_activeAxis.addValue(L"Scale");

	m_activeAxis.addValue(L"Shear");

	m_activeAxis.addValue(L"Center");

	m_activeAxis.setValue(L"Position");

	m_activeAxis.setId("EditToolActiveAxis");

}

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

EditTool::~EditTool()

{

	delete m_dragTool;

	delete m_fxGadgetController;

}

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

void EditTool::updateTranslation()

{

	m_scaleConstraint.setQStringName(tr("Scale Constraint:"));

	m_autoSelect.setQStringName(tr("Auto Select Column"));

	m_globalKeyframes.setQStringName(tr("Global Key"));

	m_lockCenterX.setQStringName(tr("Lock Center E/W"));

	m_lockCenterY.setQStringName(tr("Lock Center N/S"));

	m_lockPositionX.setQStringName(tr("Lock Position E/W"));

	m_lockPositionY.setQStringName(tr("Lock Position N/S"));

	m_lockRotation.setQStringName(tr("Lock Rotation"));

	m_lockShearH.setQStringName(tr("Lock Shear H"));

	m_lockShearV.setQStringName(tr("Lock Shear V"));

	m_lockScaleH.setQStringName(tr("Lock Scale H"));

	m_lockScaleV.setQStringName(tr("Lock Scale V"));

	m_lockGlobalScale.setQStringName(tr("Lock Global Scale"));

	m_showEWNSposition.setQStringName(tr("E/W and N/S Positions"));

	m_showZposition.setQStringName(tr("Z Position"));

	m_showSOposition.setQStringName(tr("SO"));

	m_showRotation.setQStringName(tr("Rotation"));

	m_showGlobalScale.setQStringName(tr("Global Scale"));

	m_showHVscale.setQStringName(tr("Horizontal and Vertical Scale"));

	m_showShear.setQStringName(tr("Shear"));

	m_showCenterPosition.setQStringName(tr("Center Position"));

	m_activeAxis.setQStringName(tr("Active Axis"));

}

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

bool EditTool::doesApply() const

{

	TXsheet *xsh = TTool::getApplication()->getCurrentXsheet()->getXsheet();

	assert(xsh);

	TStageObjectId objId = TTool::getApplication()->getCurrentObject()->getObjectId();

	if (objId.isColumn()) {

		TXshColumn *column = xsh->getColumn(objId.getIndex());

		if (column && column->getSoundColumn())

			return false;

	}

	return true;

}

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

const TStroke *EditTool::getSpline() const