#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 <qapplication></qapplication>

#include <qdesktopwidget></qdesktopwidget>

using namespace EditToolGadgets;

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

namespace {

int getDevPixRatio() {

  static int devPixRatio = QApplication::desktop()->devicePixelRatio();

  return devPixRatio;

}

}

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

//    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;</paramdata>

  int m_frame;

public:

  FxGadgetUndo(const std::vector<tdoubleparamp> ¶ms, int frame)</tdoubleparamp>

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

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

  }

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

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

  }

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

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

    m_gadget->commitUndo();

  }

};

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

//    FxGadget  implementation

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

FxGadget::FxGadget(FxGadgetController *controller)

    : m_id(-1)

    , m_selected(false)

    , m_controller(controller)

    , m_pixelSize(1)

    , m_undo(0)

    , m_scaleFactor(1) {

  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 ¶m) {

  m_params.push_back(param);

  param->addObserver(this);

}

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

double FxGadget::getValue(const TDoubleParamP ¶m) const {

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

}

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

void FxGadget::setValue(const TDoubleParamP ¶m, double value) {

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

}

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

TPointD FxGadget::getValue(const TPointParamP ¶m) const {

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

}

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

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

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

}

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

void FxGadget::setPixelSize() {

  setPixelSize(sqrt(tglGetPixelSize2()) * getDevPixRatio());

}

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

void FxGadget::drawTooltip(const TPointD &tooltipPos,

                           std::string tooltipPosText) {

  double unit = sqrt(tglGetPixelSize2()) * 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 ¶m)

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

}

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

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

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

class RadiusFxGadget final : public FxGadget {

  TDoubleParamP m_radius;

  TPointParamP m_center;

public:

  RadiusFxGadget(FxGadgetController *controller, const TDoubleParamP &radius,

                 const TPointParamP ¢er)

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

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

}

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

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

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

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

}

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

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

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

class AngleFxGadget final : public FxGadget {

  TDoubleParamP m_param;

  TPointD m_pos;

public:

  AngleFxGadget(FxGadgetController *controller, const TDoubleParamP ¶m,

                const TPointD &pos);

  void draw(bool picking) 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;

};

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

AngleFxGadget::AngleFxGadget(FxGadgetController *controller,

                             const TDoubleParamP ¶m, 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()) * 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);

}

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

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

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

class DiamondFxGadget final : public FxGadget {

  TDoubleParamP m_param;

public:

  DiamondFxGadget(FxGadgetController *controller, const TDoubleParamP ¶m)

      : FxGadget(controller), m_param(param) {

    addParam(param);

  }

  void draw(bool picking) 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 DiamondFxGadget::draw(bool picking) {

  setPixelSize();

  if (isSelected())

    glColor3dv(m_selectedColor);

  else

    glColor3d(0, 0, 1);

  glPushName(getId());

  double size = getValue(m_param);

  double r    = 3 * getPixelSize();

  glLineStipple(1, 0xAAAA);

  glEnable(GL_LINE_STIPPLE);

  glBegin(GL_LINES);

  glVertex2d(-size + r, r);

  glVertex2d(-r, size - r);

  glVertex2d(r, size - r);

  glVertex2d(size - r, r);

  glVertex2d(size - r, -r);

  glVertex2d(r, -size + r);

  glVertex2d(-r, -size + r);

  glVertex2d(-size + r, -r);

  glEnd();

  glDisable(GL_LINE_STIPPLE);

  drawDot(-size, 0);

  drawDot(size, 0);

  drawDot(0, -size);

  drawDot(0, size);

  double d = getPixelSize() * 3;

  glPopName();

  if (isSelected()) {

    drawTooltip(TPointD(d, size - d), getLabel());

  }

}

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

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

  double sz        = fabs(pos.x) + fabs(pos.y);

  if (sz < 0.1) sz = 0.1;

  setValue(m_param, sz);

}

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

class SizeFxGadget final : public FxGadget {

  TDoubleParamP m_lx, m_ly;

public:

  SizeFxGadget(FxGadgetController *controller, const TDoubleParamP &lx,

               const TDoubleParamP &ly)

      : FxGadget(controller), m_lx(lx), m_ly(ly) {

    addParam(lx);

    if (ly) addParam(ly);

  }

  void draw(bool picking) 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 SizeFxGadget::draw(bool picking) {

  setPixelSize();

  if (isSelected())

    glColor3dv(m_selectedColor);

  else

    glColor3d(0, 0, 1);

  glPushName(getId());

  double lx = getValue(m_lx), ly = m_ly ? getValue(m_ly) : lx;

  double r = getPixelSize() * 3;

  glLineStipple(1, 0xCCCC);

  glEnable(GL_LINE_STIPPLE);

  glBegin(GL_LINES);

  glVertex2d(0, 0);

  glVertex2d(lx, 0);

  glVertex2d(0, 0);

  glVertex2d(0, ly);

  glVertex2d(lx, 0);

  glVertex2d(lx, ly - r);

  glVertex2d(0, ly);

  glVertex2d(lx - r, ly);

  glEnd();

  glDisable(GL_LINE_STIPPLE);

  drawDot(lx, ly);

  double d = getPixelSize() * 3;

  glPopName();

  if (isSelected()) {

    drawTooltip(TPointD(lx, ly), getLabel());

  }

}

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

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

  if (m_ly)

    setValue(m_lx, std::max(pos.x, 0.1)), setValue(m_ly, std::max(pos.y, 0.1));

  else

    setValue(m_lx, std::max({pos.x, pos.y, 0.1}));

}

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

class RectFxGadget final : public FxGadget {

  TDoubleParamP m_width, m_height;

  TPointParamP m_center;

  int m_picked;

public:

  enum { None, Corner, HorizontalSide, VerticalSide };

public:

  RectFxGadget(FxGadgetController *controller, const TDoubleParamP &width,

               const TDoubleParamP &height, const TPointParamP ¢er)

      : FxGadget(controller)

      , m_width(width)

      , m_height(height)

      , m_center(center)

      , m_picked(None) {

    addParam(width);

    addParam(height);

    if (center) addParam(center->getX()), addParam(center->getY());

  }

  TPointD getCenter() const {

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

  }

  void draw(bool picking) 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 RectFxGadget::draw(bool picking) {

  setPixelSize();

  if (isSelected())

    glColor3dv(m_selectedColor);

  else

    glColor3d(0, 0, 1);

  glPushName(getId());

  glPushMatrix();

  TPointD center = getCenter();

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

  double w_2 = 0.5 * getValue(m_width);

  double h_2 = 0.5 * getValue(m_height);

  double r   = getPixelSize() * 3;

  glLineStipple(1, 0xCCCC);

  glEnable(GL_LINE_STIPPLE);

  glBegin(GL_LINES);

  glVertex2d(-w_2 + r, -h_2);

  glVertex2d(w_2 - r, -h_2);

  glVertex2d(-w_2 + r, h_2);

  glVertex2d(w_2 - r, h_2);

  glVertex2d(-w_2, -h_2 + r);

  glVertex2d(-w_2, h_2 - r);

  glVertex2d(w_2, -h_2 + r);

  glVertex2d(w_2, h_2 - r);

  glEnd();

  glDisable(GL_LINE_STIPPLE);

  drawDot(w_2, h_2);

  drawDot(-w_2, h_2);

  drawDot(w_2, -h_2);

  drawDot(-w_2, -h_2);

  glPopMatrix();

}

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

void RectFxGadget::leftButtonDown(const TPointD &ppos, const TMouseEvent &) {

  TPointD pos = ppos - getCenter();

  m_picked    = None;

  double w_2  = 0.5 * getValue(m_width);

  double h_2  = 0.5 * getValue(m_height);

  double x    = fabs(pos.x);

  double y    = fabs(pos.y);

  double r    = getPixelSize() * 15;

  if (fabs(w_2 - x) < r && fabs(y - h_2) < r)

    m_picked = Corner;

  else if (fabs(w_2 - x) < r && y < h_2)

    m_picked = VerticalSide;

  else if (fabs(h_2 - y) < r && x < w_2)

    m_picked = HorizontalSide;

}

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

void RectFxGadget::leftButtonDrag(const TPointD &ppos, const TMouseEvent &) {

  TPointD pos = ppos - getCenter();

  double w = fabs(pos.x), h = fabs(pos.y);

  if (m_picked == Corner || m_picked == VerticalSide)

    setValue(m_width, 2.0 * w);

  if (m_picked == Corner || m_picked == HorizontalSide)

    setValue(m_height, 2.0 * h);

}

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

class PolarFxGadget final : public FxGadget {

  TPointD m_pos;

  TDoubleParamP m_phiParam, m_lengthParam;

public:

  PolarFxGadget(FxGadgetController *controller, const TPointD &pos,

                const TDoubleParamP &phiParam, const TDoubleParamP &lengthParam)

      : FxGadget(controller)

      , m_pos(pos)

      , m_phiParam(phiParam)

      , m_lengthParam(lengthParam) {

    addParam(phiParam);

    addParam(lengthParam);

  }

  void draw(bool picking) override {

    setPixelSize();

    if (isSelected())

      glColor3dv(m_selectedColor);

    else

      glColor3d(0, 0, 1);

    glPushName(getId());

    double pixelSize = getPixelSize();

    double r         = getValue(m_lengthParam);

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

    // tglDrawCircle(m_pos, r);

    double phi = getValue(m_phiParam);

    glPushMatrix();

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

    glRotated(phi, 0, 0, 1);

    double rr = r - c;

    if (rr > 0) {

      glLineStipple(1, 0xAAAA);

      glEnable(GL_LINE_STIPPLE);

      glBegin(GL_LINE_STRIP);

      glVertex2d(0, 0);

      glVertex2d(rr, 0);

      glEnd();

      glDisable(GL_LINE_STIPPLE);

    }

    glBegin(GL_LINES);

    glVertex2d(rr, 0);

    glVertex2d(rr - a, b);

    glVertex2d(rr, 0);

    glVertex2d(rr - a, -b);

    glEnd();

    glTranslated(r, 0, 0);

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

    drawDot(0, 0);

    glPopMatrix();

    glPopName();

    if (isSelected()) {

      double phiRad      = phi * M_PI_180;

      TPointD toolTipPos = m_pos + r * TPointD(cos(phiRad), sin(phiRad));

      drawTooltip(toolTipPos, getLabel());

    }

  }

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

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

    TPointD d     = pos - m_pos;

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

    double length = norm(d);

    setValue(m_phiParam, phi * M_180_PI);

    setValue(m_lengthParam, length);

  }

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

};

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

class VectorFxGadget final : public FxGadget {

  TPointParamP m_pa, m_pb;

  int m_selected;

public:

  VectorFxGadget(FxGadgetController *controller, const TPointParamP &pa,

                 const TPointParamP &pb)

      : FxGadget(controller), m_pa(pa), m_pb(pb), m_selected(0) {

    addParam(pa->getX());

    addParam(pa->getY());

    addParam(pb->getX());

    addParam(pb->getY());

  }

  void draw(bool picking) override {

    setPixelSize();

    if (isSelected())

      glColor3dv(m_selectedColor);

    else

      glColor3d(0, 0, 1);

    glPushName(getId());

    double pixelSize = getPixelSize();

    TPointD pa       = getValue(m_pa);

    TPointD pb       = getValue(m_pb);

    TPointD dab      = pb - pa;

    double ab2       = norm2(dab);

    if (ab2 > 0.0001) {

      double ab = sqrt(ab2);

      TPointD u = dab * (1.0 / ab);

      TPointD v = rotate90(u);

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

      double c = pixelSize * 4;

      TPointD pbb = pb - u * c;

      if (ab - c > 0) {

        glLineStipple(1, 0xAAAA);