#include "edittoolgadgets.h"

#include "tgl.h"

#include "toonz/tfxhandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tframehandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/stage.h"

#include "tools/tool.h"

#include "tfx.h"

#include "tparamcontainer.h"

#include "toonz/tcolumnfx.h"

#include "tdoubleparam.h"

#include "tparamset.h"

#include "tundo.h"

#include "tparamuiconcept.h"

#include "historytypes.h"

#include "toonzqt/gutil.h"

#include "toonz/tscenehandle.h"

#include "toonz/toonzscene.h"

#include "toonz/tcamera.h"

#include <QApplication>

#include <QDesktopWidget>

#include <QVector2D>

using namespace EditToolGadgets;

GLdouble FxGadget::m_selectedColor[3] = {0.2, 0.8, 0.1};

namespace {

TPointD hadamard(const TPointD &v1, const TPointD &v2) {

  return TPointD(v1.x * v2.x, v1.y * v2.y);

}

#define SPIN_NUMVERTS 72

void drawSpinField(const TRectD geom, const TPointD center,

                   const double lineInterval, const double e_aspect_ratio,

                   const double e_angle) {

  static GLdouble vertices[SPIN_NUMVERTS * 2];

  static bool isInitialized = false;

  if (!isInitialized) {

    isInitialized = true;

    for (int r = 0; r < SPIN_NUMVERTS; r++) {

      double theta        = 2.0 * M_PI * (double)r / (double)SPIN_NUMVERTS;

      vertices[r * 2]     = std::cos(theta);

      vertices[r * 2 + 1] = std::sin(theta);

    }

  }

  // obtain the nearest and the furthest pos inside the geom

  TPointD nearestPos;

  nearestPos.x   = (center.x <= geom.x0)   ? geom.x0

                   : (center.x >= geom.x1) ? geom.x1

                                           : center.x;

  nearestPos.y   = (center.y <= geom.y0)   ? geom.y0

                   : (center.y >= geom.y1) ? geom.y1

                                           : center.y;

  double minDist = norm(nearestPos - center);

  TPointD farthestPos;

  farthestPos.x   = (center.x <= geom.x0)                            ? geom.x1

                    : (center.x >= geom.x1)                          ? geom.x0

                    : ((center.x - geom.x0) >= (geom.x1 - center.x)) ? geom.x0

                                                                     : geom.x1;

  farthestPos.y   = (center.y <= geom.y0)                            ? geom.y1

                    : (center.y >= geom.y1)                          ? geom.y0

                    : ((center.y - geom.y0) >= (geom.y1 - center.y)) ? geom.y0

                                                                     : geom.y1;

  double maxDist  = norm(farthestPos - center);

  double scale[2] = {1.0, 1.0};

  // adjust size for ellipse

  if (e_aspect_ratio != 1.0) {

    scale[0] = 2.0 * e_aspect_ratio / (e_aspect_ratio + 1);

    scale[1] = scale[0] / e_aspect_ratio;

    minDist *= std::min(scale[0], scale[1]);

    maxDist *= std::max(scale[0], scale[1]);

  }

  // obtain id range

  int minId = (int)std::ceil(minDist / lineInterval);

  int maxId = (int)std::floor(maxDist / lineInterval);

  glColor3dv(FxGadget::m_selectedColor);

  glEnableClientState(GL_VERTEX_ARRAY);

  glLineStipple(1, 0x00FF);

  glEnable(GL_LINE_STIPPLE);

  glVertexPointer(2, GL_DOUBLE, 0, vertices);

  glPushMatrix();

  glTranslated(center.x, center.y, 0.0);

  glRotated(e_angle, 0., 0., 1.);

  glScaled(scale[0] * lineInterval, scale[1] * lineInterval, 1.);

  for (int id = minId; id <= maxId; id++) {

    if (id == 0) continue;

    if (id % 2 == 0)

      glColor3dv(FxGadget::m_selectedColor);

    else

      glColor3d(0, 0, 1);

    glPushMatrix();

    glScaled((double)id, (double)id, 1.);

    // draw using vertex array

    glDrawArrays(GL_LINE_LOOP, 0, SPIN_NUMVERTS);

    glPopMatrix();

  }

  glDisable(GL_LINE_STIPPLE);

  glDisableClientState(GL_VERTEX_ARRAY);

  glPopMatrix();

}

#define RADIAL_FIELD_NUMSEGMENTS 5

#define RADIAL_COMPASS_NUMSEGMENTS 20

void drawRadialField(const TRectD geom, const TPointD center,

                     const double lineInterval, const double e_aspect_ratio,

                     const double e_angle, const double twist,

                     const double pivot) {

  // obtain the nearest and the furthest pos inside the geom

  TPointD nearestPos;

  nearestPos.x   = (center.x <= geom.x0)   ? geom.x0

                   : (center.x >= geom.x1) ? geom.x1

                                           : center.x;

  nearestPos.y   = (center.y <= geom.y0)   ? geom.y0

                   : (center.y >= geom.y1) ? geom.y1

                                           : center.y;

  double minDist = norm(nearestPos - center);

  TPointD farthestPos;

  farthestPos.x   = (center.x <= geom.x0)                            ? geom.x1

                    : (center.x >= geom.x1)                          ? geom.x0

                    : ((center.x - geom.x0) >= (geom.x1 - center.x)) ? geom.x0

                                                                     : geom.x1;

  farthestPos.y   = (center.y <= geom.y0)                            ? geom.y1

                    : (center.y >= geom.y1)                          ? geom.y0

                    : ((center.y - geom.y0) >= (geom.y1 - center.y)) ? geom.y0

                                                                     : geom.y1;

  double maxDist  = norm(farthestPos - center);

  double scale[2] = {1.0, 1.0};

  // adjust size for ellipse

  if (e_aspect_ratio != 1.0) {

    scale[0] = 2.0 * e_aspect_ratio / (e_aspect_ratio + 1);

    scale[1] = scale[0] / e_aspect_ratio;

    minDist *= std::min(scale[0], scale[1]);

    maxDist *= std::max(scale[0], scale[1]);

  }

  // obtain id range

  int minId =

      (minDist == 0.)

          ? 0

          : (int)std::floor(std::log2(M_PI * minDist / lineInterval)) + 1;

  int maxId = (int)std::ceil(std::log2(M_PI * maxDist / lineInterval)) + 1;

  struct LineInfo {

    double anglePos;  // original direction of the line

    int birthId;      // generation where the line started to be drawn

  };

  // register lines information

  QList<LineInfo> infoList;

  // initial lines at minId

  int initLineAmount = std::pow(2, minId);

  for (int li = 0; li < initLineAmount; li++)

    infoList.append({360.0 * (double)li / (double)initLineAmount, minId});

  for (int id = minId + 1; id <= maxId; id++) {

    // insert between the existing lines

    QList<LineInfo>::iterator itr = infoList.end();

    while (itr != infoList.begin()) {

      double ap;

      if (itr == infoList.end())

        ap = (360.0 + (*(itr - 1)).anglePos) * 0.5;

      else

        ap = ((*itr).anglePos + (*(itr - 1)).anglePos) * 0.5;

      itr = infoList.insert(itr, {ap, id});

      itr--;

    }

  }

  int unitDist =

      std::pow(2, (maxId - 1)) - ((minId == 0) ? 0 : std::pow(2, (minId - 1)));

  GLdouble *vertices =

      new GLdouble[(unitDist * RADIAL_FIELD_NUMSEGMENTS + 1) * 2];

  double radiStep = (lineInterval / M_PI) / (double)RADIAL_FIELD_NUMSEGMENTS;

  double tmpRad =

      (minId == 0) ? 0. : (std::pow(2, (minId - 1)) * lineInterval / M_PI);

  for (int v = 0; v < unitDist * RADIAL_FIELD_NUMSEGMENTS + 1; v++) {

    double tw           = twist * tmpRad / pivot;

    vertices[v * 2]     = tmpRad * std::cos(tw);

    vertices[v * 2 + 1] = tmpRad * std::sin(tw);

    tmpRad += radiStep;

  }

  glColor3d(0, 0, 1);

  glEnableClientState(GL_VERTEX_ARRAY);

  glLineStipple(1, 0x00FF);

  glEnable(GL_LINE_STIPPLE);

  glVertexPointer(2, GL_DOUBLE, 0, vertices);

  glPushMatrix();

  glTranslated(center.x, center.y, 0.0);

  glRotated(e_angle, 0., 0., 1.);

  glScaled(scale[0], scale[1], 1.);

  int vertexIdOffset =

      (minId == 0) ? 0 : std::pow(2, (minId - 1)) * RADIAL_FIELD_NUMSEGMENTS;

  for (auto line : infoList) {

    glPushMatrix();

    glRotated(line.anglePos, 0., 0., 1.);

    int startId = (line.birthId == 0) ? 0

                                      : std::pow(2, (line.birthId - 1)) *

                                                RADIAL_FIELD_NUMSEGMENTS -

                                            vertexIdOffset;

    // draw using vertex array

    glDrawArrays(GL_LINE_STRIP, startId,

                 unitDist * RADIAL_FIELD_NUMSEGMENTS - startId);

    glPopMatrix();

  }

  glDisable(GL_LINE_STIPPLE);

  glDisableClientState(GL_VERTEX_ARRAY);

  glPopMatrix();

  delete[] vertices;

}

}  // namespace

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

//    FxGadgetUndo  definition

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

class FxGadgetUndo final : public TUndo {

  struct ParamData {

    TDoubleParamP m_param;

    double m_oldValue, m_newValue;

    bool m_wasKeyframe;

  };

private:

  std::vector<ParamData> m_params;

  int m_frame;

public:

  FxGadgetUndo(const std::vector<TDoubleParamP> &params, int frame)

      : m_frame(frame) {

    m_params.resize(params.size());

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

      m_params[i].m_param       = params[i];

      m_params[i].m_oldValue    = params[i]->getValue(frame);

      m_params[i].m_newValue    = m_params[i].m_oldValue;

      m_params[i].m_wasKeyframe = m_params[i].m_param->isKeyframe(frame);

    }

  }

  void onAdd() override {

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

      m_params[i].m_newValue = m_params[i].m_param->getValue(m_frame);

    }

  }

  void undo() const override {

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

      if (!m_params[i].m_wasKeyframe)

        m_params[i].m_param->deleteKeyframe(m_frame);

      else

        m_params[i].m_param->setValue(m_frame, m_params[i].m_oldValue);

    }

  }

  void redo() const override {

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

      m_params[i].m_param->setValue(m_frame, m_params[i].m_newValue);

    }

  }

  int getSize() const override {

    return sizeof(*this) + m_params.size() * sizeof(ParamData);

  }

  QString getHistoryString() override {

    QString str = QObject::tr("Modify Fx Gadget  ");

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

      str += QString::fromStdString(m_params[i].m_param->getName());

      if (i != (int)m_params.size() - 1) str += QString::fromStdString(", ");

    }

    str += QString("  Frame : %1").arg(QString::number(m_frame + 1));

    return str;

  }

  int getHistoryType() override { return HistoryType::Fx; }

};

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

//    GadgetDragTool  definition

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

class GadgetDragTool final : public DragTool {

  FxGadgetController *m_controller;

  FxGadget *m_gadget;

  TPointD m_firstPos;

public:

  GadgetDragTool(FxGadgetController *controller, FxGadget *gadget)

      : m_controller(controller), m_gadget(gadget) {}

  TAffine getMatrix() const { return m_controller->getMatrix().inv(); }

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

    m_gadget->createUndo();

    m_gadget->leftButtonDown(getMatrix() * pos, e);

    m_firstPos = pos;

  }

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

    // precise control with pressing Alt key

    if (e.isAltPressed()) {

      TPointD precisePos = m_firstPos + (pos - m_firstPos) * 0.1;

      m_gadget->leftButtonDrag(getMatrix() * precisePos, e);

    } else

      m_gadget->leftButtonDrag(getMatrix() * pos, e);

  }

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

    leftButtonUp();

  }

  void leftButtonUp() override {

    m_gadget->leftButtonUp();

    m_gadget->commitUndo();

  }

};

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

//    FxGadget  implementation

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

FxGadget::FxGadget(FxGadgetController *controller, int handleCount)

    : m_id(-1)

    , m_selected(-1)

    , m_controller(controller)

    , m_pixelSize(1)

    , m_undo(0)

    , m_scaleFactor(1)

    , m_handleCount(handleCount) {

  controller->assignId(this);

}

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

FxGadget::~FxGadget() {

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

    m_params[i]->removeObserver(this);

}

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

void FxGadget::addParam(const TDoubleParamP &param) {

  m_params.push_back(param);

  param->addObserver(this);

}

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

double FxGadget::getValue(const TDoubleParamP &param) const {

  return param->getValue(m_controller->getCurrentFrame());

}

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

void FxGadget::setValue(const TDoubleParamP &param, double value) {

  param->setValue(m_controller->getCurrentFrame(), value);

}

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

TPointD FxGadget::getValue(const TPointParamP &param) const {

  return param->getValue(m_controller->getCurrentFrame());

}

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

void FxGadget::setValue(const TPointParamP &param, const TPointD &pos) {

  param->setValue(m_controller->getCurrentFrame(), pos);

}

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

void FxGadget::setPixelSize() {

  setPixelSize(sqrt(tglGetPixelSize2()) * m_controller->getDevPixRatio());

}

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

void FxGadget::drawTooltip(const TPointD &tooltipPos,

                           std::string tooltipPosText) {

  double unit = sqrt(tglGetPixelSize2()) * m_controller->getDevPixRatio();

  glPushMatrix();

  glTranslated(tooltipPos.x, tooltipPos.y, 0.0);

  double sc = unit * 1.6;

  glScaled(sc, sc, 1);

  tglDrawText(TPointD(8, -3), tooltipPosText);

  glPopMatrix();

}

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

void FxGadget::drawDot(const TPointD &pos) {

  double r = getPixelSize() * 3;

  tglDrawRect(pos.x - r, pos.y - r, pos.x + r, pos.y + r);

}

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

void FxGadget::onChange(const TParamChange &) {

  m_controller->invalidateViewer();

}

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

void FxGadget::createUndo() {

  assert(m_undo == 0);

  m_undo = new FxGadgetUndo(m_params, m_controller->getCurrentFrame());

}

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

void FxGadget::commitUndo() {

  assert(m_undo);

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

  m_undo = 0;

}

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

//    Specific Gadget Concepts  definition

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

class PointFxGadget final : public FxGadget {

  TPointD m_pos;

  TDoubleParamP m_xParam, m_yParam;

public:

  PointFxGadget(FxGadgetController *controller, const TPointParamP &param)

      : FxGadget(controller), m_xParam(param->getX()), m_yParam(param->getY()) {

    addParam(m_xParam);

    addParam(m_yParam);

  }

  PointFxGadget(FxGadgetController *controller, const TDoubleParamP &xParam,

                const TDoubleParamP &yParam)

      : FxGadget(controller), m_xParam(xParam), m_yParam(yParam) {

    addParam(m_xParam);

    addParam(m_yParam);

  }

  void draw(bool picking) override;

  TPointD getPoint() const {

    return TPointD(getValue(m_xParam), getValue(m_yParam));

  }

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

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

};

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

void PointFxGadget::draw(bool picking) {

  setPixelSize();

  if (isSelected())

    glColor3dv(m_selectedColor);

  else

    glColor3d(0, 0, 1);

  glPushName(getId());

  TPointD pos(getPoint());

  double unit = getPixelSize();

  glPushMatrix();

  glTranslated(pos.x, pos.y, 0);

  double r = unit * 3;

  double d = unit * 6;

  glBegin(GL_LINES);

  glVertex2d(-d, 0);

  glVertex2d(-r, 0);

  glVertex2d(d, 0);

  glVertex2d(r, 0);

  glVertex2d(0, -d);

  glVertex2d(0, -r);

  glVertex2d(0, d);

  glVertex2d(0, r);

  glEnd();

  tglDrawRect(-r, -r, r, r);

  glPopMatrix();

  glPopName();

  if (isSelected()) {

    drawTooltip(pos + TPointD(7, 3) * unit, getLabel());

  }

}

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

void PointFxGadget::leftButtonDown(const TPointD &pos, const TMouseEvent &) {}

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

void PointFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &) {

  if (m_xParam) setValue(m_xParam, pos.x);

  if (m_yParam) setValue(m_yParam, pos.y);

}

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

class RadiusFxGadget final : public FxGadget {

  TDoubleParamP m_radius;

  TPointParamP m_center;

public:

  RadiusFxGadget(FxGadgetController *controller, const TDoubleParamP &radius,

                 const TPointParamP &center)

      : FxGadget(controller), m_radius(radius), m_center(center) {

    addParam(radius);

  }

  TPointD getCenter() const;

  void draw(bool picking) override;

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

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

};

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

TPointD RadiusFxGadget::getCenter() const {

  return m_center ? getValue(m_center) : TPointD();

}

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

void RadiusFxGadget::draw(bool picking) {

  if (!m_radius) return;

  setPixelSize();

  if (isSelected())

    glColor3dv(m_selectedColor);

  else

    glColor3d(0, 0, 1);

  glPushName(getId());

  double radius  = getValue(m_radius);

  TPointD center = getCenter();

  glLineStipple(1, 0xAAAA);

  glEnable(GL_LINE_STIPPLE);

  tglDrawCircle(center, radius);

  glDisable(GL_LINE_STIPPLE);

  drawDot(center + TPointD(0.707, 0.707) * radius);

  glPopName();

  if (isSelected()) {

    drawTooltip(center + TPointD(0.707, 0.707) * radius, getLabel());

  }

}

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

void RadiusFxGadget::leftButtonDown(const TPointD &pos, const TMouseEvent &) {}

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

void RadiusFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &) {

  setValue(m_radius, norm(pos - getCenter()));

}

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

class DistanceFxGadget final : public FxGadget {

  TDoubleParamP m_distance, m_angle;

  int m_grabPos;

public:

  DistanceFxGadget(FxGadgetController *controller,

                   const TDoubleParamP &distance, const TDoubleParamP &angle)

      : FxGadget(controller)

      , m_distance(distance)

      , m_angle(angle)

      , m_grabPos(1) {

    addParam(distance);

    if (angle) addParam(angle);

  }

  TPointD getDirection() const {

    if (!m_angle) return TPointD(1.0, 0.0);

    double angle = getValue(m_angle);

    return TPointD(cos(angle), sin(angle));

  }

  void draw(bool picking) override;

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

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

};

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

void DistanceFxGadget::draw(bool picking) {

  if (!m_distance) return;

  setPixelSize();

  glColor3d(0, 0, 1);

  double d = getValue(m_distance) * getScaleFactor();

  TPointD dir(getDirection());

  TPointD u = rotate90(dir) * (getPixelSize() * 10);

  tglDrawSegment(-u, u);

  glPushName(getId());

  TPointD b, c;

  b = dir * (d * 0.5);

  c = b - dir * d;

  tglDrawSegment(b - u, b + u);

  tglDrawCircle(b, getPixelSize() * 5);

  tglDrawSegment(c - u, c + u);

  tglDrawCircle(c, getPixelSize() * 5);

  glPopName();

  glLineStipple(1, 0xAAAA);

  glEnable(GL_LINE_STIPPLE);

  tglDrawSegment(b, c);

  glDisable(GL_LINE_STIPPLE);

  if (isSelected()) {

    drawTooltip(b + TPointD(5, 5) * getPixelSize(), getLabel());

  }

}

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

void DistanceFxGadget::leftButtonDown(const TPointD &pos, const TMouseEvent &) {

  m_grabPos = (pos.x > 0.0) ? 1 : -1;

}

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

void DistanceFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &) {

  double v = (pos * getDirection()) / getScaleFactor();

  v        = v * 2 * m_grabPos;

  setValue(m_distance, v);

}

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

class AngleFxGadget final : public FxGadget {

  TDoubleParamP m_param;

  TPointD m_pos;

public:

  AngleFxGadget(FxGadgetController *controller, const TDoubleParamP &param,

                const TPointD &pos);

  void draw(bool picking) override;

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

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

};

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

AngleFxGadget::AngleFxGadget(FxGadgetController *controller,

                             const TDoubleParamP &param, const TPointD &pos)

    : FxGadget(controller), m_param(param), m_pos(pos) {

  addParam(param);

}

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

void AngleFxGadget::draw(bool picking) {

  if (isSelected())

    glColor3dv(m_selectedColor);

  else

    glColor3d(0, 0, 1);

  glPushName(getId());

  double pixelSize = sqrt(tglGetPixelSize2()) * m_controller->getDevPixRatio();

  double r         = pixelSize * 40;

  double a = pixelSize * 10, b = pixelSize * 5;

  tglDrawCircle(m_pos, r);

  double phi = getValue(m_param);

  glPushMatrix();

  glTranslated(m_pos.x, m_pos.y, 0);

  glRotated(phi, 0, 0, 1);

  glBegin(GL_LINES);

  glVertex2d(0, 0);

  glVertex2d(r, 0);

  glVertex2d(r, 0);

  glVertex2d(r - a, b);

  glVertex2d(r, 0);

  glVertex2d(r - a, -b);

  glEnd();

  glPopMatrix();

  glPopName();

  if (isSelected()) {

    drawTooltip(m_pos + TPointD(0.707, 0.707) * r, getLabel());

  }

}

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

void AngleFxGadget::leftButtonDown(const TPointD &pos, const TMouseEvent &) {}

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

void AngleFxGadget::leftButtonDrag(const TPointD &pos, const TMouseEvent &) {

  TPointD d  = pos - m_pos;

  double phi = atan2(d.y, d.x);

  setValue(m_param, phi * M_180_PI);

}

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

class AngleRangeFxGadget final : public FxGadget {

  TDoubleParamP m_startAngle, m_endAngle;

  TPointParamP m_center;

  enum HANDLE { StartAngle = 0, EndAngle, None } m_handle = None;

  double m_clickedAngle;

  double m_targetAngle, m_anotherAngle;

public:

  AngleRangeFxGadget(FxGadgetController *controller,

                     const TDoubleParamP &startAngle,

                     const TDoubleParamP &endAngle, const TPointParamP &center);

  void draw(bool picking) override;

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

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

  void leftButtonUp() override;

};

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

AngleRangeFxGadget::AngleRangeFxGadget(FxGadgetController *controller,

                                       const TDoubleParamP &startAngle,

                                       const TDoubleParamP &endAngle,

                                       const TPointParamP &center)

    : FxGadget(controller, 2)

    , m_startAngle(startAngle)

    , m_endAngle(endAngle)

    , m_center(center) {

  addParam(startAngle);

  addParam(endAngle);

  addParam(center->getX());

  addParam(center->getY());

}

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

void AngleRangeFxGadget::draw(bool picking) {

  auto setColorById = [&](int id) {

    if (isSelected(id))

      glColor3dv(m_selectedColor);

    else

      glColor3d(0, 0, 1);

  };

  double pixelSize = sqrt(tglGetPixelSize2()) * m_controller->getDevPixRatio();

  double r         = pixelSize * 200;

  double a         = pixelSize * 30;

  TPointD center = getValue(m_center);

  double start   = getValue(m_startAngle);

  double end     = getValue(m_endAngle);

  glPushMatrix();

  glTranslated(center.x, center.y, 0);

  setColorById(StartAngle);

  glPushMatrix();

  glPushName(getId() + StartAngle);

  glRotated(start, 0, 0, 1);

  glBegin(GL_LINE_STRIP);

  glVertex2d(0, 0);

  glVertex2d(r, 0);

  // expand handle while dragging

  if (m_handle == StartAngle) glVertex2d(r * 5.0, 0);

  glEnd();

  glPopName();

  glPushMatrix();

  glTranslated(r * 1.05, 0, 0.0);

  glScaled(pixelSize * 1.6, pixelSize * 1.6, 1);

  glRotated(-start, 0, 0, 1);

  tglDrawText(TPointD(0, 0), "Start Angle");

  glPopMatrix();

  glPopMatrix();

  setColorById(EndAngle);

  glPushMatrix();

  glPushName(getId() + EndAngle);

  glRotated(end, 0, 0, 1);

  glBegin(GL_LINE_STRIP);

  glVertex2d(0, 0);

  glVertex2d(r, 0);

  // expand handle while dragging

  if (m_handle == EndAngle) glVertex2d(r * 5.0, 0);

  glEnd();

  glPopName();

  glPushMatrix();

  glTranslated(r * 1.05, 0, 0.0);

  glScaled(pixelSize * 1.6, pixelSize * 1.6, 1);

  glRotated(-end, 0, 0, 1);

  tglDrawText(TPointD(0, 0), "End Angle");

  glPopMatrix();

  glPopMatrix();

  // draw arc

  while (end <= start) end += 360.0;

  glColor3d(0, 0, 1);

  glBegin(GL_LINE_STRIP);

  double angle  = start;

  double dAngle = 5.0;

  while (angle <= end) {

    double rad = angle / M_180_PI;

    glVertex2d(a * std::cos(rad), a * std::sin(rad));

    angle += dAngle;

  }

  if (angle != end)

    glVertex2d(a * std::cos(end / M_180_PI), a * std::sin(end / M_180_PI));

  glEnd();

  glPopMatrix();

}

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

void AngleRangeFxGadget::leftButtonDown(const TPointD &pos,

                                        const TMouseEvent &) {

  m_handle = (HANDLE)m_selected;

  if (m_handle == None) return;

  TPointD d             = pos - getValue(m_center);

  m_clickedAngle        = atan2(d.y, d.x) * M_180_PI;

  TDoubleParamP target  = (m_handle == StartAngle) ? m_startAngle : m_endAngle;

  TDoubleParamP another = (m_handle == StartAngle) ? m_endAngle : m_startAngle;

  m_targetAngle         = getValue(target);

  m_anotherAngle        = getValue(another);

}

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

void AngleRangeFxGadget::leftButtonDrag(const TPointD &pos,

                                        const TMouseEvent &e) {

  if (m_handle == None) return;

  TDoubleParamP target = (m_handle == StartAngle) ? m_startAngle : m_endAngle;

  TPointD d            = pos - getValue(m_center);

  double angle         = atan2(d.y, d.x) * M_180_PI;

  double targetAngle   = m_targetAngle + angle - m_clickedAngle;

  // move every 10 degrees when pressing Shift key

  if (e.isShiftPressed()) targetAngle = std::round(targetAngle / 10.0) * 10.0;

  setValue(target, targetAngle);

  // move both angles when pressing Ctrl key

  if (e.isCtrlPressed()) {

    TDoubleParamP another =

        (m_handle == StartAngle) ? m_endAngle : m_startAngle;