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

}

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

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

}

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

  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 {

    // precise control with pressing Alt key

    if (e.isAltPressed()) {

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

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

    } else

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

    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 ¶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 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 ¢er);

  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;

};

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

AngleRangeFxGadget::AngleRangeFxGadget(FxGadgetController *controller,

                                       const TDoubleParamP &startAngle,

                                       const TDoubleParamP &endAngle,

                                       const TPointParamP ¢er)

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

    double anotherAngle = m_anotherAngle + angle - m_clickedAngle;

    if (e.isShiftPressed())

      anotherAngle = std::round(anotherAngle / 10.0) * 10.0;

    setValue(another, anotherAngle);

  }

}

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

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

  m_handle = None;

}

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

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;