#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 "toonzqt/gutil.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>

#include <qapplication></qapplication>

#include <qdesktopwidget></qdesktopwidget>

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

// 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 final : 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 &) override {

    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 &e) override {

    if (m_lockCenterX && m_lockCenterY) return;

    double factor = 1.0 / Stage::inch;

    // precise control with pressing Alt key

    if (e.isAltPressed()) factor *= 0.1;

    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 &) override {

    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) override {

    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 &) override {

    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 final : 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 &) override {

    if (m_lockPositionX && m_lockPositionY) return;

    start();

    m_firstPos = pos;

  }

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

    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;

    // precise control with pressing Alt key

    if (e.isAltPressed()) factor *= 0.1;

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

              getOldValue(1) + delta.y * factor);

  }

};

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

// DragSplinePositionTool

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

class DragSplinePositionTool final : 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,

                         double pixelSize)

      : DragChannelTool(TStageObject::T_Path, globalKeyframesEnabled)

      , m_spline(spline)

      , m_offset(0.0)

      , m_splineLength(0)

      , m_tolerance(pixelSize * 10.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 &) override {

    m_firstPos = pos;

    start();

    assert(m_spline);

    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 &) override {

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

    snapLengthToControlPoint(len);

    setValue(lengthToParamValue(len));

  }

};

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

// DragRotationTool

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

class DragRotationTool final : 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 &) override {

    if (m_lockRotation) return;

    m_firstPos = pos;

    m_lastPos  = pos;

    m_center   = getCenter();

    start();

  }

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

    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 = asin(cross(a, b) / sqrt(a2 * b2)) * M_180_PI;

    // precise control with pressing Alt key

    if (e.isAltPressed()) dang *= 0.1;

    setValue(getValue(0) + dang);

  }

};

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

// DragIsotropicScaleTool

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

class DragIsotropicScaleTool final : 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 &) override {

    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) override {

    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;

    // precise control with pressing Alt key

    if (e.isAltPressed()) r1 = m_r0 + (r1 - m_r0) * 0.1;

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

  }

};

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

// DragScaleTool

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

class DragScaleTool final : 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 &) override {

    if (m_lockScaleH && m_lockScaleV) return;

    m_firstPos = pos;

    m_center   = getCenter();

    start();

  }

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

    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(std::abs(fx));

    double fy = b.y / a.y;

    if (fabs(fy) > 1) fy = tsign(fy) * sqrt(std::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;

      // precise control with pressing Alt key

      if (e.isAltPressed()) {

        fx = 1.0 + (fx - 1.0) * 0.1;

        fy = 1.0 + (fy - 1.0) * 0.1;

      }

      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 final : 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 &) override {

    if (m_lockShearH && m_lockShearV) return;

    m_firstPos = pos;

    m_center   = getCenter();

    start();

  }

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

    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;

    }

    // precise control with pressing Alt key

    if (e.isAltPressed()) {

      fx *= 0.1;

      fy *= 0.1;

    }

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

  }

};

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

// DragZTool

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

class DragZTool final : public DragChannelTool {

  TPointD 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) override {

    m_lastPos  = e.m_pos;

    m_firstPos = pos;

    m_dz       = 0;

    start();

  }

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

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

    // precise control with pressing Alt key

    if (e.isAltPressed()) dz *= 0.1;

    m_lastPos = e.m_pos;

    if (dz != 0.0) {

      m_dz += dz;

      setValue(getOldValue(0) + m_dz);

    }

  }

};

bool hasVisibleChildColumn(const TStageObject *obj, const TXsheet *xsh) {

  if (!(obj->getId().isColumn())) return false;  // just in case

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

  if (!column) return false;

  if (column->isCamstandVisible()) return true;

  for (const auto child : obj->getChildren()) {

    if (hasVisibleChildColumn(child, xsh)) return true;

  }

  return false;

}

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

}  // namespace

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

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

// EditTool

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

class EditTool final : 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;

  bool m_isAltPressed;

  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;

  void drawMainHandle();

  void onEditAllLeftButtonDown(TPointD &pos, const TMouseEvent &e);

public:

  EditTool();

  ~EditTool();

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

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

  void saveOldValues();

  bool transformEnabled() const;

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

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

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

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

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

  void draw() override;

  void transform(const TAffine &aff);

  void onActivate() override;

  void onDeactivate() override;

  bool onPropertyChanged(std::string propertyName) override;

  void computeBBox();

  int getCursorId() const override;

  TPropertyGroup *getProperties(int targetType) override { return &m_prop; }

  void updateMatrix() override {

    setMatrix(

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

  }

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

  QString updateEnabled(int rowIndex, int columnIndex) override;

};

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

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 X", false)

    , m_lockCenterY("Lock Center Y", false)

    , m_lockPositionX("Lock Position X", false)

    , m_lockPositionY("Lock Position Y", 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("X and Y 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")

    , m_isAltPressed(false) {

  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", "edit_position");

  m_activeAxis.addValue(L"Rotation", "edit_rotation");

  m_activeAxis.addValue(L"Scale", "edit_scale");

  m_activeAxis.addValue(L"Shear", "edit_shear");

  m_activeAxis.addValue(L"Center", "edit_center");

  m_activeAxis.addValue(L"All", "edit_all");

  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_scaleConstraint.setItemUIName(L"None", tr("None"));

  m_scaleConstraint.setItemUIName(L"A/R", tr("A/R"));

  m_scaleConstraint.setItemUIName(L"Mass", tr("Mass"));

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

  m_autoSelect.setItemUIName(L"None", tr("None"));

  m_autoSelect.setItemUIName(L"Column", tr("Column"));

  m_autoSelect.setItemUIName(L"Pegbar", tr("Pegbar"));

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

  m_lockCenterX.setQStringName(tr("Lock Center X"));

  m_lockCenterY.setQStringName(tr("Lock Center Y"));

  m_lockPositionX.setQStringName(tr("Lock Position X"));

  m_lockPositionY.setQStringName(tr("Lock Position Y"));

  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("X and Y Positions"));

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

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

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