#include "toonz/tpalettehandle.h"

#include "tools/toolhandle.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 "tw/keycodes.h"

#include "historytypes.h"

// For Qt translation support

#include <qcoreapplication></qcoreapplication>

using namespace ToolUtils;

class GeometricTool;

class MultiLinePrimitive;

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

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

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

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

// Utility Functions

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

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

}

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

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

{

	TPointD d = p1 - p0;

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

}

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

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;

}

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

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 : public TUndo

{

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

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

	MultiLinePrimitive *m_tool;

public:

	MultilinePrimitiveUndo(const std::vector<tpointd> &vertex, MultiLinePrimitive *tool)</tpointd>

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

	{

	}

	~MultilinePrimitiveUndo() {}

	void undo() const;

	void redo() const;

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

	{

		m_newVertex = vertex;

	}

	int getSize() const

	{

		return sizeof(this);

	}

	QString getToolName();

	int getHistoryType()

	{

		return HistoryType::GeometricTool;

	}

};

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

class FullColorBluredPrimitiveUndo : 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

	{

		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

	{

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

	}

};

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

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

class CMBluredPrimitiveUndo : 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

	{

		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

	{

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

	TBoolProperty m_pencil;

	TEnumProperty m_capStyle;

	TEnumProperty m_joinStyle;

	TIntProperty m_miterJoinLimit;

	TPropertyGroup m_prop[2];

	int m_targetType;

	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_selective("Selective", false), m_pencil("Pencil Mode", false), m_capStyle("Cap"), m_joinStyle("Join"), m_miterJoinLimit("Miter:", 0, 100, 4), 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);

		}

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

		m_capStyle.addValue(ROUNDC_WSTR);

		m_capStyle.addValue(PROJECTING_WSTR);

		m_capStyle.setId("Cap");

		m_joinStyle.addValue(MITER_WSTR);

		m_joinStyle.addValue(ROUNDJ_WSTR);

		m_joinStyle.addValue(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_type.setId("GeometricShape");

		m_edgeCount.setId("GeometricEdge");

	}

	void updateTranslation()

	{

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

		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_selective.setQStringName(tr("Selective"));

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

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

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

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

	}

};

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

// 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(int key, const TPoint &point) { return false; }

	virtual void onEnter(){};

	virtual void draw(){};

	virtual void onActivate(){};

	virtual void onDeactivate(){};

	virtual void onImageChanged(){};

	virtual TStroke *makeStroke() const = 0;

};

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

// Rectangle Primitive Class Declaration

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

class RectanglePrimitive : 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)

	{

	}

	virtual std::string getName() const { return "Rectangle"; } // W_ToolOptions_ShapeRect"; }

	TStroke *makeStroke() const;

	void draw();

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

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

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

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

	void onEnter();

};

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

// Circle Primitive Class Declaration

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

class CirclePrimitive : 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)

	{

	}

	virtual std::string getName() const { return "Circle"; } // W_ToolOptions_ShapeCircle";}

	void draw();

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

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

	TStroke *makeStroke() const;

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

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

	void onEnter();

};

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

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

	{

	}

	virtual std::string getName() const { return "Polyline"; } // W_ToolOptions_ShapePolyline";}

	void addVertex(const TPointD &pos);

	void moveSpeed(const TPointD &delta);

	virtual void draw();

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

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

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

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

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

	bool keyDown(int key, const TPoint &point);

	TStroke *makeStroke() const;

	void endLine();

	void onActivate();

	void onDeactivate()

	{

		m_vertex.clear();

		m_speedMoved = false;

		m_beforeSpeedMoved = false;

	}

	void onEnter();

	void onImageChanged();

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

	{

		m_vertex = vertex;

	};

	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 : public MultiLinePrimitive

{

public:

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

		: MultiLinePrimitive(param, tool, reasterTool)

	{

		m_isSingleLine = true;

	}

	std::string getName() const { return "Line"; } // W_ToolOptions_ShapePolyline";}

	void draw();

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

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

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

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

};

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

// Ellipse Primitive Class Declaration

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

class EllipsePrimitive : 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)

	{

	}

	virtual std::string getName() const { return "Ellipse"; } // W_ToolOptions_ShapeEllipse";}

	void draw();

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

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

	TStroke *makeStroke() const;

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

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

	void onEnter();

};

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

// Arc Primitive Class Declaration

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

class ArcPrimitive : public Primitive

{

	TStroke *m_stroke;

	TPointD m_startPoint, m_endPoint, m_centralPoint;

	int m_clickNumber;

	TPixel32 m_color;

public:

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

		: Primitive(param, tool, reasterTool), m_stroke(0), m_clickNumber(0)

	{

	}

	~ArcPrimitive()

	{

		if (m_stroke)

			delete m_stroke;

	}

	virtual std::string getName() const { return "Arc"; } // _ToolOptions_ShapeArc";}

	TStroke *makeStroke() const;

	void draw();

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

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

	void onEnter();

};

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

// Polygon Primitive Class Declaration

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

class PolygonPrimitive : public Primitive

{

	TPointD m_startPoint, m_centre;

	double m_radius;

	TPixel32 m_color;

public:

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

		: Primitive(param, tool, reasterTool)

	{

	}

	virtual std::string getName() const { return "Polygon"; } // W_ToolOptions_ShapePolygon";}

	TStroke *makeStroke() const;

	void draw();

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

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

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

};

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

// Geometric Tool

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

class GeometricTool : public TTool

{

protected:

	Primitive *m_primitive;

	std::map<std::wstring, *="" primitive=""> m_primitiveTable;</std::wstring,>

	PrimitiveParam m_param;

	std::wstring m_typeCode;

	bool m_active;

	bool m_firstTime;

public:

	GeometricTool(int targetType)

		: TTool("T_Geometric"), m_primitive(0), m_param(targetType), m_active(false), m_firstTime(true)

	{

		bind(targetType);

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

			(targetType & TTool::ToonzImage)) {

			addPrimitive(new RectanglePrimitive(&m_param, this, true));

			addPrimitive(new CirclePrimitive(&m_param, this, true));

			addPrimitive(new EllipsePrimitive(&m_param, this, true));

			addPrimitive(new LinePrimitive(&m_param, this, true));

			addPrimitive(new MultiLinePrimitive(&m_param, this, true));

			addPrimitive(new ArcPrimitive(&m_param, this, true));

			addPrimitive(new PolygonPrimitive(&m_param, this, true));

		} else //targetType == 1

		{

			//vector

			addPrimitive(m_primitive = new RectanglePrimitive(&m_param, this, false));

			addPrimitive(new CirclePrimitive(&m_param, this, false));

			addPrimitive(new EllipsePrimitive(&m_param, this, false));

			addPrimitive(new LinePrimitive(&m_param, this, false));