#include "tools/toolutils.h"

#include "tools/toolhandle.h"

#include "toonzqt/imageutils.h"

#include "trop.h"

#include "tools/tool.h"

#include "tstroke.h"

#include "timageinfo.h"

#include "timagecache.h"

#include "tgl.h"

#include "toonz/txsheethandle.h"

#include "toonz/tframehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/txshleveltypes.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tpalettehandle.h"

#include "toonz/txshlevel.h"

#include "toonz/txshcell.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/imagemanager.h"

#include "toonz/ttileset.h"

#include "toonz/toonzimageutils.h"

#include "toonz/levelproperties.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tstageobject.h"

#include "toonz/trasterimageutils.h"

#include "toonz/levelset.h"

#include "toonz/toonzscene.h"

#include "toonz/preferences.h"

#include "toonz/palettecontroller.h"

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/icongenerator.h"

#include "toonzqt/selection.h"

#include "toonzqt/gutil.h"

#include "tools/strokeselection.h"

#include <qpainter></qpainter>

#include <qglwidget> // for QGLWidget::convertToGLFormat</qglwidget>

#include <qfont></qfont>

#include <qfontmetrics></qfontmetrics>

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

//    Local namespace

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

namespace

{

//!Riempie il vettore \b theVect con gli indici degli stroke contenuti nel mapping \b theMap.

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;

	}

}

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

void updateSaveBox(const TToonzImageP &ti)

{

	if (ti) {

		assert(ti->getRaster());		   // Image should have a raster

		assert(ti->getSubsampling() == 1); // Image should not be subsampled - modified images must be the ORIGINAL ones

		const TRect &savebox = ti->getSavebox();

		{

			TRect newSaveBox;

			TRop::computeBBox(ti->getRaster(), newSaveBox); // This iterates the WHOLE raster to find its new savebox!

			if (!Preferences::instance()->isMinimizeSaveboxAfterEditing())

				newSaveBox += savebox; // If not minimizing the savebox, it cannot be shrunk.

			ti->setSavebox(newSaveBox);

		}

	}

}

} //namespace

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

//    ToolUtils namespace

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

void ToolUtils::updateSaveBox(const TXshSimpleLevelP &sl, const TFrameId &fid)

{

	// TODO: Savebox updates should not happen on mouse updates. This is, unfortunately, what currently happens.

	sl->setDirtyFlag(true);

	TImageP img = sl->getFrame(fid, true); // The image will be modified (it should already have been, though)

										   // Observe that the returned image will forcedly have subsampling 1

	::updateSaveBox(img);

	TImageInfo *info = sl->getFrameInfo(fid, true);

	ImageBuilder::setImageInfo(*info, img.getPointer());

}

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

void ToolUtils::updateSaveBox(const TXshSimpleLevelP &sl, const TFrameId &fid, TImageP img)

{

	sl->setFrame(fid, img);

	ToolUtils::updateSaveBox(sl, fid);

}

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

void ToolUtils::updateSaveBox()

{

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

	if (!application)

		return;

	TXshLevel *xl = application->getCurrentLevel()->getLevel();

	if (!xl)

		return;

	TXshSimpleLevel *sl = xl->getSimpleLevel();

	if (!sl || sl->getType() != TZP_XSHLEVEL)

		return;

	TFrameId fid = getFrameId();

	ToolUtils::updateSaveBox(sl, fid);

}

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

//! Return the right value in both case: LevelFrame and SceneFrame.

TFrameId ToolUtils::getFrameId()

{

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

	if (!app)

		return TFrameId();

	TFrameHandle *frameHandle = app->getCurrentFrame();

	if (frameHandle->isEditingScene()) {

		TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

		if (!xsh)

			return 0;

		int row = frameHandle->getFrame();

		int col = app->getCurrentColumn()->getColumnIndex();

		if (col < 0)

			return 0;

		TXshCell cell = xsh->getCell(row, col);

		return cell.getFrameId();

	} else

		return frameHandle->getFid();

}

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

void ToolUtils::drawRect(const TRectD &rect, const TPixel32 &color, unsigned short stipple, bool doContrast)

{

	GLint src, dst;

	bool isEnabled;

	tglColor(color);

	if (doContrast) {

		if (color == TPixel32::Black)

			tglColor(TPixel32(90, 90, 90));

		isEnabled = glIsEnabled(GL_BLEND);

		glGetIntegerv(GL_BLEND_SRC, &src);

		glGetIntegerv(GL_BLEND_DST, &dst);

		glEnable(GL_BLEND);

		glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA);

	}

	if (stipple != 0xffff) {

		glLineStipple(1, stipple);

		glEnable(GL_LINE_STIPPLE);

	}

	glBegin(GL_LINE_STRIP);

	tglVertex(rect.getP00());

	tglVertex(rect.getP01());

	tglVertex(rect.getP11());

	tglVertex(rect.getP10());

	tglVertex(rect.getP00());

	glEnd();

	glDisable(GL_LINE_STIPPLE);

	if (doContrast) {

		if (!isEnabled)

			glDisable(GL_BLEND);

		glBlendFunc(src, dst);

	}

}

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

void ToolUtils::fillRect(const TRectD &rect, const TPixel32 &color)

{

	tglColor(color);

	glBegin(GL_QUADS);

	tglVertex(rect.getP00());

	tglVertex(rect.getP01());

	tglVertex(rect.getP11());

	tglVertex(rect.getP10());

	tglVertex(rect.getP00());

	glEnd();

}

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

void ToolUtils::drawPoint(const TPointD &q, double pixelSize)

{

	double size = pixelSize * 2.0;

	glBegin(GL_QUADS);

	glVertex2d(q.x - size, q.y - size);

	glVertex2d(q.x - size, q.y + size);

	glVertex2d(q.x + size, q.y + size);

	glVertex2d(q.x + size, q.y - size);

	glEnd();

}

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

void ToolUtils::drawCross(const TPointD &q, double pixelSize)

{

	double size = pixelSize;

	glBegin(GL_LINES);

	glVertex2d(q.x - size, q.y);

	glVertex2d(q.x + size, q.y);

	glEnd();

	glBegin(GL_LINES);

	glVertex2d(q.x, q.y - size);

	glVertex2d(q.x, q.y + size);

	glEnd();

}

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

void ToolUtils::drawArrow(const TSegment &s, double pixelSize)

{

	TPointD v, vn;

	double length = s.getLength() * pixelSize;

	if (length == 0)

		return;

	v = normalize(s.getSpeed());

	vn = v;

	TPointD p1 = s.getP0() + v * length;

	glBegin(GL_LINES);

	tglVertex(s.getP0());

	tglVertex(p1);

	glEnd();

	v = v * length * 0.7;

	vn = vn * length * 0.2;

	TPointD p;

	glBegin(GL_TRIANGLES);

	p = s.getP0() + v + rotate90(vn);

	tglVertex(p);

	tglVertex(p1);

	p = s.getP0() + v + rotate270(vn);

	tglVertex(p);

	glEnd();

}

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

void ToolUtils::drawSquare(const TPointD &pos, double r, const TPixel32 &color)

{

	TRectD rect(pos - TPointD(r, r), pos + TPointD(r, r));

	tglColor(color);

	glBegin(GL_LINE_STRIP);

	tglVertex(rect.getP00());

	tglVertex(rect.getP01());

	tglVertex(rect.getP11());

	tglVertex(rect.getP10());

	tglVertex(rect.getP00());

	glEnd();

}

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

void ToolUtils::drawRectWhitArrow(const TPointD &pos, double r)

{

	if (TTool::getApplication()->getCurrentObject()->isSpline())

		return;

	TRectD rect(pos - TPointD(14 * r, 2 * r), pos + TPointD(14 * r, 2 * r));

	tglColor(TPixel32::Black);

	glBegin(GL_POLYGON);

	tglVertex(rect.getP00());

	tglVertex(rect.getP10());

	tglVertex(rect.getP11());

	tglVertex(rect.getP01());

	glEnd();

	double par = 5 * r;

	TPointD p01 = 0.5 * (rect.getP00() + rect.getP10());

	TPointD p02 = 0.5 * (rect.getP01() + rect.getP11());

	TPointD p11 = TPointD(p01.x, p01.y - par);

	TPointD p12 = TPointD(p02.x, p02.y + par);

	TPointD p;

	tglColor(TPixel32(130, 130, 130));

	glBegin(GL_TRIANGLES);

	p = p11 + rotate90(TPointD(0, par));

	tglVertex(p);

	tglVertex(p01);

	p = p11 + rotate270(TPointD(0, par));

	tglVertex(p);

	glEnd();

	glBegin(GL_TRIANGLES);

	p = p12 + rotate90(TPointD(0, -par));

	tglVertex(p);

	tglVertex(p02);

	p = p12 + rotate270(TPointD(0, -par));

	tglVertex(p);

	glEnd();

}

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

QRadialGradient ToolUtils::getBrushPad(int size, double hardness)

{

	hardness = tcrop(hardness, 0.0, 0.97);

	double halfSize = size * 0.5;

	double x = halfSize * hardness;

	TQuadratic q(TPointD(x, 1.0), TPointD((halfSize + x) * 0.5, 0.0), TPointD(halfSize, 0.0));

	QRadialGradient rd(QPointF(halfSize, halfSize), halfSize, QPointF(halfSize, halfSize));

	rd.setColorAt(0, QColor(0, 0, 0));

	double t;

	double offset = halfSize - x;

	assert(offset > 0);

	for (t = 0; t <= 1; t += 1.0 / offset) {

		TPointD p = q.getPoint(t);

		int value = 255 * p.y;

		rd.setColorAt(p.x / halfSize, QColor(0, 0, 0, value));

	}

	return rd;

}

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

QList<trect> ToolUtils::splitRect(const TRect &first, const TRect &second)</trect>

{

	TRect intersection = first * second;

	QList<trect> rects;</trect>

	if (intersection.isEmpty()) {

		rects.append(first);

		return rects;

	}

	TRect rect;

	if (first.x0 < intersection.x0) {

		rect = TRect(first.getP00(), TPoint(intersection.x0 - 1, first.y1));

		rects.append(rect);

	}

	if (intersection.x1 < first.x1) {

		rect = TRect(TPoint(intersection.x1 + 1, first.y0), first.getP11());

		rects.append(rect);

	}

	if (intersection.y1 < first.y1) {

		rect = TRect(intersection.x0, intersection.y1 + 1, intersection.x1, first.y1);

		rects.append(rect);

	}

	if (first.y0 < intersection.y0) {

		rect = TRect(intersection.x0, first.y0, intersection.x1, intersection.y0 - 1);

		rects.append(rect);

	}

	return rects;

}

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

TRaster32P ToolUtils::convertStrokeToImage(TStroke *stroke, const TRect &imageBounds, TPoint &pos)

{

	int count = stroke->getControlPointCount();

	if (count == 0)

		return TRaster32P();

	TPointD imgCenter = TPointD((imageBounds.x0 + imageBounds.x1) * 0.5, (imageBounds.y0 + imageBounds.y1) * 0.5);

	TStroke s(*stroke);

	//check self looped stroke

	TThickPoint first = s.getControlPoint(0);

	TThickPoint back = s.getControlPoint(count - 1);

	if (first != back) {

		TPointD mid = (first + back) * 0.5;

		s.setControlPoint(count, mid);

		s.setControlPoint(count + 1, first);

	}

	//check bounds intersection

	s.transform(TTranslation(imgCenter));

	TRectD bbox = s.getBBox();

	TRect rect(tfloor(bbox.x0), tfloor(bbox.y0), tfloor(bbox.x1), tfloor(bbox.y1));

	pos = rect.getP00();

	pos = TPoint(pos.x > 0 ? pos.x : 0, pos.y > 0 ? pos.y : 0);

	rect *= imageBounds;

	if (rect.isEmpty())

		return TRaster32P();

	//creates the image

	QImage img(rect.getLx(), rect.getLy(), QImage::Format_ARGB32);

	img.fill(Qt::transparent);

	QColor color = Qt::black;

	QPainter p(&img);

	p.setPen(QPen(color, 1, Qt::SolidLine));

	p.setBrush(color);

	p.setRenderHint(QPainter::Antialiasing, true);

	QPainterPath path = strokeToPainterPath(&s);

	QRectF pathRect = path.boundingRect();

	p.translate(-toQPoint(pos));

	p.drawPath(path);

	return rasterFromQImage(img, true, false);

}

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

TStroke *ToolUtils::merge(const ArrayOfStroke &a)

{

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

	TStroke *ref = 0;

	int controlPoints = 0;

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

		ref = a[i];

		assert(ref);

		if (!ref)

			continue;

		controlPoints = ref->getControlPointCount() - 1;

		for (int j = 0; j < controlPoints; ++j)

			v.push_back(ref->getControlPoint(j));

	}

	if (controlPoints > 0)

		v.push_back(ref->getControlPoint(controlPoints));

	TStroke *out = new TStroke(v);

	return out;

}

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

//

//TToolUndo

//

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

ToolUtils::TToolUndo::TToolUndo(TXshSimpleLevel *level, const TFrameId &frameId,

								bool createdFrame, bool createdLevel, const TPaletteP &oldPalette)

	: TUndo(), m_level(level), m_frameId(frameId), m_oldPalette(oldPalette), m_col(-2), m_row(-1), m_isEditingLevel(false), m_createdFrame(createdFrame), m_createdLevel(createdLevel), m_imageId("")

{

	m_animationSheetEnabled = Preferences::instance()->isAnimationSheetEnabled();

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

	m_isEditingLevel = app->getCurrentFrame()->isEditingLevel();

	if (!m_isEditingLevel) {

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

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

		if (m_animationSheetEnabled) {

			m_cellsData = TTool::m_cellsData;

		}

	}

	if (createdFrame) {

		m_imageId = "TToolUndo" + toString(m_idCount++);

		TImageCache::instance()->add(m_imageId, level->getFrame(frameId, false), false);

	}

}

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

ToolUtils::TToolUndo::~TToolUndo()

{

	TImageCache::instance()->remove(m_imageId);

}

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

void ToolUtils::TToolUndo::insertLevelAndFrameIfNeeded() const

{

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

	if (m_createdLevel) {

		TLevelSet *levelSet = app->getCurrentScene()->getScene()->getLevelSet();

		if (levelSet) {

			levelSet->insertLevel(m_level.getPointer());

			app->getCurrentScene()->notifyCastChange();

		}

	}

	if (m_createdFrame) {

		TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

		TImageP img = TImageCache::instance()->get(m_imageId, false);

		m_level->setFrame(m_frameId, img);

		if (!m_isEditingLevel) {

			if (m_animationSheetEnabled) {

				int m = m_cellsData.size() / 3;

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

					int r0 = m_cellsData[i * 3];

					int r1 = m_cellsData[i * 3 + 1];

					int type = m_cellsData[i * 3 + 2];

					TXshCell cell;

					if (type == 1)

						cell = xsh->getCell(r0 - 1, m_col);

					else

						cell = TXshCell(m_level.getPointer(), m_frameId);

					for (int r = r0; r <= r1; r++)

						xsh->setCell(r, m_col, cell);

				}

			} else {

				TXshCell cell(m_level.getPointer(), m_frameId);

				xsh->setCell(m_row, m_col, cell);

			}

		}

		app->getCurrentLevel()->notifyLevelChange();

	}

}

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

void ToolUtils::TToolUndo::removeLevelAndFrameIfNeeded() const

{

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

	if (m_createdFrame) {

		m_level->eraseFrame(m_frameId);

		if (!m_isEditingLevel) {

			TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

			if (m_animationSheetEnabled) {

				int m = m_cellsData.size() / 3;

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

					int r0 = m_cellsData[i * 3];

					int r1 = m_cellsData[i * 3 + 1];

					int type = m_cellsData[i * 3 + 2];

					TXshCell cell;

					if (type == 0)

						cell = xsh->getCell(r0 - 1, m_col);

					for (int r = r0; r <= r1; r++)

						xsh->setCell(r, m_col, cell);

				}

			} else {

				xsh->clearCells(m_row, m_col);

			}

		}

		if (m_createdLevel) {

			// butta il livello

			TLevelSet *levelSet = app->getCurrentScene()->getScene()->getLevelSet();

			if (levelSet) {

				levelSet->removeLevel(m_level.getPointer());

				app->getCurrentScene()->notifyCastChange();

			}

		}

		app->getCurrentLevel()->notifyLevelChange();

	}

	if (m_oldPalette.getPointer()) {

		m_level->getPalette()->assign(m_oldPalette->clone());

		app->getPaletteController()->getCurrentLevelPalette()->notifyPaletteChanged();

	}

}

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

void ToolUtils::TToolUndo::notifyImageChanged() const

{

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

	TXshSimpleLevel *currentSl = 0;

	TFrameId currentFrameId;

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

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

		if (!xl)

			return;

		currentSl = xl->getSimpleLevel();

		currentFrameId = app->getCurrentFrame()->getFid();

	} else {

		int row = app->getCurrentFrame()->getFrame();

		int col = app->getCurrentColumn()->getColumnIndex();

		if (col < 0)

			return;

		TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

		if (!xsh)

			return;

		TXshCell cell = xsh->getCell(row, col);

		currentSl = cell.getSimpleLevel();

		currentFrameId = cell.getFrameId();

	}

	if (currentSl == m_level.getPointer() && currentFrameId == m_frameId) {

		TTool *tool = app->getCurrentTool()->getTool();

		if (tool)

			tool->onImageChanged();

	}

	IconGenerator::instance()->invalidate(m_level.getPointer(), m_frameId);

	IconGenerator::instance()->invalidateSceneIcon();

	if (m_level && m_level->getType() == PLI_XSHLEVEL) {

		std::string id = m_level->getImageId(m_frameId) + "_rasterized";

		ImageManager::instance()->invalidate(id);

	}

}

int ToolUtils::TToolUndo::m_idCount = 0;

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

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

ToolUtils::TRasterUndo::TRasterUndo(TTileSetCM32 *tiles, TXshSimpleLevel *level, const TFrameId &frameId,

									bool createdFrame, bool createdLevel, const TPaletteP &oldPalette)

	: TToolUndo(level, frameId, createdFrame, createdLevel, oldPalette), m_tiles(tiles)

{

}

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

ToolUtils::TRasterUndo::~TRasterUndo()

{

	if (m_tiles)

		delete m_tiles;

}

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

TToonzImageP ToolUtils::TRasterUndo::getImage() const

{

	if (m_level->isFid(m_frameId))

		return (TToonzImageP)m_level->getFrame(m_frameId, true);

	return 0;

}

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

int ToolUtils::TRasterUndo::getSize() const

{

	int size = sizeof(*this);

	size += sizeof(*(m_level.getPointer()));

	size += sizeof(*(m_oldPalette.getPointer()));

	return m_tiles ? m_tiles->getMemorySize() + size : size;

}

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

void ToolUtils::TRasterUndo::undo() const

{

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

	if (!app)

		return;

	if (m_tiles && m_tiles->getTileCount() > 0) {

		TToonzImageP image = getImage();

		if (!image)

			return;

		ToonzImageUtils::paste(image, m_tiles);

		ToolUtils::updateSaveBox(m_level, m_frameId);

	}

	removeLevelAndFrameIfNeeded();

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

	notifyImageChanged();

}

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

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

ToolUtils::TFullColorRasterUndo::TFullColorRasterUndo(TTileSetFullColor *tiles, TXshSimpleLevel *level,

													  const TFrameId &frameId, bool createdFrame,

													  bool createdLevel, const TPaletteP &oldPalette)

	: TToolUndo(level, frameId, createdFrame, createdLevel, oldPalette), m_tiles(tiles)

{

}

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

ToolUtils::TFullColorRasterUndo::~TFullColorRasterUndo()

{

	delete m_tiles;

}

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

TRasterImageP ToolUtils::TFullColorRasterUndo::getImage() const

{

	if (m_level->isFid(m_frameId))

		return (TRasterImageP)m_level->getFrame(m_frameId, true);

	return 0;

}

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

int ToolUtils::TFullColorRasterUndo::getSize() const

{

	int size = sizeof(*this);

	size += sizeof(*(m_level.getPointer()));

	size += sizeof(*(m_oldPalette.getPointer()));

	return m_tiles ? m_tiles->getMemorySize() + size : size;

}

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

void ToolUtils::TFullColorRasterUndo::undo() const

{

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

	if (!app)

		return;

	if (m_tiles && m_tiles->getTileCount() > 0) {

		TRasterImageP image = getImage();

		if (!image)

			return;

		std::vector<trect> rects = paste(image, m_tiles);</trect>

		int i;

		TRect resRect = rects[0];

		for (i = 1; i < (int)rects.size(); i++)

			resRect += rects[i];

	}

	removeLevelAndFrameIfNeeded();

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

	notifyImageChanged();

}

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

std::vector<trect> ToolUtils::TFullColorRasterUndo::paste(const TRasterImageP &ti, const TTileSetFullColor *tileSet) const</trect>

{

	std::vector<trect> rects;</trect>

	TRasterP raster = ti->getRaster();

	for (int i = 0; i < tileSet->getTileCount(); i++) {

		const TTileSetFullColor::Tile *tile = tileSet->getTile(i);

		TRasterP ras;

		tile->getRaster(ras);

		assert(!!ras);

		raster->copy(ras, tile->m_rasterBounds.getP00());

		rects.push_back(tile->m_rasterBounds);

	}

	return rects;

}

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

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

ToolUtils::UndoModifyStroke::UndoModifyStroke(TXshSimpleLevel *level, const TFrameId &frameId, int strokeIndex)

	: TToolUndo(level, frameId), m_strokeIndex(strokeIndex)

{

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

	assert(image);

	TStroke *stroke = image->getStroke(m_strokeIndex);

	int n = stroke->getControlPointCount();

	for (int i = 0; i < n; i++)

		m_before.push_back(stroke->getControlPoint(i));

	m_selfLoopBefore = stroke->isSelfLoop();

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

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

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

}

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

ToolUtils::UndoModifyStroke::~UndoModifyStroke() {}

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

void ToolUtils::UndoModifyStroke::onAdd()

{

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

	assert(image);

	if (!image)

		return;

	TStroke *stroke = image->getStroke(m_strokeIndex);

	assert(stroke);

	int n = stroke->getControlPointCount();

	for (int i = 0; i < n; i++)

		m_after.push_back(stroke->getControlPoint(i));

	m_selfLoopAfter = stroke->isSelfLoop();

}

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

void ToolUtils::UndoModifyStroke::undo() const

{

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

	if (!app)

		return;

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

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

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

	} else

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

	TSelection *selection = app->getCurrentSelection()->getSelection();

	if (selection)

		selection->selectNone();

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

	assert(image);

	if (!image)

		return;

	QMutexLocker lock(image->getMutex());

	TStroke *stroke = 0;

	if (image->getStrokeCount() == 1) // && image->getStroke(0)->getStyle()==SplineStyle)

		stroke = image->getStroke(0);

	else

		stroke = image->getStroke(m_strokeIndex);

	if (!stroke)

		return;

	TStroke *oldStroke = new TStroke(*stroke);

	stroke->reshape(&m_before[0], m_before.size());

	stroke->setSelfLoop(m_selfLoopBefore);

	image->notifyChangedStrokes(m_strokeIndex, oldStroke);

	notifyImageChanged();

	delete oldStroke;

}

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

void ToolUtils::UndoModifyStroke::redo() const

{

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

	if (!app)

		return;

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

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

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

	} else

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

	TSelection *selection = app->getCurrentSelection()->getSelection();

	if (selection)

		selection->selectNone();

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

	assert(image);

	if (!image)

		return;

	QMutexLocker lock(image->getMutex());

	TStroke *stroke = 0;

	if (image->getStrokeCount() == 1) //&& image->getStroke(0)->getStyle()==SplineStyle)

		stroke = image->getStroke(0);

	else

		stroke = image->getStroke(m_strokeIndex);

	if (!stroke)

		return;

	TStroke *oldStroke = new TStroke(*stroke);

	stroke->reshape(&m_after[0], m_after.size());

	stroke->setSelfLoop(m_selfLoopAfter);

	image->notifyChangedStrokes(m_strokeIndex, oldStroke);

	delete oldStroke;

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

	notifyImageChanged();

}

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

int ToolUtils::UndoModifyStroke::getSize() const

{

	return (m_before.capacity() + m_after.capacity()) * sizeof(TThickPoint) +

		   sizeof(*this) + 500;

}