#include "toonz/tpalettehandle.h"

#include "tools/toolhandle.h"

#include "tools/toolcommandids.h"

#include "toonz/tobjecthandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tframehandle.h"

#include "tools/tool.h"

#include "tcolorstyles.h"

#include "tpalette.h"

#include "tools/toolutils.h"

#include "tstroke.h"

#include "tmathutil.h"

#include "tools/cursors.h"

#include "tproperty.h"

#include "ttoonzimage.h"

#include "drawutil.h"

#include "tvectorimage.h"

#include "tenv.h"

#include "bluredbrush.h"

#include "toonz/ttileset.h"

#include "toonz/toonzimageutils.h"

#include "toonz/tstageobject.h"

#include "toonz/tstageobjectspline.h"

#include "toonzqt/imageutils.h"

#include "toonzqt/dvdialog.h"

#include "toonz/trasterimageutils.h"

#include "toonz/preferences.h"

#include "historytypes.h"

#include "toonzvectorbrushtool.h"

// For Qt translation support

#include <qcoreapplication></qcoreapplication>

using namespace ToolUtils;

class GeometricTool;

class MultiLinePrimitive;

class MultiArcPrimitive;

TEnv::DoubleVar GeometricSize("InknpaintGeometricSize", 1);

TEnv::DoubleVar GeometricRasterSize("InknpaintGeometricRasterSize", 1);

TEnv::StringVar GeometricType("InknpaintGeometricType", "Rectangle");

TEnv::IntVar GeometricEdgeCount("InknpaintGeometricEdgeCount", 3);

TEnv::IntVar GeometricSelective("InknpaintGeometricSelective", 0);

TEnv::IntVar GeometricGroupIt("InknpaintGeometricGroupIt", 0);

TEnv::IntVar GeometricAutofill("InknpaintGeometricAutofill", 0);

TEnv::IntVar GeometricSmooth("InknpaintGeometricSmooth", 0);

TEnv::IntVar GeometricPencil("InknpaintGeometricPencil", 0);

TEnv::DoubleVar GeometricBrushHardness("InknpaintGeometricHardness", 100);

TEnv::DoubleVar GeometricOpacity("InknpaintGeometricOpacity", 100);

TEnv::IntVar GeometricCapStyle("InknpaintGeometricCapStyle", 0);

TEnv::IntVar GeometricJoinStyle("InknpaintGeometricJoinStyle", 0);

TEnv::IntVar GeometricMiterValue("InknpaintGeometricMiterValue", 4);

TEnv::IntVar GeometricSnap("InknpaintGeometricSnap", 0);

TEnv::IntVar GeometricSnapSensitivity("InknpaintGeometricSnapSensitivity", 0);

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

#define ROUNDC_WSTR L"round_cap"

#define BUTT_WSTR L"butt_cap"

#define PROJECTING_WSTR L"projecting_cap"

#define ROUNDJ_WSTR L"round_join"

#define BEVEL_WSTR L"bevel_join"

#define MITER_WSTR L"miter_join"

#define LOW_WSTR L"Low"

#define MEDIUM_WSTR L"Medium"

#define HIGH_WSTR L"High"

const double SNAPPING_LOW    = 5.0;

const double SNAPPING_MEDIUM = 25.0;

const double SNAPPING_HIGH   = 100.0;

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

// Utility Functions

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

static TPointD rectify(const TPointD &oldPos, const TPointD &pos) {

  const double h             = sqrt(2.0) / 2.0;

  const TPointD directions[] = {TPointD(1, 0),  TPointD(h, h),  TPointD(0, 1),

                                TPointD(-h, h), TPointD(-1, 0), TPointD(-h, -h),

                                TPointD(0, -1), TPointD(h, -h)};

  TPointD v                  = pos - oldPos;

  int j                      = 0;

  double bestValue           = v * directions[j];

  for (int k = 1; k < 8; k++) {

    double value = v * directions[k];

    if (value > bestValue) {

      bestValue = value;

      j         = k;

    }

  }

  return oldPos + bestValue * directions[j];

}

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

static TPointD computeSpeed(TPointD p0, TPointD p1, double factor) {

  TPointD d = p1 - p0;

  return (d == TPointD()) ? TPointD() : d * (factor / norm(d));

}

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

static TRect drawBluredBrush(const TRasterImageP &ri, TStroke *stroke,

                             int thick, double hardness, double opacity) {

  TStroke *s       = new TStroke(*stroke);

  TPointD riCenter = ri->getRaster()->getCenterD();

  s->transform(TTranslation(riCenter));

  int styleId    = s->getStyle();

  TPalette *plt  = ri->getPalette();

  TPixel32 color = plt->getStyle(styleId)->getMainColor();

  TRectD bbox      = s->getBBox();

  TRect bboxI      = convert(bbox).enlarge(1);

  TRect rectRender = bboxI * ri->getRaster()->getBounds();

  if (rectRender.isEmpty()) return TRect();

  TRaster32P workRas(ri->getRaster()->getSize());

  TRaster32P backupRas = ri->getRaster()->clone();

  workRas->clear();

  QRadialGradient brushPad = ToolUtils::getBrushPad(thick, hardness);

  BluredBrush brush(workRas, thick, brushPad, false);

  int i, chunkCount = s->getChunkCount();

  for (i = 0; i < chunkCount; i++) {

    const TThickQuadratic *q = s->getChunk(i);

    std::vector<tthickpoint> points;</tthickpoint>

    points.push_back(q->getThickP0());

    points.push_back(q->getThickP1());

    points.push_back(q->getThickP2());

    // i punti contenuti nello stroke sembra che haano la tickness pari al

    // raggio e non al diametro del punto!

    points[0].thick *= 2;

    points[1].thick *= 2;

    points[2].thick *= 2;

    TRect chunkBox = brush.getBoundFromPoints(points);

    brush.addArc(points[0], points[1], points[2], 1, 1);

    brush.updateDrawing(ri->getRaster(), backupRas, color, chunkBox, opacity);

  }

  delete s;

  return rectRender;

}

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

static TRect drawBluredBrush(const TToonzImageP &ti, TStroke *stroke, int thick,

                             double hardness, bool selective) {

  TStroke *s       = new TStroke(*stroke);

  TPointD riCenter = ti->getRaster()->getCenterD();

  s->transform(TTranslation(riCenter));

  int styleId = s->getStyle();

  TRectD bbox      = s->getBBox();

  TRect bboxI      = convert(bbox).enlarge(1);

  TRect rectRender = bboxI * ti->getRaster()->getBounds();

  if (rectRender.isEmpty()) return TRect();

  TRaster32P workRas(ti->getRaster()->getSize());

  TRasterCM32P backupRas = ti->getRaster()->clone();

  workRas->clear();

  QRadialGradient brushPad = ToolUtils::getBrushPad(thick, hardness);

  BluredBrush brush(workRas, thick, brushPad, false);

  int i, chunkCount = s->getChunkCount();

  for (i = 0; i < chunkCount; i++) {

    const TThickQuadratic *q = s->getChunk(i);

    std::vector<tthickpoint> points;</tthickpoint>

    points.push_back(q->getThickP0());

    points.push_back(q->getThickP1());

    points.push_back(q->getThickP2());

    // i punti contenuti nello stroke sembra che haano la tickness pari al

    // raggio e non al diametro del punto!

    points[0].thick *= 2;

    points[1].thick *= 2;

    points[2].thick *= 2;

    TRect chunkBox = brush.getBoundFromPoints(points);

    brush.addArc(points[0], points[1], points[2], 1, 1);

    brush.updateDrawing(ti->getRaster(), backupRas, chunkBox, styleId,

                        selective);

  }

  delete s;

  return rectRender;

}

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

class MultilinePrimitiveUndo final : public TUndo {

  std::vector<tpointd> m_oldVertex;</tpointd>

  std::vector<tpointd> m_newVertex;</tpointd>

  MultiLinePrimitive *m_tool;

public:

  MultilinePrimitiveUndo(const std::vector<tpointd> &vertex,</tpointd>

                         MultiLinePrimitive *tool)

      : TUndo(), m_oldVertex(vertex), m_tool(tool), m_newVertex() {}

  ~MultilinePrimitiveUndo() {}

  void undo() const override;

  void redo() const override;

  void setNewVertex(const std::vector<tpointd> &vertex) {</tpointd>

    m_newVertex = vertex;

  }

  int getSize() const override { return sizeof(this); }

  QString getToolName();

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

};

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

class MultiArcPrimitiveUndoData {

private:

  TStroke *m_stroke;

  TStroke *m_strokeTemp;

  TPointD m_startPoint, m_endPoint, m_centralPoint;

  int m_clickNumber;

public:

  MultiArcPrimitiveUndoData(TStroke *stroke, TStroke *strokeTemp,

                            TPointD startPoint, TPointD endPoint,

                            TPointD centralPoint, int clickNumber)

      : m_stroke(0)

      , m_strokeTemp(0)

      , m_startPoint(startPoint)

      , m_endPoint(endPoint)

      , m_centralPoint(centralPoint)

      , m_clickNumber(clickNumber) {

    if (stroke) {

      m_stroke = new TStroke(*stroke);

    }

    if (strokeTemp) {

      m_strokeTemp = new TStroke(*strokeTemp);

    }

  }

  ~MultiArcPrimitiveUndoData() {

    delete m_stroke;

    delete m_strokeTemp;

  }

  void replace(MultiArcPrimitive *tool) const;

};

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

class MultiArcPrimitiveUndo final : public TUndo {

  MultiArcPrimitive *m_tool;

  MultiArcPrimitiveUndoData m_undo;

  MultiArcPrimitiveUndoData *m_redo;

public:

  MultiArcPrimitiveUndo(MultiArcPrimitive *tool, TStroke *stroke,

                        TStroke *strokeTemp, TPointD startPoint,

                        TPointD endPoint, TPointD centralPoint, int clickNumber)

      : TUndo()

      , m_tool(tool)

      , m_undo(stroke, strokeTemp, startPoint, endPoint, centralPoint,

               clickNumber)

      , m_redo(0) {}

  ~MultiArcPrimitiveUndo() { delete m_redo; }

  void setRedoData(TStroke *stroke, TStroke *strokeTemp, TPointD startPoint,

                   TPointD endPoint, TPointD centralPoint, int clickNumber) {

    m_redo = new MultiArcPrimitiveUndoData(stroke, strokeTemp, startPoint,

                                           endPoint, centralPoint, clickNumber);

  }

  void undo() const override;

  void redo() const override;

  int getSize() const override { return sizeof(this); }

  QString getToolName();

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

};

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

class FullColorBluredPrimitiveUndo final : public UndoFullColorPencil {

  int m_thickness;

  double m_hardness;

public:

  FullColorBluredPrimitiveUndo(TXshSimpleLevel *level, const TFrameId &frameId,

                               TStroke *stroke, int thickness, double hardness,

                               double opacity, bool doAntialias,

                               bool createdFrame, bool createdLevel)

      : UndoFullColorPencil(level, frameId, stroke, opacity, doAntialias,

                            createdFrame, createdLevel)

      , m_thickness(thickness)

      , m_hardness(hardness) {

    TRasterP raster = getImage()->getRaster();

    TDimension d    = raster->getSize();

    m_tiles         = new TTileSetFullColor(d);

    TRect rect      = convert(stroke->getBBox()) +

                 TPoint((int)(d.lx * 0.5), (int)(d.ly * 0.5));

    m_tiles->add(raster, rect.enlarge(2));

    m_stroke = new TStroke(*stroke);

  }

  ~FullColorBluredPrimitiveUndo() {}

  void redo() const override {

    insertLevelAndFrameIfNeeded();

    TRasterImageP ri = getImage();

    if (!ri) return;

    drawBluredBrush(ri, m_stroke, m_thickness, m_hardness, m_opacity);

    TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

  int getSize() const override {

    return UndoFullColorPencil::getSize() + sizeof(this);

  }

};

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

/*-- Hardness<100 のときの GeometricToolのUndo --*/

class CMBluredPrimitiveUndo final : public UndoRasterPencil {

  int m_thickness;

  double m_hardness;

  bool m_selective;

public:

  CMBluredPrimitiveUndo(TXshSimpleLevel *level, const TFrameId &frameId,

                        TStroke *stroke, int thickness, double hardness,

                        bool selective, bool doAntialias, bool createdFrame,

                        bool createdLevel, std::string primitiveName)

      : UndoRasterPencil(level, frameId, stroke, selective, false, doAntialias,

                         createdFrame, createdLevel, primitiveName)

      , m_thickness(thickness)

      , m_hardness(hardness)

      , m_selective(selective) {

    TRasterCM32P raster = getImage()->getRaster();

    TDimension d        = raster->getSize();

    m_tiles             = new TTileSetCM32(d);

    TRect rect          = convert(stroke->getBBox()) +

                 TPoint((int)(d.lx * 0.5), (int)(d.ly * 0.5));

    m_tiles->add(raster, rect.enlarge(2));

    m_stroke = new TStroke(*stroke);

  }

  ~CMBluredPrimitiveUndo() {}

  void redo() const override {

    insertLevelAndFrameIfNeeded();

    TToonzImageP ti = getImage();

    if (!ti) return;

    drawBluredBrush(ti, m_stroke, m_thickness, m_hardness, m_selective);

    TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();

    notifyImageChanged();

  }

  int getSize() const override {

    return UndoRasterPencil::getSize() + sizeof(this);

  }

};

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

class PrimitiveParam {

  Q_DECLARE_TR_FUNCTIONS(PrimitiveParam)

public:

  TDoubleProperty m_toolSize;

  TIntProperty m_rasterToolSize;

  TDoubleProperty m_opacity;

  TDoubleProperty m_hardness;

  TEnumProperty m_type;

  TIntProperty m_edgeCount;

  TBoolProperty m_autogroup;

  TBoolProperty m_autofill;

  TBoolProperty m_smooth;

  TBoolProperty m_selective;

  TBoolProperty m_pencil;

  TEnumProperty m_capStyle;

  TEnumProperty m_joinStyle;

  TIntProperty m_miterJoinLimit;

  TBoolProperty m_snap;

  TEnumProperty m_snapSensitivity;

  TPropertyGroup m_prop[2];

  int m_targetType;

  // for snapping

  int m_strokeIndex1;

  double m_w1, m_pixelSize, m_currThickness, m_minDistance2;

  bool m_foundSnap = false;

  TPointD m_snapPoint;

  PrimitiveParam(int targetType)

      : m_type("Shape:")  // "W_ToolOptions_ShapeType")

      , m_toolSize("Size:", 0, 100,

                   1)  // "W_ToolOptions_ShapeThickness", 0,30,1)

      , m_rasterToolSize("Size:", 1, 100, 1)

      , m_opacity("Opacity:", 0, 100, 100)

      , m_hardness("Hardness:", 0, 100, 100)

      , m_edgeCount("Polygon Sides:", 3, 15, 3)

      , m_autogroup("Auto Group", false)

      , m_autofill("Auto Fill", false)

      , m_smooth("Smooth", false)

      , m_selective("Selective", false)

      , m_pencil("Pencil Mode", false)

      , m_capStyle("Cap")

      , m_joinStyle("Join")

      , m_miterJoinLimit("Miter:", 0, 100, 4)

      , m_snap("Snap", false)

      , m_snapSensitivity("Sensitivity:")

      , m_targetType(targetType) {

    if (targetType & TTool::Vectors) m_prop[0].bind(m_toolSize);

    if (targetType & TTool::ToonzImage || targetType & TTool::RasterImage) {

      m_prop[0].bind(m_rasterToolSize);

      m_prop[0].bind(m_hardness);

    }

    if (targetType & TTool::RasterImage) m_prop[0].bind(m_opacity);

    m_prop[0].bind(m_type);

    m_prop[0].bind(m_edgeCount);

    if (targetType & TTool::Vectors) {

      m_prop[0].bind(m_autogroup);

      m_prop[0].bind(m_autofill);

      m_prop[0].bind(m_smooth);

      m_prop[0].bind(m_snap);

      m_snap.setId("Snap");

      m_prop[0].bind(m_snapSensitivity);

      m_snapSensitivity.addValue(LOW_WSTR);

      m_snapSensitivity.addValue(MEDIUM_WSTR);

      m_snapSensitivity.addValue(HIGH_WSTR);

      m_snapSensitivity.setId("SnapSensitivity");

    }

    if (targetType & TTool::ToonzImage) {

      m_prop[0].bind(m_selective);

      m_prop[0].bind(m_pencil);

      m_pencil.setId("PencilMode");

    }

    m_capStyle.addValue(BUTT_WSTR, QString::fromStdWString(BUTT_WSTR));

    m_capStyle.addValue(ROUNDC_WSTR, QString::fromStdWString(ROUNDC_WSTR));

    m_capStyle.addValue(PROJECTING_WSTR,

                        QString::fromStdWString(PROJECTING_WSTR));

    m_capStyle.setId("Cap");

    m_joinStyle.addValue(MITER_WSTR, QString::fromStdWString(MITER_WSTR));

    m_joinStyle.addValue(ROUNDJ_WSTR, QString::fromStdWString(ROUNDJ_WSTR));

    m_joinStyle.addValue(BEVEL_WSTR, QString::fromStdWString(BEVEL_WSTR));

    m_joinStyle.setId("Join");

    m_miterJoinLimit.setId("Miter");

    m_prop[1].bind(m_capStyle);

    m_prop[1].bind(m_joinStyle);

    m_prop[1].bind(m_miterJoinLimit);

    m_selective.setId("Selective");

    m_autogroup.setId("AutoGroup");

    m_autofill.setId("Autofill");

    m_smooth.setId("Smooth");

    m_type.setId("GeometricShape");

    m_edgeCount.setId("GeometricEdge");

  }

  void updateTranslation() {

    m_type.setQStringName(tr("Shape:"));

    m_type.setItemUIName(L"Rectangle", tr("Rectangle"));

    m_type.setItemUIName(L"Circle", tr("Circle"));

    m_type.setItemUIName(L"Ellipse", tr("Ellipse"));

    m_type.setItemUIName(L"Line", tr("Line"));

    m_type.setItemUIName(L"Polyline", tr("Polyline"));

    m_type.setItemUIName(L"Arc", tr("Arc"));

    m_type.setItemUIName(L"MultiArc", tr("MultiArc"));

    m_type.setItemUIName(L"Polygon", tr("Polygon"));

    m_toolSize.setQStringName(tr("Size:"));

    m_rasterToolSize.setQStringName(tr("Thickness:"));

    m_opacity.setQStringName(tr("Opacity:"));

    m_hardness.setQStringName(tr("Hardness:"));

    m_edgeCount.setQStringName(tr("Polygon Sides:"));

    m_autogroup.setQStringName(tr("Auto Group"));

    m_autofill.setQStringName(tr("Auto Fill"));

    m_smooth.setQStringName(tr("Smooth"));

    m_selective.setQStringName(tr("Selective"));

    m_pencil.setQStringName(tr("Pencil Mode"));

    m_capStyle.setQStringName(tr("Cap"));

    m_capStyle.setItemUIName(BUTT_WSTR, tr("Butt cap"));

    m_capStyle.setItemUIName(ROUNDC_WSTR, tr("Round cap"));

    m_capStyle.setItemUIName(PROJECTING_WSTR, tr("Projecting cap"));

    m_joinStyle.setQStringName(tr("Join"));

    m_joinStyle.setItemUIName(MITER_WSTR, tr("Miter join"));

    m_joinStyle.setItemUIName(ROUNDJ_WSTR, tr("Round join"));

    m_joinStyle.setItemUIName(BEVEL_WSTR, tr("Bevel join"));

    m_miterJoinLimit.setQStringName(tr("Miter:"));

    m_snap.setQStringName(tr("Snap"));

    m_snapSensitivity.setQStringName(tr(""));

    if (m_targetType & TTool::Vectors) {

      m_snapSensitivity.setItemUIName(LOW_WSTR, tr("Low"));

      m_snapSensitivity.setItemUIName(MEDIUM_WSTR, tr("Med"));

      m_snapSensitivity.setItemUIName(HIGH_WSTR, tr("High"));

    }

  }

};

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

// Abstract Class Primitive

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

class Primitive {

protected:

  bool m_isEditing, m_rasterTool, m_isPrompting;

  GeometricTool *m_tool;

  PrimitiveParam *m_param;

public:

  Primitive(PrimitiveParam *param, GeometricTool *tool, bool rasterTool)

      : m_param(param)

      , m_tool(tool)

      , m_isEditing(false)

      , m_rasterTool(rasterTool)

      , m_isPrompting(false) {}

  double getThickness() const {

    if (m_rasterTool)

      return m_param->m_rasterToolSize.getValue() * 0.5;

    else

      return m_param->m_toolSize.getValue() * 0.5;

  }

  void setIsPrompting(bool value) { m_isPrompting = value; }

  virtual std::string getName() const = 0;

  virtual ~Primitive() {}

  virtual void leftButtonDown(const TPointD &p, const TMouseEvent &e){};

  virtual void leftButtonDrag(const TPointD &p, const TMouseEvent &e){};

  virtual void leftButtonUp(const TPointD &p, const TMouseEvent &e){};

  virtual void leftButtonDoubleClick(const TPointD &, const TMouseEvent &e){};

  virtual void rightButtonDown(const TPointD &p, const TMouseEvent &e){};

  virtual void mouseMove(const TPointD &p, const TMouseEvent &e){};

  virtual bool keyDown(QKeyEvent *event) { return false; }

  virtual void onEnter(){};

  virtual void draw(){};

  virtual void onActivate(){};

  virtual void onDeactivate(){};

  virtual void onImageChanged(){};

  TPointD calculateSnap(TPointD pos);

  void drawSnap();

  TPointD getSnap(TPointD pos);

  void resetSnap();

  TPointD checkGuideSnapping(TPointD pos);

  bool getSmooth() { return m_param->m_smooth.getValue(); }

  virtual TStroke *makeStroke() const = 0;

};

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

void Primitive::resetSnap() {

  m_param->m_strokeIndex1 = -1;

  m_param->m_w1           = -1;

  m_param->m_foundSnap    = false;

}

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

TPointD Primitive::calculateSnap(TPointD pos) {

  m_param->m_foundSnap = false;

  if (Preferences::instance()->getVectorSnappingTarget() == 1) return pos;

  TVectorImageP vi(TTool::getImage(false));

  TPointD snapPoint = pos;

  if (vi && m_param->m_snap.getValue()) {

    double minDistance2     = m_param->m_minDistance2;

    m_param->m_strokeIndex1 = -1;

    int i, strokeNumber = vi->getStrokeCount();

    TStroke *stroke;

    double distance2, outW;

    for (i = 0; i < strokeNumber; i++) {

      stroke = vi->getStroke(i);

      if (stroke->getNearestW(pos, outW, distance2) &&

          distance2 < minDistance2) {

        minDistance2            = distance2;

        m_param->m_strokeIndex1 = i;

        if (areAlmostEqual(outW, 0.0, 1e-3))

          m_param->m_w1 = 0.0;

        else if (areAlmostEqual(outW, 1.0, 1e-3))

          m_param->m_w1 = 1.0;

        else

          m_param->m_w1 = outW;

        TThickPoint point1   = stroke->getPoint(m_param->m_w1);

        snapPoint            = TPointD(point1.x, point1.y);

        m_param->m_foundSnap = true;

        m_param->m_snapPoint = snapPoint;

      }

    }

  }

  return snapPoint;

}

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

TPointD Primitive::getSnap(TPointD pos) {

  if (m_param->m_foundSnap)

    return m_param->m_snapPoint;

  else

    return pos;

}

// Primitive::drawSnap and Primitive::checkGuideSnapping are below the

// Geometric Tool definition since they use the m_tool property of Primitive

// but it isn't defined yet up here.

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

// Rectangle Primitive Class Declaration

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

class RectanglePrimitive final : public Primitive {

  TRectD m_selectingRect;

  TPointD m_pos;

  TPointD m_startPoint;

  TPixel32 m_color;

public:

  RectanglePrimitive(PrimitiveParam *param, GeometricTool *tool,

                     bool reasterTool)

      : Primitive(param, tool, reasterTool) {}

  std::string getName() const override {

    return "Rectangle";

  }  // W_ToolOptions_ShapeRect"; }

  TStroke *makeStroke() const override;

  void draw() override;

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

  void leftButtonDrag(const TPointD &realPos, const TMouseEvent &e) override;

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

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

  void onEnter() override;

};

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

// Circle Primitive Class Declaration

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

class CirclePrimitive final : public Primitive {

  TPointD m_centre;

  TPointD m_pos;

  double m_radius;

  TPixel32 m_color;

public:

  CirclePrimitive(PrimitiveParam *param, GeometricTool *tool, bool reasterTool)

      : Primitive(param, tool, reasterTool) {}

  std::string getName() const override {

    return "Circle";

  }  // W_ToolOptions_ShapeCircle";}

  void draw() override;

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

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

  TStroke *makeStroke() const override;

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

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

  void onEnter() override;

};

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

// MultiLine Primitive Class Declaration

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

const double joinDistance = 5.0;

class MultiLinePrimitive : public Primitive {

protected:

  std::vector<tpointd> m_vertex;</tpointd>

  TPointD m_mousePosition;

  TPixel32 m_color;

  bool m_closed, m_isSingleLine;

  bool m_speedMoved;        //!< True after moveSpeed(), false after addVertex()

  bool m_beforeSpeedMoved;  //!< Old value of m_speedMoved

  bool m_ctrlDown;          //!< Whether ctrl is hold down

  MultilinePrimitiveUndo *m_undo;

public:

  MultiLinePrimitive(PrimitiveParam *param, GeometricTool *tool,

                     bool reasterTool)

      : Primitive(param, tool, reasterTool)

      , m_closed(false)

      , m_isSingleLine(false)

      , m_speedMoved(false)

      , m_beforeSpeedMoved(false)

      , m_ctrlDown(false) {}

  std::string getName() const override {

    return "Polyline";

  }  // W_ToolOptions_ShapePolyline";}

  void addVertex(const TPointD &pos);

  void moveSpeed(const TPointD &delta);

  void draw() override;

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

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

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

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

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

  bool keyDown(QKeyEvent *event) override;

  TStroke *makeStroke() const override;

  void endLine();

  void onActivate() override;

  void onDeactivate() override {

    m_vertex.clear();

    m_speedMoved       = false;

    m_beforeSpeedMoved = false;

  }

  void onEnter() override;

  void onImageChanged() override;

  void setVertexes(const std::vector<tpointd> &vertex) { m_vertex = vertex; };</tpointd>

  void setSpeedMoved(bool speedMoved) { m_speedMoved = speedMoved; };

};

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

void MultilinePrimitiveUndo::undo() const {

  m_tool->setVertexes(m_oldVertex);

  int count       = m_oldVertex.size();

  bool speedMoved = (count != 0 && count % 4 != 1);

  m_tool->setSpeedMoved(speedMoved);

  TTool::getApplication()->getCurrentTool()->getTool()->invalidate();

}

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

void MultilinePrimitiveUndo::redo() const {

  m_tool->setVertexes(m_newVertex);

  int count       = m_newVertex.size();

  bool speedMoved = (count != 0 && count % 4 != 1);

  m_tool->setSpeedMoved(speedMoved);

  TTool::getApplication()->getCurrentTool()->getTool()->invalidate();

}

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

QString MultilinePrimitiveUndo::getToolName() {

  return QString("Geometric Tool %1")

      .arg(QString::fromStdString(m_tool->getName()));

}

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

// Line Primitive Class Declaration

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

class LinePrimitive final : public MultiLinePrimitive {

public:

  LinePrimitive(PrimitiveParam *param, GeometricTool *tool, bool reasterTool)

      : MultiLinePrimitive(param, tool, reasterTool) {

    m_isSingleLine = true;

  }

  std::string getName() const override {

    return "Line";

  }  // W_ToolOptions_ShapePolyline";}

  void draw() override;

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

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

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

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

  void leftButtonDoubleClick(const TPointD &, const TMouseEvent &e) override {}

};

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

// Ellipse Primitive Class Declaration

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

class EllipsePrimitive final : public Primitive {

  TPointD m_pos;

  TRectD m_selectingRect;

  TPointD m_startPoint;

  TPixel32 m_color;

public:

  EllipsePrimitive(PrimitiveParam *param, GeometricTool *tool, bool reasterTool)

      : Primitive(param, tool, reasterTool) {}

  std::string getName() const override {

    return "Ellipse";

  }  // W_ToolOptions_ShapeEllipse";}

  void draw() override;

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

  void leftButtonDrag(const TPointD &realPos, const TMouseEvent &e) override;

  TStroke *makeStroke() const override;

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

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

  void onEnter() override;

};

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

// Multi Arc Primitive Class Declaration

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

class MultiArcPrimitive : public Primitive {

  TStroke *m_stroke;

  TStroke *m_strokeTemp;

  TPointD m_startPoint, m_endPoint, m_centralPoint;

  int m_clickNumber;

  TPixel32 m_color;

  int m_undoCount;

protected:

  bool m_isSingleArc;

public:

  MultiArcPrimitive(PrimitiveParam *param, GeometricTool *tool,

                    bool reasterTool)

      : Primitive(param, tool, reasterTool)

      , m_stroke(0)

      , m_strokeTemp(0)

      , m_clickNumber(0)

      , m_isSingleArc(false)

      , m_undoCount(0) {}

  ~MultiArcPrimitive() { delete m_stroke; }

  std::string getName() const override { return "MultiArc"; }

  TStroke *makeStroke() const override;

  void draw() override;

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

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

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

  bool keyDown(QKeyEvent *event) override;

  void onEnter() override;

  void onDeactivate() override {

    delete m_stroke;

    delete m_strokeTemp;

    m_stroke      = 0;

    m_strokeTemp  = 0;

    m_clickNumber = 0;

    TUndoManager::manager()->popUndo(m_undoCount);

    m_undoCount = 0;

  }

  void replaceData(TStroke *stroke, TStroke *strokeTemp, TPointD startPoint,

                   TPointD endPoint, TPointD centralPoint, int clickNumber) {

    delete m_stroke;

    delete m_strokeTemp;

    m_stroke       = stroke;

    m_strokeTemp   = strokeTemp;

    m_startPoint   = startPoint;

    m_endPoint     = endPoint;

    m_centralPoint = centralPoint;

    m_clickNumber  = clickNumber;

  }

  void decreaseUndo() { --m_undoCount; }

  void increaseUndo() { ++m_undoCount; }

};

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

void MultiArcPrimitiveUndoData::replace(MultiArcPrimitive *tool) const {

  TStroke *stroke     = 0;

  TStroke *strokeTemp = 0;