#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>
#include <QGLWidget>
#include <QFont>
#include <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)
{
	assert(theMap.size() == theVect.size());
	std::map<int, VIStroke *>::const_iterator it = theMap.begin();
	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 intersection = first * second;
	QList<TRect> rects;
	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;

	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);
		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
{
	std::vector<TRect> rects;
	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;
}

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

ToolUtils::UndoModifyStrokeAndPaint::UndoModifyStrokeAndPaint(TXshSimpleLevel *level, const TFrameId &frameId,
															  int strokeIndex)
	: UndoModifyStroke(level, frameId, strokeIndex), m_fillInformation(0)
{
	TVectorImageP image = level->getFrame(frameId, true);
	assert(image);
	TStroke *stroke = image->getStroke(strokeIndex);
	m_oldBBox = stroke->getBBox();
}

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

void ToolUtils::UndoModifyStrokeAndPaint::onAdd()
{
	TVectorImageP image = m_level->getFrame(m_frameId, true);
	assert(!!image);
	if (!image)
		return;

	UndoModifyStroke::onAdd();
	TStroke *stroke = image->getStroke(m_strokeIndex);
	m_fillInformation = new std::vector<TFilledRegionInf>;
	ImageUtils::getFillingInformationOverlappingArea(image, *m_fillInformation, m_oldBBox, stroke->getBBox());
}

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

void ToolUtils::UndoModifyStrokeAndPaint::undo() const
{
	TTool::Application *application = TTool::getApplication();
	if (!application)
		return;

	UndoModifyStroke::undo();
	TRegion *reg;
	UINT size = m_fillInformation->size();
	if (!size) {
		application->getCurrentXsheet()->notifyXsheetChanged();
		notifyImageChanged();
		return;
	}

	TVectorImageP image = m_level->getFrame(m_frameId, true);
	assert(!!image);
	if (!image)
		return;

	//image->validateRegions();
	image->findRegions();
	for (UINT i = 0; i < size; i++) {
		reg = image->getRegion((*m_fillInformation)[i].m_regionId);
		assert(reg);
		if (reg)
			reg->setStyle((*m_fillInformation)[i].m_styleId);
	}

	application->getCurrentXsheet()->notifyXsheetChanged();
	notifyImageChanged();
}
//-----------------------------------------------------------------------------

ToolUtils::UndoModifyStrokeAndPaint::~UndoModifyStrokeAndPaint()
{
	delete m_fillInformation;
}

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

int ToolUtils::UndoModifyStrokeAndPaint::getSize() const
{
	int size = m_fillInformation ? m_fillInformation->size() * sizeof(TFilledRegionInf) : 0;
	return UndoModifyStroke::getSize() + size;
}

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

ToolUtils::UndoModifyListStroke::UndoModifyListStroke(TXshSimpleLevel *level, const TFrameId &frameId,
													  const std::vector<TStroke *> &strokeVect)
	: TToolUndo(level, frameId), m_fillInformation(0)
{
	UINT strokeNum = strokeVect.size();
	TVectorImageP image = level->getFrame(frameId, true);
	assert(image);
	for (UINT i = 0; i < strokeNum; i++) {
		m_oldBBox += (strokeVect[i])->getBBox();
		int strokeIndex = image->getStrokeIndex(strokeVect[i]);
		m_strokeList.push_back(new UndoModifyStroke(level, frameId, strokeIndex));
	}

	m_beginIt = m_strokeList.begin();
	m_endIt = m_strokeList.end();
}

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

ToolUtils::UndoModifyListStroke::~UndoModifyListStroke()
{
	clearPointerContainer(m_strokeList);
	delete m_fillInformation;
}

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

void ToolUtils::UndoModifyListStroke::onAdd()
{
	std::list<UndoModifyStroke *>::iterator it = m_beginIt;
	TRectD newBBox;

	TVectorImageP image = m_level->getFrame(m_frameId, true);
	assert(!!image);
	if (!image)
		return;

	for (; it != m_endIt; ++it) {
		TStroke *s = image->getStroke((*it)->m_strokeIndex);
		(*it)->onAdd();
	}
	m_fillInformation = new std::vector<TFilledRegionInf>;

	if (m_beginIt != m_endIt)
		ImageUtils::getFillingInformationOverlappingArea(image, *m_fillInformation, m_oldBBox, newBBox);
}

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

void ToolUtils::UndoModifyListStroke::undo() const
{
	TTool::Application *app = TTool::getApplication();
	if (!app)
		return;

	std::list<UndoModifyStroke *>::iterator stroke_it = m_beginIt;
	if (m_beginIt == m_endIt)
		return;

	for (; stroke_it != m_endIt; ++stroke_it) {
		(*stroke_it)->undo();
	}

	UINT size = m_fillInformation->size();
	if (!size) {
		app->getCurrentXsheet()->notifyXsheetChanged();
		app->getCurrentTool()->getTool()->notifyImageChanged();
		return;
	}

	TVectorImageP image = m_level->getFrame(m_frameId, true);
	assert(!!image);
	if (!image)
		return;

	image->findRegions();

	TRegion *reg;
	for (UINT i = 0; i < size; i++) {
		reg = image->getRegion((*m_fillInformation)[i].m_regionId);
		assert(reg);
		if (reg)
			reg->setStyle((*m_fillInformation)[i].m_styleId);
	}
	app->getCurrentXsheet()->notifyXsheetChanged();
	notifyImageChanged();
}

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

void ToolUtils::UndoModifyListStroke::redo() const
{
	TTool::Application *app = TTool::getApplication();
	if (!app)
		return;

	std::list<UndoModifyStroke *>::iterator it = m_beginIt;

	for (; it != m_endIt; ++it) {
		(*it)->redo();
	}

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

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

int ToolUtils::UndoModifyListStroke::getSize() const
{
	int sum = 0;

	std::list<UndoModifyStroke *>::iterator it = m_beginIt;

	for (; it != m_endIt; ++it) {
		sum += (*it)->getSize();
	}

	if (m_fillInformation)
		sum += m_fillInformation->capacity() * sizeof(TFilledRegionInf);

	return sum;
}

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

ToolUtils::UndoPencil::UndoPencil(TStroke *stroke,
								  std::vector<TFilledRegionInf> *fillInformation,
								  TXshSimpleLevel *level, const TFrameId &frameId,
								  bool createdFrame, bool createdLevel,
								  bool autogroup, bool autofill)
	: TToolUndo(level, frameId, createdFrame, createdLevel, 0), m_strokeId(stroke->getId()), m_fillInformation(fillInformation), m_autogroup(autogroup), m_autofill(autofill)
{
	m_stroke = new TStroke(*stroke);
}

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

ToolUtils::UndoPencil::~UndoPencil()
{
	delete m_fillInformation;
	delete m_stroke;
}

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

void ToolUtils::UndoPencil::undo() const
{
	TTool::Application *app = TTool::getApplication();
	if (!app)
		return;

	/*if(app->getCurrentFrame()->isEditingScene() && m_col!=-2 && m_row!=-1)
	{
		app->getCurrentColumn()->setColumnIndex(m_col);
		app->getCurrentFrame()->setFrame(m_row);
	}
	else
		app->getCurrentFrame()->setFid(m_frameId);*/

	TVectorImageP image = m_level->getFrame(m_frameId, true);
	assert(image);
	if (!image)
		return;

	QMutexLocker sl(image->getMutex());
	VIStroke *stroke = image->getStrokeById(m_strokeId);
	if (!stroke)
		return;
	image->deleteStroke(stroke);
	TSelection *selection = app->getCurrentSelection()->getSelection();
	if (StrokeSelection *strokeSelection = (StrokeSelection *)selection)
		strokeSelection->selectNone();

	UINT size = m_fillInformation->size();
	TRegion *reg;
	for (UINT i = 0; i < size; i++) {
		reg = image->getRegion((*m_fillInformation)[i].m_regionId);
		assert(reg);
		if (reg)
			reg->setStyle((*m_fillInformation)[i].m_styleId);
	}

	removeLevelAndFrameIfNeeded();

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

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

void ToolUtils::UndoPencil::redo() const
{
	TTool::Application *app = TTool::getApplication();
	if (!app)
		return;

	insertLevelAndFrameIfNeeded();

	/*if(app->getCurrentFrame()->isEditingScene())
	{
		app->getCurrentColumn()->setColumnIndex(m_col);
		app->getCurrentFrame()->setFrame(m_row);
	}
	else
		app->getCurrentFrame()->setFid(m_frameId);*/

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

	QMutexLocker sl(image->getMutex());
	TStroke *stroke = new TStroke(*m_stroke);
	stroke->setId(m_strokeId);
	image->addStroke(stroke);
	if (image->isComputedRegionAlmostOnce())
		image->findRegions();

	if (m_autogroup && stroke->isSelfLoop()) {
		int index = image->getStrokeCount() - 1;
		image->group(index, 1);
		if (m_autofill) {
			//to avoid filling other strokes, I enter into the new stroke group
			int currentGroup = image->exitGroup();
			image->enterGroup(index);
			image->selectFill(stroke->getBBox().enlarge(1, 1), 0, stroke->getStyle(), false, true, false);
			if (currentGroup != -1)
				image->enterGroup(currentGroup);
			else
				image->exitGroup();
		}
	}
	app->getCurrentXsheet()->notifyXsheetChanged();
	notifyImageChanged();
}

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

int ToolUtils::UndoPencil::getSize() const
{
	return sizeof(*this) + m_fillInformation->capacity() * sizeof(TFilledRegionInf) + 500;
}

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

ToolUtils::UndoRasterPencil::UndoRasterPencil(TXshSimpleLevel *level, const TFrameId &frameId, TStroke *stroke,
											  bool selective, bool filled, bool doAntialias, bool createdFrame,
												bool createdLevel, std::string primitiveName)
	: TRasterUndo(0, level, frameId, createdFrame, createdLevel, 0), m_selective(selective), m_filled(filled), m_doAntialias(doAntialias), m_primitiveName(primitiveName)
{
	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);
}

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

ToolUtils::UndoRasterPencil::~UndoRasterPencil()
{
	delete m_stroke;
}

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

void ToolUtils::UndoRasterPencil::redo() const
{
	insertLevelAndFrameIfNeeded();
	TToonzImageP image = getImage();
	if (!image)
		return;

	ToonzImageUtils::addInkStroke(image, m_stroke, m_stroke->getStyle(), m_selective, m_filled, TConsts::infiniteRectD, m_doAntialias);
	ToolUtils::updateSaveBox();
	TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();
	notifyImageChanged();
}

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

int ToolUtils::UndoRasterPencil::getSize() const
{
	return TRasterUndo::getSize() + m_stroke->getControlPointCount() * sizeof(TThickPoint) + 100 + sizeof(this);
}

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

ToolUtils::UndoFullColorPencil::UndoFullColorPencil(TXshSimpleLevel *level, const TFrameId &frameId,
													TStroke *stroke, double opacity, bool doAntialias,
													bool createdFrame, bool createdLevel)
	: TFullColorRasterUndo(0, level, frameId, createdFrame, createdLevel, 0), m_opacity(opacity), m_doAntialias(doAntialias)
{
	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);
}

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

ToolUtils::UndoFullColorPencil::~UndoFullColorPencil()
{
	delete m_stroke;
}

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

void ToolUtils::UndoFullColorPencil::redo() const
{
	insertLevelAndFrameIfNeeded();
	TRasterImageP image = getImage();
	if (!image)
		return;
	TRasterImageUtils::addStroke(image, m_stroke, TRectD(), m_opacity, m_doAntialias);
	TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();
	notifyImageChanged();
}

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

int ToolUtils::UndoFullColorPencil::getSize() const
{
	return TFullColorRasterUndo::getSize() + m_stroke->getControlPointCount() * sizeof(TThickPoint) + 100 + sizeof(this);
}

//=============================================================================================
//
// undo class (path strokes). call it BEFORE and register it AFTER path change
//
ToolUtils::UndoPath::UndoPath(TStageObjectSpline *spline)
	: m_spline(spline)
{
	assert(!!m_spline);

	const TStroke *stroke = m_spline->getStroke();
	assert(stroke);
	int n = stroke->getControlPointCount();
	for (int i = 0; i < n; i++)
		m_before.push_back(stroke->getControlPoint(i));
	m_selfLoopBefore = stroke->isSelfLoop();
}

ToolUtils::UndoPath::~UndoPath()
{
}

void ToolUtils::UndoPath::onAdd()
{
	assert(!!m_spline);

	const TStroke *stroke = m_spline->getStroke();
	assert(stroke);
	int n = stroke->getControlPointCount();
	for (int i = 0; i < n; i++)
		m_after.push_back(stroke->getControlPoint(i));
}

void ToolUtils::UndoPath::undo() const
{
	assert(!!m_spline);

	TTool::Application *app = TTool::getApplication();
	TSelection *selection = app->getCurrentSelection()->getSelection();
	if (selection)
		selection->selectNone();

	TStroke *stroke = new TStroke(*m_spline->getStroke());
	stroke->reshape(&m_before[0], m_before.size());
	stroke->setSelfLoop(m_selfLoopBefore);
	m_spline->setStroke(stroke);

	if (!app->getCurrentObject()->isSpline())
		return;

	TStageObjectId currentObjectId = app->getCurrentObject()->getObjectId();
	TStageObject *stageObject = app->getCurrentXsheet()->getXsheet()->getStageObject(currentObjectId);
	if (stageObject->getSpline()->getId() == m_spline->getId())
		app->getCurrentObject()->setSplineObject(m_spline);

	app->getCurrentTool()->getTool()->notifyImageChanged();
}

void ToolUtils::UndoPath::redo() const
{
	assert(!!m_spline);

	TTool::Application *app = TTool::getApplication();
	TSelection *selection = app->getCurrentSelection()->getSelection();
	if (selection)
		selection->selectNone();

	TStroke *stroke = new TStroke(*m_spline->getStroke());
	stroke->reshape(&m_after[0], m_after.size());
	stroke->setSelfLoop(m_selfLoopBefore);
	m_spline->setStroke(stroke);

	if (!app->getCurrentObject()->isSpline())
		return;

	TStageObjectId currentObjectId = app->getCurrentObject()->getObjectId();
	TStageObject *stageObject = app->getCurrentXsheet()->getXsheet()->getStageObject(currentObjectId);
	if (stageObject->getSpline()->getId() == m_spline->getId())
		app->getCurrentObject()->setSplineObject(m_spline);

	app->getCurrentTool()->getTool()->notifyImageChanged();
}

int ToolUtils::UndoPath::getSize() const
{
	return sizeof(*this) + 500;
}

//=============================================================================================
//
// UndoControlPointEditor
//

ToolUtils::UndoControlPointEditor::UndoControlPointEditor(TXshSimpleLevel *level, const TFrameId &frameId)
	: TToolUndo(level, frameId), m_isStrokeDelete(false)
{
	TVectorImageP image = level->getFrame(frameId, true);
	assert(image);
	if (!image)
		return;

	TTool::Application *app = TTool::getApplication();
	if (!app)
		return;

	m_row = app->getCurrentFrame()->getFrame();
	m_column = app->getCurrentColumn()->getColumnIndex();
}

ToolUtils::UndoControlPointEditor::~UndoControlPointEditor()
{
	deleteVIStroke(m_oldStroke.second);
	if (!m_isStrokeDelete)
		deleteVIStroke(m_newStroke.second);
}

void ToolUtils::UndoControlPointEditor::onAdd()
{
	TVectorImageP image = m_level->getFrame(m_frameId, true);
	assert(image);
	if (!image)
		return;
	QMutexLocker lock(image->getMutex());
	if (m_isStrokeDelete)
		return;
	addNewStroke(m_oldStroke.first, image->getVIStroke(m_oldStroke.first));
}

void ToolUtils::UndoControlPointEditor::addOldStroke(int index, VIStroke *vs)
{
	VIStroke *s = cloneVIStroke(vs);
	m_oldStroke = std::make_pair(index, s);
}

void ToolUtils::UndoControlPointEditor::addNewStroke(int index, VIStroke *vs)
{
	VIStroke *s = cloneVIStroke(vs);
	m_newStroke = std::make_pair(index, s);
}

void ToolUtils::UndoControlPointEditor::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());

	if (!m_isStrokeDelete)
		image->removeStroke(m_newStroke.first, false);

	UINT i = 0;
	VIStroke *s = cloneVIStroke(m_oldStroke.second);
	image->insertStrokeAt(s, m_oldStroke.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

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

void ToolUtils::UndoControlPointEditor::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());

	image->removeStroke(m_oldStroke.first, false);

	if (!m_isStrokeDelete) {
		VIStroke *s = cloneVIStroke(m_newStroke.second);
		image->insertStrokeAt(s, m_newStroke.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

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

//=============================================================================================
//
// Menu
//

ToolUtils::DragMenu::DragMenu()
	: QMenu()
{
}

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

QAction *ToolUtils::DragMenu::exec(const QPoint &p, QAction *action)
{
	QAction *execAct = QMenu::exec(p, action);
	if (execAct)
		return execAct;

	return defaultAction();
}

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

void ToolUtils::DragMenu::mouseReleaseEvent(QMouseEvent *e)
{
	QMenu::mouseReleaseEvent(e);
	hide();
}

//=============================================================================================
//
// ColumChooserMenu
//

ToolUtils::ColumChooserMenu::ColumChooserMenu(TXsheet *xsh, const std::vector<int> &columnIndexes)
	: DragMenu()
{
	int size = columnIndexes.size();
	int i;
	for (i = size - 1; i >= 0; i--) {
		int index = columnIndexes[i];
		TStageObjectId id = TStageObjectId::ColumnId(index);
		TStageObject *stageObject = xsh->getStageObject(id);
		QString cmdStr = "Column " + QString::fromStdString(stageObject->getName());
		QAction *act = new QAction(cmdStr, this);
		act->setData(index);
		addAction(act);
		if (size - 1 == i) {
			setDefaultAction(act);
			setActiveAction(act);
		}
	}
}

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

int ToolUtils::ColumChooserMenu::execute()
{
	QAction *executeAct = exec(QCursor::pos());
	return (!executeAct) ? -1 : executeAct->data().toInt();
}

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

double ToolUtils::ConeSubVolume::compute(double cover)
{
	double x = (10 * tcrop(cover, -1.0, 1.0)) + 10;
	assert(0 <= x && x <= 20);
	int i = tfloor(x);
	if (i == 20)
		return m_values[i];
	else
		//Interpolazione lineare.
		return (-(x - (i + 1)) * m_values[i]) - (-(x - i) * m_values[i + 1]);
}

const double ToolUtils::ConeSubVolume::m_values[] = {
	1.0, 0.99778, 0.987779, 0.967282, 0.934874,
	0.889929, 0.832457, 0.763067, 0.683002, 0.594266,
	0.5, 0.405734, 0.316998, 0.236933, 0.167543,
	0.110071, 0.0651259, 0.0327182, 0.0122208, 0.00221986,
	0.0};

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

void ToolUtils::drawBalloon(
	const TPointD &pos,
	std::string text,
	const TPixel32 &color,
	TPoint delta,
	bool isPicking,
	std::vector<TRectD> *otherBalloons)
{
	QString qText = QString::fromStdString(text);
	QFont font("Arial", 10); // ,QFont::Bold);
	QFontMetrics fm(font);
	QRect textRect = fm.boundingRect(qText);

	int baseLine = -textRect.top();
	int mrg = 3;

	// avoid other balloons
	if (otherBalloons) {
		double pixelSize = sqrt(tglGetPixelSize2());
		std::vector<TRectD> &balloons = *otherBalloons;
		int n = (int)balloons.size();
		TDimensionD balloonSize(pixelSize * (textRect.width() + mrg * 2), pixelSize * (textRect.height() + mrg * 2));
		TRectD balloonRect;
		for (;;) {
			balloonRect = TRectD(pos + TPointD(delta.x * pixelSize, delta.y * pixelSize), balloonSize);
			int i = 0;
			while (i < n && !balloons[i].overlaps(balloonRect))
				i++;
			if (i == n)
				break;
			double y = balloons[i].y0 - balloonSize.ly - 2 * mrg * pixelSize;
			delta.y = (y - pos.y) / pixelSize;
		}
		balloons.push_back(balloonRect);
	}

	textRect.moveTo(qMax(delta.x, 10 + mrg), qMax(mrg + 2, -delta.y - baseLine));

	int y = textRect.top() + baseLine;
	int x0 = textRect.left() - mrg;
	int x1 = textRect.right() + mrg;
	int y0 = textRect.top() - mrg;
	int y1 = textRect.bottom() + mrg;

	double pixelSize = sqrt(tglGetPixelSize2());
	if (isPicking) {
		TTool::Viewer *viewer = TTool::getApplication()->getCurrentTool()->getTool()->getViewer();

		if (viewer->is3DView()) {
			double x0 = pos.x + textRect.left() * pixelSize, y0 = pos.y + delta.y * pixelSize;
			double x1 = x0 + pixelSize * textRect.width();
			double y1 = y0 + pixelSize * textRect.height();
			double d = pixelSize * 5;
			glRectd(x0 - d, y0 - d, x1 + d, y1 + d);
		} else {
			TPoint posBalloon = viewer->worldToPos(pos);

			double d = 5;
			double x0 = posBalloon.x + textRect.left() - d;
			double y0 = posBalloon.y + delta.y - d;
			double x1 = x0 + textRect.width() + d;
			double y1 = y0 + textRect.height() + d;

			TPoint p1(x0, y0);
			TPoint p2(x1, y0);
			TPoint p3(x0, y1);
			TPoint p4(x1, y1);

			TPointD w1(viewer->winToWorld(p1));
			TPointD w2(viewer->winToWorld(p2));
			TPointD w3(viewer->winToWorld(p3));
			TPointD w4(viewer->winToWorld(p4));

			glBegin(GL_QUADS);
			glVertex2d(w1.x, w1.y);
			glVertex2d(w2.x, w2.y);
			glVertex2d(w4.x, w4.y);
			glVertex2d(w3.x, w3.y);
			glEnd();
		}

		return;
	}

	QSize size(
		textRect.width() + textRect.left() + mrg,
		qMax(textRect.bottom() + mrg, y + delta.y) + 3);

	QImage label(size.width(), size.height(), QImage::Format_ARGB32);
	label.fill(Qt::transparent);
	// label.fill(qRgba(200,200,0,200));
	QPainter p(&label);
	p.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
	p.setBrush(QColor(color.r, color.g, color.b, color.m));
	p.setPen(Qt::NoPen);

	QPainterPath pp;
	pp.moveTo(x0, y - 8);
	pp.lineTo(0, y + delta.y);
	pp.lineTo(x0, y);
	/* bordi arrotondati
  int arcSize = 10;
  pp.arcTo(x0,y1-arcSize,arcSize,arcSize,180,90);
  pp.arcTo(x1-arcSize,y1-arcSize,arcSize,arcSize,270,90);
  pp.arcTo(x1-arcSize,y0,arcSize,arcSize,0,90);
  pp.arcTo(x0,y0,arcSize,arcSize,90,90);
  */
	// bordi acuti
	pp.lineTo(x0, y1);
	pp.lineTo(x1, y1);
	pp.lineTo(x1, y0);
	pp.lineTo(x0, y0);

	pp.closeSubpath();

	p.drawPath(pp);

	p.setPen(Qt::black);
	p.setFont(font);
	p.drawText(textRect, Qt::AlignCenter | Qt::TextDontClip, qText);

	QImage texture = QGLWidget::convertToGLFormat(label);

	glRasterPos2f(pos.x, pos.y);
	glBitmap(0, 0, 0, 0, 0, -size.height() + (y + delta.y), NULL); //
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glDrawPixels(texture.width(), texture.height(), GL_RGBA, GL_UNSIGNED_BYTE, texture.bits());
	glDisable(GL_BLEND);
	glColor3d(0, 0, 0);
}

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

void ToolUtils::drawHook(
	const TPointD &pos,
	ToolUtils::HookType type,
	bool highlighted, bool onionSkin)
{
	int r = 10, d = r + r;
	QImage image(d, d, QImage::Format_ARGB32);
	image.fill(Qt::transparent);
	// image.fill(qRgba(200,200,0,200));
	QPainter painter(&image);
	// painter.setRenderHints(QPainter::Antialiasing|QPainter::TextAntialiasing);

	int matte = onionSkin ? 100 : 255;

	QColor color(0, 0, 0, matte);
	if (highlighted)
		color = QColor(0, 175, 175, matte);

	if (type == NormalHook || type == PassHookA) {
		painter.setPen(QPen(QColor(255, 255, 255, matte), 3));
		painter.drawEllipse(5, 5, d - 10, d - 10);
		painter.setPen(color);
		painter.drawEllipse(5, 5, d - 10, d - 10);
	} else if (type == OtherLevelHook) {
		QColor color(0, 200, 200, 200);
		//painter.setPen(QPen(Qt::white,3));
		//painter.drawEllipse(5,5,d-10,d-10);
		painter.setPen(Qt::white);
		painter.setBrush(color);
		painter.drawEllipse(6, 6, d - 12, d - 12);
	}
	if (type == NormalHook || type == PassHookB) {
		painter.setPen(QPen(QColor(255, 255, 255, matte), 3));
		painter.drawLine(0, r, d, r);
		painter.drawLine(r, 0, r, d);
		painter.setPen(color);
		painter.drawLine(0, r, d, r);
		painter.drawLine(r, 0, r, d);
	}

	QImage texture = QGLWidget::convertToGLFormat(image);
	glRasterPos2f(pos.x, pos.y);
	glBitmap(0, 0, 0, 0, -r, -r, NULL);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glDrawPixels(texture.width(), texture.height(), GL_RGBA, GL_UNSIGNED_BYTE, texture.bits());
	glDisable(GL_BLEND);
}

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

bool ToolUtils::isJustCreatedSpline(TImage *image)
{
	TVectorImageP vi = image;
	if (!vi)
		return false;
	if (vi->getStrokeCount() != 1)
		return false;
	TStroke *stroke = vi->getStroke(0);
	if (stroke->getControlPointCount() != 3)
		return false;
	TPointD p0 = stroke->getControlPoint(0);
	TPointD p1 = stroke->getControlPoint(1);
	TPointD p2 = stroke->getControlPoint(2);
	double d = 30.0;
	return p0 == TPointD(-d, 0) && p1 == TPointD(0, 0) && p2 == TPointD(d, 0);
}

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

TRectD ToolUtils::interpolateRect(const TRectD &rect1, const TRectD &rect2, double t)
{
	assert(rect1.x0 <= rect1.x1);
	assert(rect1.y0 <= rect1.y1);
	assert(rect2.x0 <= rect2.x1);
	assert(rect2.y0 <= rect2.y1);

	return TRectD(
		rect1.x0 + (rect2.x0 - rect1.x0) * t,
		rect1.y0 + (rect2.y0 - rect1.y0) * t,
		rect1.x1 + (rect2.x1 - rect1.x1) * t,
		rect1.y1 + (rect2.y1 - rect1.y1) * t);
}

//-----------------------------------------------------------------------------
/*
bool ToolUtils::isASubRegion(int reg, const std::vector<TRegion*> &regions)
{
	TRegion *region=regions[reg];
	for (int i=0; i<(int)regions.size(); i++)
	{
		if(i!=reg)
			if(region->isSubRegionOf(*regions[i]))
				return true;
	}
	return false;
}
*/
//-----------------------------------------------------------------------------

TRectD ToolUtils::getBounds(const std::vector<TThickPoint> &points, double maxThickness)
{
	TThickPoint p = points[0];
	double radius = maxThickness == 0 ? p.thick * 0.5 : maxThickness * 0.5;
	TRectD rect(p - TPointD(radius, radius), p + TPointD(radius, radius));
	int i;
	for (i = 1; i < (int)points.size(); i++) {
		p = points[i];
		radius = maxThickness == 0 ? p.thick * 0.5 : maxThickness * 0.5;
		rect = rect + TRectD(p - TPointD(radius, radius), p + TPointD(radius, radius));
	}
	return rect;
}

//-----------------------------------------------------------------------------
/*
template <typename PIXEL>
TRasterPT<PIXEL> ToolUtils::rotate90(const TRasterPT<PIXEL> &ras, bool toRight)
{
	if(!ras)
		return 0;
	int lx=ras->getLy();
	int ly=ras->getLx();
	TRasterPT<PIXEL> workRas(lx,ly);
	for (int i=0; i<ras->getLx(); i++)
	{
		for (int j=0; j<ras->getLy(); j++)
		{
			if(toRight)
				workRas->pixels(ly-1-i)[j]=ras->pixels(j)[i];
			else
				workRas->pixels(i)[lx-1-j]=ras->pixels(j)[i];
		}
	}
	return workRas;	
}*/