// TnzTools includes

#include "tools/tool.h"

#include "tools/cursors.h"

#include "tools/toolcommandids.h"

#include "tools/toolutils.h"

#include "tools/toolutils.h"

#include "tools/toolhandle.h"

#include "historytypes.h"

// TnzLib includes

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tframehandle.h"

#include "toonz/ttileset.h"

#include "toonz/ttilesaver.h"

#include "toonz/trasterimageutils.h"

#include "toonz/stage2.h"

#include "toonz/levelproperties.h"

#include "toonz/strokegenerator.h"

// TnzBase includes

#include "tenv.h"

// TnzCore includes

#include "tproperty.h"

#include "trasterimage.h"

#include "bluredbrush.h"

#include "trop.h"

#include "tgl.h"

#include "tstroke.h"

#include "drawutil.h"

#include "tinbetween.h"

#include "tpixelutils.h"

// Qt includes

#include <qcoreapplication></qcoreapplication>

using namespace ToolUtils;

#define NORMALERASE L"Normal"

#define RECTERASE L"Rectangular"

#define FREEHANDERASE L"Freehand"

#define POLYLINEERASE L"Polyline"

TEnv::DoubleVar FullcolorEraseSize("FullcolorEraseSize", 5);

TEnv::DoubleVar FullcolorEraseHardness("FullcolorEraseHardness", 100);

TEnv::DoubleVar FullcolorEraserOpacity("FullcolorEraserOpacity", 100);

TEnv::StringVar FullcolorEraserType("FullcolorEraseType", "Normal");

TEnv::IntVar FullcolorEraserInvert("FullcolorEraseInvert", 0);

TEnv::IntVar FullcolorEraserRange("FullcolorEraseRange", 0);

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

//    Local namespace  stuff

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

namespace

{

int computeThickness(int pressure, const TIntPairProperty &property)

{

	double p = pressure / 255.0;

	double t = p * p * p;

	int thick0 = property.getValue().first;

	int thick1 = property.getValue().second;

	return tround(thick0 + (thick1 - thick0) * t);

}

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

void eraseImage(const TRasterImageP &ri, const TRaster32P &image, const TPoint &pos, bool invert)

{

	TRect rasBounds = ri->getRaster()->getBounds();

	TRect imageBounds = image->getBounds() + pos;

	if (invert) {

		TRect rect(imageBounds.x0, rasBounds.y0, rasBounds.x1, imageBounds.y0 - 1);

		TRasterImageUtils::eraseRect(ri, TRasterImageUtils::convertRasterToWorld(rect, ri));

		rect = TRect(imageBounds.x1 + 1, imageBounds.y0, rasBounds.x1, rasBounds.y1);

		TRasterImageUtils::eraseRect(ri, TRasterImageUtils::convertRasterToWorld(rect, ri));

		rect = TRect(rasBounds.x0, imageBounds.y1 + 1, imageBounds.x1, rasBounds.y1);

		TRasterImageUtils::eraseRect(ri, TRasterImageUtils::convertRasterToWorld(rect, ri));

		rect = TRect(rasBounds.x0, rasBounds.y0, imageBounds.x0 - 1, imageBounds.y1);

		TRasterImageUtils::eraseRect(ri, TRasterImageUtils::convertRasterToWorld(rect, ri));

	}

	TRaster32P workRas;

	if (TRasterGR8P ras = ri->getRaster()) {

		workRas = TRaster32P(imageBounds.getSize());

		TRop::convert(workRas, ras->extract(imageBounds));

	} else

		workRas = ri->getRaster()->extract(imageBounds);

	int y;

	for (y = 0; y < workRas->getLy(); y++) {

		TPixel32 *outPix = workRas->pixels(y);

		TPixel32 *outEndPix = outPix + workRas->getLx();

		TPixel32 *inPix = image->pixels(y);

		for (outPix; outPix != outEndPix; outPix++, inPix++) {

			if (outPix->m == 0)

				continue;

			TPixel32 pix = depremultiply(*outPix);

			pix.m = invert ? pix.m * (inPix->m) / 255 : pix.m * (255 - inPix->m) / 255;

			*outPix = premultiply(pix);

		}

	}

	if (TRasterGR8P ras = ri->getRaster()) {

		TRop::addBackground(workRas, TPixel32::White);

		TRop::over(ras, workRas, pos);

	}

}

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

class RectFullColorUndo : public TFullColorRasterUndo

{

	TRectD m_modifyArea;

	TStroke *m_stroke;

	std::wstring m_eraseType;

	bool m_invert;

public:

	RectFullColorUndo(TTileSetFullColor *tileSet, const TRectD &modifyArea, TStroke stroke,

					  std::wstring eraseType,

					  TXshSimpleLevel *level, bool invert,

					  const TFrameId &frameId)

		: TFullColorRasterUndo(tileSet, level, frameId, false, false, 0), m_modifyArea(modifyArea), m_eraseType(eraseType), m_invert(invert)

	{

		m_stroke = new TStroke(stroke);

	}

	~RectFullColorUndo()

	{

		delete m_stroke;

	}

	void redo() const

	{

		TRasterImageP ri = getImage();

		if (!ri)

			return;

		if (m_eraseType == RECTERASE)

			TRect rect = TRasterImageUtils::eraseRect(ri, m_modifyArea);

		else if (m_eraseType == FREEHANDERASE || m_eraseType == POLYLINEERASE) {

			TPoint pos;

			TRaster32P image = convertStrokeToImage(m_stroke, ri->getRaster()->getBounds(), pos);

			if (!image)

				return;

			eraseImage(ri, image, pos, m_invert);

		}

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

		notifyImageChanged();

	}

	int getSize() const

	{

		return TFullColorRasterUndo::getSize() +

			   m_stroke->getControlPointCount() * sizeof(TThickPoint) +

			   100 +

			   sizeof(this);

	}

	virtual QString getToolName()

	{

		return QString("Raster Eraser Tool (Rect)");

	}

	int getHistoryType()

	{

		return HistoryType::EraserTool;

	}

};

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

class FullColorEraserUndo : public TFullColorRasterUndo

{

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

	int m_size;

	double m_hardness;

	double m_opacity;

public:

	FullColorEraserUndo(TTileSetFullColor *tileSet,

						const std::vector<tthickpoint> &points,</tthickpoint>

						TXshSimpleLevel *level, const TFrameId &frameId,

						int size, double hardness, double opacity)

		: TFullColorRasterUndo(tileSet, level, frameId, false, false, 0), m_points(points), m_size(size), m_hardness(hardness), m_opacity(opacity) {}

	void redo() const

	{

		if (m_points.size() == 0)

			return;

		TRasterImageP image = getImage();

		TRasterP ras = image->getRaster();

		QRadialGradient brushPad = getBrushPad(m_size, m_hardness);

		TRaster32P workRaster = TRaster32P(ras->getSize());

		TRasterP backUpRas = ras->clone();

		workRaster->clear();

		BluredBrush brush(workRaster, m_size, brushPad, false);

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

		points.push_back(m_points[0]);

		TRect bbox = brush.getBoundFromPoints(points);

		brush.addPoint(m_points[0], 1);

		brush.eraseDrawing(ras, backUpRas, bbox, m_opacity);

		if (m_points.size() > 1) {

			points.clear();

			points.push_back(m_points[0]);

			points.push_back(m_points[1]);

			bbox = brush.getBoundFromPoints(points);

			brush.addArc(m_points[0], (m_points[1] + m_points[0]) * 0.5, m_points[1], 1, 1);

			brush.eraseDrawing(ras, backUpRas, bbox, m_opacity);

			int i;

			for (i = 1; i + 2 < (int)m_points.size(); i = i + 2) {

				points.clear();

				points.push_back(m_points[i]);

				points.push_back(m_points[i + 1]);

				points.push_back(m_points[i + 2]);

				bbox = brush.getBoundFromPoints(points);

				brush.addArc(m_points[i], m_points[i + 1], m_points[i + 2], 1, 1);

				brush.eraseDrawing(ras, backUpRas, bbox, m_opacity);

			}

		}

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

		notifyImageChanged();

	}

	int getSize() const

	{

		return sizeof(*this) + TFullColorRasterUndo::getSize();

	}

	virtual QString getToolName()

	{

		return QString("Raster Eraser Tool");

	}

	int getHistoryType()

	{

		return HistoryType::EraserTool;

	}

};

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

void eraseStroke(const TRasterImageP &ri, TStroke *stroke, std::wstring eraseType,

				 bool invert, const TXshSimpleLevelP &level, const TFrameId &frameId)

{

	assert(stroke);

	TPoint pos;

	TRasterP ras = ri->getRaster();

	TRaster32P image = convertStrokeToImage(stroke, ras->getBounds(), pos);

	if (!image)

		return;

	TRect rasterErasedArea = image->getBounds() + pos;

	TRect area;

	if (!invert)

		area = rasterErasedArea.enlarge(2);

	else

		area = ras->getBounds();

	TTileSetFullColor *tileSet = new TTileSetFullColor(ras->getSize());

	tileSet->add(ras, area);

	TUndoManager::manager()->add(new RectFullColorUndo(tileSet, convert(area), *stroke, eraseType, level.getPointer(),

													   invert, frameId));

	eraseImage(ri, image, pos, invert);

}

} // namespace

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

//    FullColorEraserTool  definition

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

class FullColorEraserTool : public TTool

{

	Q_DECLARE_TR_FUNCTIONS(FullColorEraserTool)

public:

	FullColorEraserTool(std::string name);

	~FullColorEraserTool();

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

	void updateTranslation();

	void onActivate();

	void onDeactivate();

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

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

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

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

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

	void draw();

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

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

	bool onPropertyChanged(std::string propertyName);

	void onImageChanged();

	void onEnter();

	void update(const TRasterImageP &ri, TRectD selArea, const TXshSimpleLevelP &level, bool multi = false,

				const TFrameId &frameId = -1);

	void multiUpdate(const TRectD firstRect, const TRectD lastRect);

	void multiAreaEraser(TFrameId &firstFid, TFrameId &lastFid,

						 TStroke *firstStroke, TStroke *lastStroke);

	void doMultiEraser(const TImageP &img, double t,

					   const TFrameId &fid,

					   const TVectorImageP &firstImage,

					   const TVectorImageP &lastImage);

	void resetMulti();

private:

	TPropertyGroup m_prop;

	TIntProperty m_size;

	TDoubleProperty m_opacity;

	TDoubleProperty m_hardness;

	TEnumProperty m_eraseType;

	TBoolProperty m_invertOption;

	TBoolProperty m_multi;

	TXshSimpleLevelP m_level;

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

	TFrameId m_firstFrameId,

		m_veryFirstFrameId;

	TRaster32P m_workRaster;

	TRasterP m_backUpRas;

	QRadialGradient m_brushPad;

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

	BluredBrush *m_brush;

	TTileSetFullColor *m_tileSet;

	TTileSaverFullColor *m_tileSaver;

	StrokeGenerator m_track;

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

	TStroke *m_firstStroke;

	TRectD m_selectingRect,

		m_firstRect;

	TPointD m_mousePos,

		m_brushPos,

		m_firstPos;

	double m_thick;

	bool m_firstTime,

		m_selecting,

		m_firstFrameSelected,

		m_isXsheetCell;

} fullColorEraser(T_Eraser); // Tools are statically instantiated

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

FullColorEraserTool::FullColorEraserTool(std::string name)

	: TTool(name), m_size("Size:", 1, 100, 5, false), m_opacity("Opacity:", 0, 100, 100), m_hardness("Hardness:", 0, 100, 100), m_eraseType("Type:"), m_invertOption("Invert", false), m_multi("Frame Range", false), m_currCell(-1, -1), m_brush(0), m_tileSet(0), m_tileSaver(0), m_thick(0.5), m_firstTime(true), m_selecting(false), m_firstFrameSelected(false), m_isXsheetCell(false)

{

	bind(TTool::RasterImage);

	m_prop.bind(m_size);

	m_prop.bind(m_hardness);

	m_prop.bind(m_opacity);

	m_prop.bind(m_eraseType);

	m_prop.bind(m_invertOption);

	m_prop.bind(m_multi);

	m_eraseType.addValue(NORMALERASE);

	m_eraseType.addValue(RECTERASE);

	m_eraseType.addValue(FREEHANDERASE);

	m_eraseType.addValue(POLYLINEERASE);

}

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

FullColorEraserTool::~FullColorEraserTool()

{

	delete m_firstStroke;

}

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

void FullColorEraserTool::updateTranslation()

{

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

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

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

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

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

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

}

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

void FullColorEraserTool::onActivate()

{

	if (m_firstTime) {

		m_firstTime = false;

		m_size.setValue(FullcolorEraseSize);

		m_opacity.setValue(FullcolorEraserOpacity);

		m_hardness.setValue(FullcolorEraseHardness);

		m_eraseType.setValue(toWideString(FullcolorEraserType.getValue()));

		m_invertOption.setValue((bool)FullcolorEraserInvert);

		m_multi.setValue((bool)FullcolorEraserRange);

		m_firstTime = false;

	}

	m_brushPad = getBrushPad(m_size.getValue(), m_hardness.getValue() * 0.01);

}

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

void FullColorEraserTool::onDeactivate()

{

}

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

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

{

	m_brushPos = m_mousePos = pos;

	TRasterImageP ri = (TRasterImageP)getImage(true);

	if (!ri)

		return;

	TRectD invalidateRect;

	TRasterP ras = ri->getRaster();

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

		TDimension dim = ras->getSize();

		double opacity = m_opacity.getValue() * 0.01;

		double hardness = m_hardness.getValue() * 0.01;

		m_workRaster = TRaster32P(dim);

		m_workRaster->clear();

		m_backUpRas = ras->clone();

		int maxThick = m_size.getValue();

		TPointD rasCenter = ras->getCenterD();

		TThickPoint point(pos + rasCenter, maxThick);

		TPointD halfThick(maxThick * 0.5, maxThick * 0.5);

		invalidateRect = TRectD(pos - halfThick, pos + halfThick);

		m_points.clear();

		m_points.push_back(point);

		m_tileSet = new TTileSetFullColor(ras->getSize());

		m_tileSaver = new TTileSaverFullColor(ras, m_tileSet);

		m_brush = new BluredBrush(m_workRaster, m_size.getValue(), m_brushPad, false);

		TRect bbox = m_brush->getBoundFromPoints(m_points);

		m_tileSaver->save(bbox);

		m_brush->addPoint(point, 1);

		m_brush->eraseDrawing(ras, m_backUpRas, bbox, opacity);

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

		if (m_multi.getValue() && m_firstRect.isEmpty()) {

			invalidateRect = m_selectingRect;

			m_selectingRect.empty();

			invalidate(invalidateRect.enlarge(2));

		}

		m_selecting = true;

		m_selectingRect.x0 = pos.x;

		m_selectingRect.y0 = pos.y;

		m_selectingRect.x1 = pos.x + 1;

		m_selectingRect.y1 = pos.y + 1;

		invalidateRect = m_selectingRect;

	} else if (m_eraseType.getValue() == FREEHANDERASE || m_eraseType.getValue() == POLYLINEERASE) {

		if (m_multi.getValue() && m_firstStroke && !m_firstFrameSelected) {

			invalidateRect = m_firstStroke->getBBox();

			delete m_firstStroke;

			m_firstStroke = 0;

			invalidate(invalidateRect.enlarge(2));

		}

		m_track.clear();

		m_firstPos = pos;

		double pixelSize2 = getPixelSize() * getPixelSize();

		m_track.add(TThickPoint(pos, m_thick), pixelSize2);

		TPointD dpiScale = m_viewer->getDpiScale();

		TPixel color = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg ? TPixel32::White : TPixel32::Black;

		tglColor(color);

		getViewer()->startForegroundDrawing();

		glPushMatrix();

		glScaled(dpiScale.x, dpiScale.y, 1);

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

			if (m_polyline.empty() || m_polyline.back() != pos)

				m_polyline.push_back(pos);

		} else

			m_track.drawLastFragments();

		glPopMatrix();

		getViewer()->endForegroundDrawing();

		int maxThick = 2 * m_thick;

		TPointD halfThick(maxThick * 0.5, maxThick * 0.5);

		invalidateRect = TRectD(pos - halfThick, pos + halfThick);

	}

	invalidate(invalidateRect.enlarge(2));

}

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

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

{

	m_brushPos = m_mousePos = pos;

	double pixelSize2 = getPixelSize() * getPixelSize();

	TRasterImageP ri = (TRasterImageP)getImage(true);

	if (!ri)

		return;

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

		double thickness = m_size.getValue();

		TDimension size = m_workRaster->getSize();

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

		TThickPoint point(pos + rasCenter, thickness);

		TThickPoint old = m_points.back();

		if (norm2(point - old) < 4)

			return;

		TThickPoint mid((old + point) * 0.5, (point.thick + old.thick) * 0.5);

		m_points.push_back(mid);

		m_points.push_back(point);

		int m = m_points.size();

		double opacity = m_opacity.getValue() * 0.01;

		TThickPoint pa = m_points.front();

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

		points.push_back(pa);

		points.push_back(mid);

		TRect bbox;

		TRectD invalidateRect;

		if (m == 3) {

			TThickPoint pa = m_points.front();

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

			points.push_back(pa);

			points.push_back(mid);

			invalidateRect = ToolUtils::getBounds(points, thickness);

			bbox = m_brush->getBoundFromPoints(points);

			m_tileSaver->save(bbox);

			m_brush->addArc(pa, (mid + pa) * 0.5, mid, 1, 1);

		} else {

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

			points.push_back(m_points[m - 4]);

			points.push_back(old);

			points.push_back(mid);

			invalidateRect = ToolUtils::getBounds(points, thickness);

			bbox = m_brush->getBoundFromPoints(points);

			m_tileSaver->save(bbox);

			m_brush->addArc(m_points[m - 4], old, mid, 1, 1);

		}

		m_brush->eraseDrawing(ri->getRaster(), m_backUpRas, bbox, opacity);

		invalidate(invalidateRect.enlarge(2) - rasCenter);

	}

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

		assert(m_selecting);

		TRectD oldRect = m_selectingRect;

		if (oldRect.x0 > oldRect.x1)

			tswap(oldRect.x1, oldRect.x0);

		if (oldRect.y0 > oldRect.y1)

			tswap(oldRect.y1, oldRect.y0);

		m_selectingRect.x1 = pos.x;

		m_selectingRect.y1 = pos.y;

		TRectD invalidateRect(m_selectingRect);

		if (invalidateRect.x0 > invalidateRect.x1)

			tswap(invalidateRect.x1, invalidateRect.x0);

		if (invalidateRect.y0 > invalidateRect.y1)

			tswap(invalidateRect.y1, invalidateRect.y0);

		invalidateRect += oldRect;

		invalidate(invalidateRect.enlarge(2));

	}

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

		getViewer()->startForegroundDrawing();

		TPixel color = ToonzCheck::instance()->getChecks() & ToonzCheck::eBlackBg ? TPixel32::White : TPixel32::Black;

		tglColor(color);

		glPushMatrix();

		tglMultMatrix(getMatrix());

		TPointD dpiScale = m_viewer->getDpiScale();

		glScaled(dpiScale.x, dpiScale.y, 1);

		m_track.add(TThickPoint(pos, m_thick), pixelSize2);

		m_track.drawLastFragments();

		glPopMatrix();

		getViewer()->endForegroundDrawing();

	}

}

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

void FullColorEraserTool::leftButtonUp(const TPointD &pos, const TMouseEvent &e)

{

	m_brushPos = m_mousePos = pos;

	TRasterImageP ri = (TRasterImageP)getImage(true);

	if (!ri)

		return;

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

		if (m_points.size() != 1) {

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

			TThickPoint point(pos + rasCenter, m_size.getValue());

			m_points.push_back(point);

			int m = m_points.size();

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

			points.push_back(m_points[m - 3]);

			points.push_back(m_points[m - 2]);

			points.push_back(m_points[m - 1]);

			TRect bbox = m_brush->getBoundFromPoints(points);

			m_tileSaver->save(bbox);

			m_brush->addArc(points[0], points[1], points[2], 1, 1);

			double opacity = m_opacity.getValue() * 0.01;

			m_brush->eraseDrawing(ri->getRaster(), m_backUpRas, bbox, opacity);

			TRectD invalidateRect = ToolUtils::getBounds(points, m_size.getValue());

			invalidate(invalidateRect.enlarge(2) - rasCenter);

		}

		if (m_brush) {

			delete m_brush;

			m_brush = 0;

		}

		m_workRaster->unlock();

		double opacity = m_opacity.getValue() * 0.01;

		double hardness = m_hardness.getValue() * 0.01;

		m_workRaster = TRaster32P();

		m_backUpRas = TRaster32P();

		delete m_tileSaver;

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

		TXshLevel *level = app->getCurrentLevel()->getLevel();

		TXshSimpleLevelP simLevel = level->getSimpleLevel();

		TFrameId frameId = getCurrentFid();

		TUndoManager::manager()->add(new FullColorEraserUndo(m_tileSet, m_points, simLevel.getPointer(),

															 frameId, m_size.getValue(), m_hardness.getValue() * 0.01, opacity));

		notifyImageChanged();

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

		if (m_selectingRect.x0 > m_selectingRect.x1)

			tswap(m_selectingRect.x1, m_selectingRect.x0);

		if (m_selectingRect.y0 > m_selectingRect.y1)

			tswap(m_selectingRect.y1, m_selectingRect.y0);

		if (m_multi.getValue()) {

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

			if (m_firstFrameSelected) {

				multiUpdate(m_firstRect, m_selectingRect);

				notifyImageChanged();

				if (e.isShiftPressed()) {

					m_firstRect = m_selectingRect;

					m_firstFrameId = getFrameId();

					invalidate();

				} else {

					if (m_isXsheetCell) {

						app->getCurrentColumn()->setColumnIndex(m_currCell.first);

						app->getCurrentFrame()->setFrame(m_currCell.second);

					} else

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

					resetMulti();

				}

			} else {

				m_isXsheetCell = app->getCurrentFrame()->isEditingScene();

				m_currCell = std::pair<int, int="">(getColumnIndex(), getFrame());</int,>

			}

		} else {

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

			TXshLevel *level = app->getCurrentLevel()->getLevel();

			TXshSimpleLevelP simLevel = level->getSimpleLevel();

			TFrameId frameId = getCurrentFid();

			if (m_invertOption.getValue()) {

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

				TRect rect = TRasterImageUtils::convertWorldToRaster(m_selectingRect, ri);

				rect *= ri->getSavebox();

				TDimension dim = ri->getRaster()->getSize();

				TRectD rect01 = TRectD(TPointD(0., 0.), TPointD((double)rect.x0, (double)dim.ly));

				if (rect01.getLx() > 0 && rect01.getLy() > 0) {

					rect01 = TRasterImageUtils::convertRasterToWorld(convert(rect01), ri);

					update(ri, rect01, simLevel, false, frameId);

				}

				TRectD rect02 = TRectD(convert(rect.getP01()), TPointD((double)rect.x1, (double)dim.ly));

				if (rect02.getLx() > 0 && rect02.getLy() > 0) {

					rect02 = TRasterImageUtils::convertRasterToWorld(convert(rect02), ri);

					update(ri, rect02, simLevel, false, frameId);

				}

				TRectD rect03 = TRectD(TPointD((double)rect.x0, 0.), convert(rect.getP10()));

				if (rect03.getLx() > 0 && rect03.getLy() > 0) {

					rect03 = TRasterImageUtils::convertRasterToWorld(convert(rect03), ri);

					update(ri, rect03, simLevel, false, frameId);

				}

				TRectD rect04 = TRectD(TPointD((double)rect.x1, 0.), TPointD((double)dim.lx, (double)dim.ly));

				if (rect04.getLx() > 0 && rect04.getLy() > 0) {

					rect04 = TRasterImageUtils::convertRasterToWorld(convert(rect04), ri);

					update(ri, rect04, simLevel, false, frameId);

				}

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

				invalidate();

			} else {

				update(ri, m_selectingRect, simLevel, false, frameId);

				invalidate(m_selectingRect.enlarge(2));

			}

			m_selectingRect.empty();

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

			m_selecting = false;

			notifyImageChanged();

		}

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

		if (m_track.isEmpty())

			return;

		double pixelSize2 = getPixelSize() * getPixelSize();

		m_track.add(TThickPoint(pos, m_thick), pixelSize2);

		m_track.add(TThickPoint(m_firstPos, m_thick), pixelSize2);

		getViewer()->startForegroundDrawing();

		m_track.drawLastFragments();

		getViewer()->endForegroundDrawing();

		m_track.filterPoints();

		double error = (30.0 / 11) * sqrt(pixelSize2);

		TStroke *stroke = m_track.makeStroke(error);

		stroke->setStyle(1);

		m_track.clear();

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

		if (m_multi.getValue()) //stroke multi

		{

			if (m_firstFrameSelected) {

				TFrameId tmp = getCurrentFid();

				if (m_firstStroke && stroke)

					multiAreaEraser(m_firstFrameId, tmp, m_firstStroke, stroke);

				notifyImageChanged();

				if (e.isShiftPressed()) {

					TRectD invalidateRect = m_firstStroke->getBBox();

					delete m_firstStroke;

					m_firstStroke = 0;

					invalidate(invalidateRect.enlarge(2));

					m_firstStroke = stroke;

					invalidateRect = m_firstStroke->getBBox();

					invalidate(invalidateRect.enlarge(2));

					m_firstFrameId = getFrameId();

				} else {

					if (m_isXsheetCell) {

						app->getCurrentColumn()->setColumnIndex(m_currCell.first);

						app->getCurrentFrame()->setFrame(m_currCell.second);

					} else

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

					resetMulti();

					delete stroke;

				}

			} else //primo frame

			{

				m_firstStroke = stroke;

				m_isXsheetCell = app->getCurrentFrame()->isEditingScene();

				m_currCell = std::pair<int, int="">(getColumnIndex(), getFrame());</int,>

				invalidate(m_firstStroke->getBBox().enlarge(2));

			}

		} else //stroke non multi

		{

			if (!getImage(true))

				return;

			TFrameId frameId = getCurrentFid();

			eraseStroke(ri, stroke, m_eraseType.getValue(),

						m_invertOption.getValue(), /*m_multi.getValue(),*/ m_level,

						frameId);

			notifyImageChanged();

			if (m_invertOption.getValue())

				invalidate();

			else

				invalidate(stroke->getBBox().enlarge(2));

		}

	}

}

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

void FullColorEraserTool::leftButtonDoubleClick(const TPointD &pos, const TMouseEvent &e)

{

	TRasterImageP ri(getImage(true));

	if (!ri)

		return;

	TStroke *stroke;

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

	if (m_polyline.size() <= 1) {

		resetMulti();

		return;

	}

	if (m_polyline.back() != pos)

		m_polyline.push_back(pos);

	if (m_polyline.back() != m_polyline.front())

		m_polyline.push_back(m_polyline.front());

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

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

		strokePoints.push_back(TThickPoint(m_polyline[i], 1));

		strokePoints.push_back(TThickPoint(0.5 * (m_polyline[i] + m_polyline[i + 1]), 1));

	}

	strokePoints.push_back(TThickPoint(m_polyline.back(), 1));

	m_polyline.clear();

	stroke = new TStroke(strokePoints);

	assert(stroke->getPoint(0) == stroke->getPoint(1));

	if (m_multi.getValue()) //stroke multi

	{

		if (m_firstFrameSelected) {

			TFrameId tmp = getFrameId();

			if (m_firstStroke && stroke)

				multiAreaEraser(m_firstFrameId, tmp, m_firstStroke, stroke);

			if (e.isShiftPressed()) {

				TRectD invalidateRect = m_firstStroke->getBBox();

				delete m_firstStroke;

				m_firstStroke = 0;

				invalidate(invalidateRect.enlarge(2));

				m_firstStroke = stroke;

				invalidateRect = m_firstStroke->getBBox();

				invalidate(invalidateRect.enlarge(2));

				m_firstFrameId = getFrameId();

			} else {

				if (m_isXsheetCell) {

					app->getCurrentColumn()->setColumnIndex(m_currCell.first);

					app->getCurrentFrame()->setFrame(m_currCell.second);

				} else

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

				resetMulti();

				delete stroke;

			}

		} else //primo frame

		{

			m_firstStroke = stroke;

			m_isXsheetCell = app->getCurrentFrame()->isEditingScene();

			m_currCell = std::pair<int, int="">(getColumnIndex(), getFrame());</int,>

			invalidate(m_firstStroke->getBBox().enlarge(2));

		}

	} else {

		if (!getImage(true))

			return;

		TXshLevel *level = app->getCurrentLevel()->getLevel();

		TXshSimpleLevelP simLevel = level->getSimpleLevel();

		TFrameId frameId = getFrameId();

		eraseStroke(ri, stroke, m_eraseType.getValue(),

					m_invertOption.getValue(), /*m_multi.getValue(),*/ m_level, frameId);

		notifyImageChanged();

		if (m_invertOption.getValue())

			invalidate();

		else

			invalidate(stroke->getBBox().enlarge(2));

	}

}

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

void FullColorEraserTool::mouseMove(const TPointD &pos, const TMouseEvent &e)

{

	struct Locals {

		FullColorEraserTool *m_this;