// TnzTools includes

#include "tools/toolhandle.h"

#include "tools/toolutils.h"

#include "tools/tool.h"

#include "tools/cursors.h"

// TnzQt includes

#include "toonzqt/imageutils.h"

// TnzLib includes

#include "toonz/txshlevelhandle.h"

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/strokegenerator.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/stage2.h"

// TnzBase includes

#include "tenv.h"

// TnzCore includes

#include "tmathutil.h"

#include "tundo.h"

#include "tstroke.h"

#include "tvectorimage.h"

#include "ttoonzimage.h"

#include "tproperty.h"

#include "tgl.h"

#include "tinbetween.h"

#include "drawutil.h"

// Qt includes

#include <qcoreapplication> // For Qt translation support</qcoreapplication>

using namespace ToolUtils;

TEnv::DoubleVar EraseVectorSize("InknpaintEraseVectorSize", 10);

TEnv::StringVar EraseVectorType("InknpaintEraseVectorType", "Normal");

TEnv::IntVar EraseVectorSelective("InknpaintEraseVectorSelective", 0);

TEnv::IntVar EraseVectorInvert("InknpaintEraseVectorInvert", 0);

TEnv::IntVar EraseVectorRange("InknpaintEraseVectorRange", 0);

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

//Eraser Tool

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

namespace

{

#define NORMAL_ERASE L"Normal"

#define RECT_ERASE L"Rectangular"

#define FREEHAND_ERASE L"Freehand"

#define POLYLINE_ERASE L"Polyline"

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

const double minDistance2 = 16.0; //4 pixel

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

void mapToVector(const std::map<int, *="" vistroke=""> &theMap, std::vector<int> &theVect)</int></int,>

{

	assert(theMap.size() == theVect.size());

	std::map<int, *="" vistroke="">::const_iterator it = theMap.begin();</int,>

	UINT i = 0;

	for (; it != theMap.end(); ++it) {

		theVect[i++] = it->first;

	}

}

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

class UndoEraser : public ToolUtils::TToolUndo

{

	std::vector<tfilledregioninf> m_oldFillInformation, m_newFillInformation;</tfilledregioninf>

	int m_row;

	int m_column;

public:

	std::map<int, *="" vistroke=""> m_originalStrokes;</int,>

	std::map<int, *="" vistroke=""> m_newStrokes;</int,>

	UndoEraser(TXshSimpleLevel *level, const TFrameId &frameId)

		: ToolUtils::TToolUndo(level, frameId)

	{

		TVectorImageP image = level->getFrame(m_frameId, true);

		if (!image)

			return;

		TTool::Application *app = TTool::getApplication();

		if (app) {

			m_row = app->getCurrentFrame()->getFrame();

			m_column = app->getCurrentColumn()->getColumnIndex();

		}

		ImageUtils::getFillingInformationInArea(image, m_oldFillInformation, image->getBBox());

	}

	void onAdd()

	{

		TVectorImageP image = m_level->getFrame(m_frameId, true);

		assert(!!image);

		if (!image)

			return;

		ImageUtils::getFillingInformationInArea(image, m_newFillInformation, image->getBBox());

	}

	~UndoEraser()

	{

		std::map<int, *="" vistroke="">::const_iterator it;</int,>

		for (it = m_originalStrokes.begin(); it != m_originalStrokes.end(); ++it)

			deleteVIStroke(it->second);

		for (it = m_newStrokes.begin(); it != m_newStrokes.end(); ++it)

			deleteVIStroke(it->second);

	}

	void addOldStroke(int index, VIStroke *stroke)

	{

		VIStroke *s = cloneVIStroke(stroke);

		m_originalStrokes.insert(std::map<int, *="" vistroke="">::value_type(index, s));</int,>

	}

	void addNewStroke(int index, VIStroke *stroke)

	{

		VIStroke *s = cloneVIStroke(stroke);

		m_newStrokes.insert(std::map<int, *="" vistroke="">::value_type(index, s));</int,>

	}

	void undo() const

	{

		TTool::Application *app = TTool::getApplication();

		if (!app)

			return;

		TFrameId currentFid;

		if (app->getCurrentFrame()->isEditingScene()) {

			app->getCurrentColumn()->setColumnIndex(m_column);

			app->getCurrentFrame()->setFrame(m_row);

			currentFid = TFrameId(m_row + 1);

		} else {

			app->getCurrentFrame()->setFid(m_frameId);

			currentFid = m_frameId;

		}

		TVectorImageP image = m_level->getFrame(m_frameId, true);

		assert(image);

		if (!image)

			return;

		QMutexLocker lock(image->getMutex());

		std::vector<int> newStrokeIndex(m_newStrokes.size());</int>

		mapToVector(m_newStrokes, newStrokeIndex);

		image->removeStrokes(newStrokeIndex, true, false);

		std::map<int, *="" vistroke="">::const_iterator it = m_originalStrokes.begin();</int,>

		UINT i = 0;

		VIStroke *s;

		for (; it != m_originalStrokes.end(); ++it) {

			s = cloneVIStroke(it->second);

			image->insertStrokeAt(s, it->first);

		}

		if (image->isComputedRegionAlmostOnce())

			image->findRegions(); //in futuro togliere. Serve perche' la  removeStrokes, se gli si dice

		//di non calcolare le regioni, e' piu' veloce ma poi chrash tutto

		UINT size = m_oldFillInformation.size();

		if (!size) {

			app->getCurrentXsheet()->notifyXsheetChanged();

			notifyImageChanged();

			return;

		}

		TRegion *reg;

		i = 0;

		for (; i < size; i++) {

			reg = image->getRegion(m_oldFillInformation[i].m_regionId);

			assert(reg);

			if (reg)

				reg->setStyle(m_oldFillInformation[i].m_styleId);

		}

		app->getCurrentXsheet()->notifyXsheetChanged();

		notifyImageChanged();

	}

	void redo() const

	{

		TTool::Application *app = TTool::getApplication();

		if (!app)

			return;

		TFrameId currentFid;

		if (app->getCurrentFrame()->isEditingScene()) {

			app->getCurrentColumn()->setColumnIndex(m_column);

			app->getCurrentFrame()->setFrame(m_row);

			currentFid = TFrameId(m_row + 1);

		} else {

			app->getCurrentFrame()->setFid(m_frameId);

			currentFid = m_frameId;

		}

		TVectorImageP image = m_level->getFrame(m_frameId, true);

		assert(image);

		if (!image)

			return;

		QMutexLocker lock(image->getMutex());

		std::vector<int> oldStrokeIndex(m_originalStrokes.size());</int>

		mapToVector(m_originalStrokes, oldStrokeIndex);

		image->removeStrokes(oldStrokeIndex, true, false);

		std::map<int, *="" vistroke="">::const_iterator it = m_newStrokes.begin();</int,>

		UINT i = 0;

		VIStroke *s;

		for (; it != m_newStrokes.end(); ++it) {

			s = cloneVIStroke(it->second);

			image->insertStrokeAt(s, it->first);

		}

		if (image->isComputedRegionAlmostOnce())

			image->findRegions(); //in futuro togliere. Serve perche' la  removeStrokes, se gli si dice

		//di non calcolare le regioni, e' piu' veloce ma poi chrash tutto

		UINT size = m_newFillInformation.size();

		if (!size) {

			app->getCurrentXsheet()->notifyXsheetChanged();

			notifyImageChanged();

			return;

		}

		TRegion *reg;

		i = 0;

		for (; i < size; i++) {

			reg = image->getRegion(m_newFillInformation[i].m_regionId);

			assert(reg);

			if (reg)

				reg->setStyle(m_newFillInformation[i].m_styleId);

		}

		app->getCurrentXsheet()->notifyXsheetChanged();

		notifyImageChanged();

	}

	int getSize() const

	{

		return sizeof(*this) + (m_oldFillInformation.capacity() + m_newFillInformation.capacity()) * sizeof(TFilledRegionInf) + 500;

	}

	QString getToolName()

	{

		return QString("Vector Eraser Tool");

	}

	int getHistoryType()

	{

		return HistoryType::EraserTool;

	}

};

} // namespace

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

//  EraserTool class declaration

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

class EraserTool : public TTool

{

	Q_DECLARE_TR_FUNCTIONS(EraserTool)

public:

	EraserTool();

	~EraserTool();

	ToolType getToolType() const { return TTool::LevelWriteTool; }

	void draw();

	void startErase(TVectorImageP vi, const TPointD &pos); //, const TImageLocation &imageLocation);

	void erase(TVectorImageP vi, const TPointD &pos);

	void erase(TVectorImageP vi, TRectD &rect); //, const TImageLocation &imageLocation);

	void stopErase(TVectorImageP vi);

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

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

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

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

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

	bool onPropertyChanged(std::string propertyName);

	void onEnter();

	void onLeave();

	void onActivate();

	TPropertyGroup *getProperties(int targetType) { return &m_prop; }

	int getCursorId() const { return ToolCursor::EraserCursor; }

	void onImageChanged();

	/*-- ドラッグ中にツールが切り替わった場合、Eraseの終了処理を行う --*/

	void onDeactivate();

private:

	TPropertyGroup m_prop;

	TEnumProperty m_eraseType;

	TDoubleProperty m_toolSize;

	TBoolProperty m_selective;

	TBoolProperty m_invertOption;

	TBoolProperty m_multi;

	double m_pointSize,

		m_distance2;

	TPointD m_mousePos, //!< Current mouse position.

		m_oldMousePos,  //!< Previous mouse position.

		m_brushPos,		//!< Position the brush will be painted at.

		m_firstPos;		//!< Either The first point inserted either in m_track or m_polyline

						//!  (depending on selected erase mode).

	UndoEraser *m_undo;

	std::vector<int> m_indexes;</int>

	TRectD m_selectingRect,

		m_firstRect;

	TFrameId m_firstFrameId,

		m_veryFirstFrameId;

	TXshSimpleLevelP m_level;

	std::pair<int, int=""> m_currCell;</int,>

	StrokeGenerator m_track; //!< Lazo selection generator.

	std::vector<tpointd> m_polyline; //!< Polyline points.</tpointd>

	TStroke *m_stroke;		//!< Stores the stroke generated by m_track.

	TStroke *m_firstStroke; //!< Stores the first stroke in the "frame range" case.

	double m_thick;

	bool m_firstTime,

		m_active,

		m_firstFrameSelected;

private:

	void resetMulti();

	void updateTranslation();

	//Metodi per disegnare la linea della modalita' Freehand

	void startFreehand(const TPointD &pos);

	void freehandDrag(const TPointD &pos);

	void closeFreehand(const TPointD &pos);

	//Metodi per disegnare la linea della modalita' Polyline

	void addPointPolyline(const TPointD &pos);

	void closePolyline(const TPointD &pos);

	void eraseRegion(const TVectorImageP vi, TStroke *stroke);

	void multiEraseRect(TFrameId firstFrameId, TFrameId lastFrameId,

						TRectD firstRect, TRectD lastRect, bool invert);

	void doMultiErase(TFrameId &firstFrameId, TFrameId &lastFrameId,

					  const TStroke *firstStroke, const TStroke *lastStroke);

	void doErase(double t, const TXshSimpleLevelP &sl, const TFrameId &fid,

				 const TVectorImageP &firstImage, const TVectorImageP &lastImage);

	void multiEreserRegion(TStroke *stroke, const TMouseEvent &e);

} eraserTool;

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

//  EraserTool implemention

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

EraserTool::EraserTool()

	: TTool("T_Eraser"), m_eraseType("Type:") // "W_ToolOptions_Erasetype"

	  ,

	  m_toolSize("Size:", 1, 100, 10) // "W_ToolOptions_EraserToolSize"

	  ,

	  m_selective("Selective", false) // "W_ToolOptions_Selective"

	  ,

	  m_invertOption("Invert", false) // "W_ToolOptions_Invert"

	  ,

	  m_multi("Frame Range", false) // "W_ToolOptions_FrameRange"

	  ,

	  m_pointSize(-1), m_undo(0), m_currCell(-1, -1), m_stroke(0), m_thick(5), m_active(false), m_firstTime(true)

{

	bind(TTool::VectorImage);

	m_prop.bind(m_toolSize);

	m_prop.bind(m_eraseType);

	m_eraseType.addValue(NORMAL_ERASE);

	m_eraseType.addValue(RECT_ERASE);

	m_eraseType.addValue(FREEHAND_ERASE);

	m_eraseType.addValue(POLYLINE_ERASE);

	m_prop.bind(m_selective);

	m_prop.bind(m_invertOption);

	m_prop.bind(m_multi);

	m_selective.setId("Selective");

	m_invertOption.setId("Invert");

	m_multi.setId("FrameRange");

	m_eraseType.setId("Type");

}

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

EraserTool::~EraserTool()

{

	if (m_stroke)

		delete m_stroke;

	if (m_firstStroke)

		delete m_firstStroke;

}

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

void EraserTool::updateTranslation()

{

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

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

	m_invertOption.setQStringName(tr("Invert"));

	m_multi.setQStringName(tr("Frame Range"));

	m_eraseType.setQStringName(tr("Type:"));

}

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

void EraserTool::draw()

{

	if (m_pointSize <= 0)

		return;

	double pixelSize2 = getPixelSize() * getPixelSize();

	m_thick = pixelSize2 / 2.0;

	TImageP image(getImage(false));

	TVectorImageP vi = image;

	if (vi) {

		bool blackBg = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg;

		if (m_eraseType.getValue() == RECT_ERASE) {

			TPixel color = blackBg ? TPixel32::White : TPixel32::Black;

			if (m_multi.getValue() && m_firstFrameSelected)

				drawRect(m_firstRect, color, 0x3F33, true);

			if (m_active || (m_multi.getValue() && !m_firstFrameSelected))

				drawRect(m_selectingRect, color, 0x3F33, true);

		}

		if (m_eraseType.getValue() == NORMAL_ERASE) {

			tglColor(TPixel32(255, 0, 255));

			tglDrawCircle(m_brushPos, m_pointSize);

		}

		if ((m_eraseType.getValue() == FREEHAND_ERASE || m_eraseType.getValue() == POLYLINE_ERASE) && m_multi.getValue()) {

			TPixel color = blackBg ? TPixel32::White : TPixel32::Black;

			tglColor(color);

			if (m_firstStroke)

				drawStrokeCenterline(*m_firstStroke, 1);

		}

		if (m_eraseType.getValue() == POLYLINE_ERASE && !m_polyline.empty()) {

			TPixel color = blackBg ? TPixel32::White : TPixel32::Black;

			tglColor(color);

			tglDrawCircle(m_polyline[0], 2);

			glBegin(GL_LINE_STRIP);

			for (UINT i = 0; i < m_polyline.size(); i++)

				tglVertex(m_polyline[i]);

			tglVertex(m_mousePos);

			glEnd();

		}

	}

}

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

void EraserTool::resetMulti()

{

	m_firstFrameSelected = false;

	m_firstRect.empty();

	m_selectingRect.empty();

	TTool::Application *application = TTool::getApplication();

	if (!application)

		return;

	m_firstFrameId = m_veryFirstFrameId = getCurrentFid();

	m_level = application->getCurrentLevel()->getLevel()

				  ? application->getCurrentLevel()->getLevel()->getSimpleLevel()

				  : 0;

	if (m_firstStroke) {

		delete m_firstStroke;

		m_firstStroke = 0;

	}

}

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

void EraserTool::startErase(TVectorImageP vi, const TPointD &pos) //, const TImageLocation &imageLocation)

{

	UINT size = vi->getStrokeCount();

	m_indexes.resize(size);

	for (UINT i = 0; i < size; i++)

		m_indexes[i] = i;

	assert(m_undo == 0);

	delete m_undo;

	TXshSimpleLevel *level = TTool::getApplication()->getCurrentLevel()->getSimpleLevel();

	m_undo = new UndoEraser(level, getCurrentFid());

	m_oldMousePos = pos;

	m_distance2 = minDistance2 * getPixelSize() * getPixelSize();

	erase(vi, pos);

}

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

void EraserTool::erase(TVectorImageP vi, const TPointD &pos)

{

	std::vector<int>::iterator it = m_indexes.begin();</int>

	m_distance2 += tdistance2(m_oldMousePos, pos);

	if (m_distance2 < minDistance2 * getPixelSize() * getPixelSize())

		return;

	m_distance2 = 0;

	m_oldMousePos = pos;

	//quadrato circoscritto alla circonferenza

	TRectD circumscribedSquare(pos.x - m_pointSize, pos.y - m_pointSize, pos.x + m_pointSize, pos.y + m_pointSize);

	if (!circumscribedSquare.overlaps(vi->getBBox())) {

		invalidate();

		return;

	}

	std::vector<double> intersections;</double>

	std::vector<doublepair> sortedWRanges;</doublepair>

	std::vector<tstroke *=""> splitStrokes;</tstroke>

	double rectEdge_2 = m_pointSize * TConsts::sqrt2_2;

	//quadrato iscritto nella circonferenza

	TRectD enrolledSquare(pos.x - rectEdge_2, pos.y - rectEdge_2, pos.x + rectEdge_2, pos.y + rectEdge_2);

	UINT i = 0;

	double pointSize2 = sq(m_pointSize);

	std::vector<int> oneStrokeIndex(1);</int>

	int index = TTool::getApplication()->getCurrentLevelStyleIndex();

	QMutexLocker lock(vi->getMutex());

	while (i < vi->getStrokeCount()) {

		assert(it != m_indexes.end());

		TStroke *oldStroke = vi->getStroke(i);

		if (!vi->inCurrentGroup(i) || (m_selective.getValue() && oldStroke->getStyle() != index)) {

			i++;

			it++;

			continue;

		}

		TRectD strokeBBox = oldStroke->getBBox();

		if (!circumscribedSquare.overlaps(strokeBBox)) { //stroke all'esterno del quadrato circoscritto alla circonferenxa

			i++;

			it++;

			continue;

		}

		if (enrolledSquare.contains(strokeBBox)) { //stroke tutta contenuta nel quadrato iscritto nella circonferenza

			if (*it != -1)

				m_undo->addOldStroke(*it, vi->getVIStroke(i));

			oneStrokeIndex[0] = i;

			vi->removeStrokes(oneStrokeIndex, true, true);

			it = m_indexes.erase(it);

			continue;

		}

		splitStrokes.clear();

		intersections.clear();

		/*int intersNum=*/intersect(*oldStroke, pos, m_pointSize, intersections);

		/*

    #ifdef _DEBUG

    if(intersections.size()==2 && intersections[0]==intersections[1])

    {

      intersections.clear();

      intersect( *oldStroke, pos, m_pointSize, intersections );   

    }

    #endif

    */

		if (intersections.empty()) {

			//BASTEREBBE CONTROLLARE UN SOLO PUNTO PERCHE' SE LA

			//STROKE NON INTERSECA IL CERCHIO E CONTENTIENE ALMENO

			//UN PUNTO, LA CONTIENE TUTTA. MA SICCOME NON MI FIDO

			//DELLA INTERSECT, NE CONTROLLO UN PAIO E AVVANTAGGIO (CON L' AND)

			//IL NON CONTENIMENTO, DATO CHE E' MEGLIO CANCELLARE UNA COSA IN

			// MENO, CHE UNA IN PIU'

			if (tdistance2(oldStroke->getPoint(0), pos) < pointSize2 &&

				tdistance2(oldStroke->getPoint(1), pos) < pointSize2) { //stroke tutta contenuta nella circonferenxa

				if (*it != -1)

					m_undo->addOldStroke(*it, vi->getVIStroke(i));

				oneStrokeIndex[0] = i;

				vi->removeStrokes(oneStrokeIndex, true, true);

				it = m_indexes.erase(it);

			} else { //non colpita

				i++;

				it++;

			}

			continue;

		}

		//------------------------ almeno un'intersezione ---------------------------------------------------------

		if (intersections.size() == 1) {

			if (oldStroke->isSelfLoop()) { // una sola intersezione di una stroke chiusa con un cerchio dovrebbe accadere

				// solo in caso di sfioramento, quindi faccio finta di nulla

				i++;

				it++;

				continue;

			}

			if (*it != -1)

				m_undo->addOldStroke(*it, vi->getVIStroke(i));

			double w0 = intersections[0];

			TThickPoint hitPoint = oldStroke->getThickPoint(w0);

			int chunck;

			double t;

			oldStroke->getChunkAndT(w0, chunck, t);

			int chunckIndex;

			double w1;

			if (tdistance2(oldStroke->getPoint(0), pos) < pointSize2) {

				chunckIndex = oldStroke->getChunkCount() - 1;

				w1 = 1;

			} else {

				chunckIndex = 0;

				w1 = 0;

			}

			UINT cI;

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

			if (w1 == 0) {

				for (cI = chunckIndex; cI < (UINT)chunck; cI++) {

					points.push_back(oldStroke->getChunk(cI)->getThickP0());

					points.push_back(oldStroke->getChunk(cI)->getThickP1());

				}

				TThickQuadratic t1, t2;

				oldStroke->getChunk(chunck)->split(t, t1, t2);

				points.push_back(t1.getThickP0());

				points.push_back(t1.getThickP1());

				points.push_back(hitPoint);

			} else {

				TThickQuadratic t1, t2;

				oldStroke->getChunk(chunck)->split(t, t1, t2);

				points.push_back(hitPoint);

				points.push_back(t2.getThickP1());

				points.push_back(t2.getThickP2());

				for (cI = chunck + 1; cI <= (UINT)chunckIndex; cI++) {

					points.push_back(oldStroke->getChunk(cI)->getThickP1());

					points.push_back(oldStroke->getChunk(cI)->getThickP2());

				}

			}

			oldStroke->reshape(&(points[0]), points.size());

			vi->notifyChangedStrokes(i); //per adesso cosi', pero' e' lento

			*it = -1;

			i++;

			it++;

			continue;

		}

		//---------- piu' intersezioni--------------------------------------------------------

		if (intersections.size() & 1 && oldStroke->isSelfLoop()) { //non dovrebbe mai accadere

			assert(0);

			i++;

			it++;

			continue;

		}

		if (intersections.size() == 2 && intersections[0] == intersections[1]) { //solo sfiorata

			i++;

			it++;

			continue;

		}

		UINT oldStrokeSize = vi->getStrokeCount();

		if (*it != -1)

			m_undo->addOldStroke(*it, vi->getVIStroke(i));

		sortedWRanges.clear();

		if (tdistance2(vi->getStroke(i)->getPoint(0), pos) > pointSize2) {

			if (intersections[0] == 0.0)

				intersections.erase(intersections.begin());

			else

				intersections.insert(intersections.begin(), 0.0);

		}

		if (intersections[0] != 1.0)

			intersections.push_back(1.0);

		sortedWRanges.reserve(intersections.size() / 2);

		for (UINT j = 0; j < intersections.size() - 1; j += 2)

			sortedWRanges.push_back(std::make_pair(intersections[j], intersections[j + 1]));

#ifdef _DEBUG

		for (UINT kkk = 0; kkk < sortedWRanges.size() - 1; kkk++) {

			assert(sortedWRanges[kkk].first < sortedWRanges[kkk].second);

			assert(sortedWRanges[kkk].second <= sortedWRanges[kkk + 1].first);

		}

		assert(sortedWRanges.back().first < sortedWRanges.back().second);

#endif

		vi->splitStroke(i, sortedWRanges);

		UINT addedStroke = vi->getStrokeCount() - (oldStrokeSize - 1); //-1 perche' e' quella tolta

		i += addedStroke;

		*it = -1;

		m_indexes.insert(it, addedStroke - 1, -1);

		it = m_indexes.begin() + i;

	}

	invalidate();

}

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

void EraserTool::erase(TVectorImageP vi, TRectD &rect)

{

	if (rect.x0 > rect.x1)

		tswap(rect.x1, rect.x0);

	if (rect.y0 > rect.y1)

		tswap(rect.y1, rect.y0);

	int i = 0;

	int index = TTool::getApplication()->getCurrentLevelStyleIndex();

	std::vector<int> eraseStrokes;</int>

	TXshSimpleLevel *level = TTool::getApplication()->getCurrentLevel()->getSimpleLevel();

	m_undo = new UndoEraser(level, getCurrentFid());

	for (i = 0; i < (int)vi->getStrokeCount(); i++) {

		if (!vi->inCurrentGroup(i))

			continue;

		TStroke *stroke = vi->getStroke(i);

		if (!m_invertOption.getValue()) {

			if ((!m_selective.getValue() || stroke->getStyle() == index) && rect.contains(stroke->getBBox())) {

				m_undo->addOldStroke(i, vi->getVIStroke(i));

				eraseStrokes.push_back(i);

			}

		} else {

			if ((!m_selective.getValue() || stroke->getStyle() == index) && !rect.contains(stroke->getBBox())) {

				m_undo->addOldStroke(i, vi->getVIStroke(i));

				eraseStrokes.push_back(i);

			}

		}

	}

	for (i = (int)eraseStrokes.size() - 1; i >= 0; i--)

		vi->deleteStroke(eraseStrokes[i]);

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

	m_undo = 0;

	invalidate();

}

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

void EraserTool::stopErase(TVectorImageP vi)

{

	assert(m_undo != 0);

	UINT size = m_indexes.size();

	assert(size == vi->getStrokeCount());

	UINT i = 0;

	for (; i < size; i++) {

		if (m_indexes[i] == -1)

			m_undo->addNewStroke(i, vi->getVIStroke(i));

	}

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

	m_undo = 0;

	invalidate();

	notifyImageChanged();

}

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

void EraserTool::leftButtonDown(const TPointD &pos, const TMouseEvent &e)

{

	m_brushPos = m_mousePos = pos;

	m_active = true;

	TImageP image(getImage(true));

	if (m_eraseType.getValue() == NORMAL_ERASE) {

		if (TVectorImageP vi = image)

			startErase(vi, pos /*,imageLocation*/);

	} else if (m_eraseType.getValue() == RECT_ERASE) {

		m_selectingRect.x0 = pos.x;

		m_selectingRect.y0 = pos.y;

		m_selectingRect.x1 = pos.x + 1;

		m_selectingRect.y1 = pos.y + 1;

		invalidate();

	} else if (m_eraseType.getValue() == FREEHAND_ERASE) {

		startFreehand(pos);

	} else if (m_eraseType.getValue() == POLYLINE_ERASE) {

		addPointPolyline(pos);

	}

}

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

void EraserTool::leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

{

	m_brushPos = m_mousePos = pos;

	if (!m_active)

		return;

	TImageP image(getImage(true));

	if (m_eraseType.getValue() == RECT_ERASE) {

		m_selectingRect.x1 = pos.x;

		m_selectingRect.y1 = pos.y;

		invalidate();

		return;

	} else if (m_eraseType.getValue() == NORMAL_ERASE) {

		if (TVectorImageP vi = image)

			erase(vi, pos);

	} else if (m_eraseType.getValue() == FREEHAND_ERASE) {

		freehandDrag(pos);

	}

}

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

void EraserTool::multiEraseRect(TFrameId firstFrameId, TFrameId lastFrameId,

								TRectD firstRect, TRectD lastRect, bool invert)

{

	int r0 = firstFrameId.getNumber();

	int r1 = lastFrameId.getNumber();

	if (r0 > r1) {

		tswap(r0, r1);

		tswap(firstFrameId, lastFrameId);

		tswap(firstRect, lastRect);

	}

	if ((r1 - r0) < 1)

		return;

	std::vector<tframeid> allFids;</tframeid>

	m_level->getFids(allFids);

	std::vector<tframeid>::iterator i0 = allFids.begin();</tframeid>

	while (i0 != allFids.end() && *i0 < firstFrameId)

		i0++;

	if (i0 == allFids.end())

		return;

	std::vector<tframeid>::iterator i1 = i0;</tframeid>

	while (i1 != allFids.end() && *i1 <= lastFrameId)

		i1++;

	assert(i0 < i1);

	std::vector<tframeid> fids(i0, i1);</tframeid>

	int m = fids.size();

	assert(m > 0);

	TUndoManager::manager()->beginBlock();

	for (int i = 0; i < m; ++i) {

		TFrameId fid = fids[i];

		assert(firstFrameId <= fid && fid <= lastFrameId);

		TVectorImageP img = (TVectorImageP)m_level->getFrame(fid, true);