#include "tools/tool.h"

#include "tools/toolutils.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tpalettehandle.h"

#include "toonz/preferences.h"

#include "toonz/txsheethandle.h"

#include "toonz/tobjecthandle.h"

#include "tools/toolhandle.h"

#include "tools/toolutils.h"

#include "toonz/tonionskinmaskhandle.h"

#include "timagecache.h"

#include "tundo.h"

#include "tpalette.h"

#include "tcolorstyles.h"

#include "tvectorimage.h"

#include "tools/cursors.h"

#include "ttoonzimage.h"

#include "tproperty.h"

#include "tenv.h"

#include "tools/stylepicker.h"

#include "toonz/fill.h"

#include "toonz/stage2.h"

#include "tstroke.h"

#include "drawutil.h"

#include "tsystem.h"

#include "tinbetween.h"

#include "tregion.h"

#include "tgl.h"

#include "trop.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/onionskinmask.h"

#include "toonz/ttileset.h"

#include "toonz/ttilesaver.h"

#include "toonz/toonzimageutils.h"

#include "toonz/levelproperties.h"

#include "toonz/strokegenerator.h"

#include "toonz/txshcell.h"

#include "toonzqt/imageutils.h"

#include "autofill.h"

#include "historytypes.h"

#include <stack></stack>

// For Qt translation support

#include <qcoreapplication></qcoreapplication>

using namespace ToolUtils;

#define LINES L"Lines"

#define AREAS L"Areas"

#define ALL L"Lines & Areas"

#define NORMALFILL L"Normal"

#define RECTFILL L"Rectangular"

#define FREEHANDFILL L"Freehand"

#define POLYLINEFILL L"Polyline"

TEnv::IntVar MinFillDepth("InknpaintMinFillDepth", 0);

TEnv::IntVar MaxFillDepth("InknpaintMaxFillDepth", 10);

TEnv::StringVar FillType("InknpaintFillType", "Normal");

TEnv::StringVar FillColorType("InknpaintFillColorType", "Areas");

TEnv::IntVar FillSelective("InknpaintFillSelective", 0);

TEnv::IntVar FillOnion("InknpaintFillOnion", 0);

TEnv::IntVar FillSegment("InknpaintFillSegment", 0);

TEnv::IntVar FillRange("InknpaintFillRange", 0);

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

namespace

{

inline int vectorFill(const TVectorImageP &img, const wstring &type, const TPointD &point, int style, bool emptyOnly = false)

{

	if (type == ALL || type == LINES) {

		int oldStyleId = img->fillStrokes(point, style);

		if (oldStyleId != -1)

			return oldStyleId;

	}

	if (type == ALL || type == AREAS)

		return img->fill(point, style, emptyOnly);

	return -1;

}

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

// VectorFillUndo

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

class VectorFillUndo : public TToolUndo

{

	int m_oldColorStyle;

	int m_newColorStyle;

	TPointD m_point;

	wstring m_type;

	int m_row;

	int m_column;

public:

	VectorFillUndo(

		int newColorStyle,

		int oldColorStyle,

		wstring fillType,

		TPointD clickPoint,

		TXshSimpleLevel *sl,

		const TFrameId &fid)

		: TToolUndo(sl, fid), m_newColorStyle(newColorStyle), m_oldColorStyle(oldColorStyle), m_point(clickPoint), m_type(fillType)

	{

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

		if (app) {

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

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

		}

	}

	void undo() const

	{

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

		if (!app)

			return;

		app->getCurrentLevel()->setLevel(m_level.getPointer());

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

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

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

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

		} else

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

		assert(img);

		if (!img)

			return;

		QMutexLocker lock(img->getMutex());

		vectorFill(img, m_type, m_point, m_oldColorStyle);

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

		notifyImageChanged();

	}

	void redo() const

	{

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

		if (!app)

			return;

		app->getCurrentLevel()->setLevel(m_level.getPointer());

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

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

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

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

		} else

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

		assert(img);

		if (!img)

			return;

		QMutexLocker lock(img->getMutex());

		vectorFill(img, m_type, m_point, m_newColorStyle);

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

		notifyImageChanged();

	}

	void onAdd()

	{

	}

	int getSize() const

	{

		return sizeof(*this);

	}

	virtual QString getToolName()

	{

		return QString("Fill Tool : %1").arg(QString::fromStdWString(m_type));

	}

	int getHistoryType()

	{

		return HistoryType::FillTool;

	}

};

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

// VectorRectFillUndo

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

class VectorRectFillUndo : public TToolUndo

{

	vector<tfilledregioninf> *m_regionFillInformation;</tfilledregioninf>

	vector<pair<int, int="">> *m_strokeFillInformation;</pair<int,>

	TRectD m_selectionArea;

	int m_styleId;

	bool m_unpaintedOnly;

	TStroke *m_stroke;

public:

	~VectorRectFillUndo()

	{

		if (m_regionFillInformation)

			delete m_regionFillInformation;

		if (m_strokeFillInformation)

			delete m_strokeFillInformation;

		if (m_stroke)

			delete m_stroke;

	}

	VectorRectFillUndo(

		vector<tfilledregioninf> *regionFillInformation,</tfilledregioninf>

		vector<pair<int, int="">> *strokeFillInformation,</pair<int,>

		TRectD selectionArea,

		TStroke *stroke,

		int styleId,

		bool unpaintedOnly,

		TXshSimpleLevel *sl,

		const TFrameId &fid)

		: TToolUndo(sl, fid), m_regionFillInformation(regionFillInformation), m_strokeFillInformation(strokeFillInformation), m_selectionArea(selectionArea), m_styleId(styleId), m_unpaintedOnly(unpaintedOnly), m_stroke(0)

	{

		if (stroke)

			m_stroke = new TStroke(*stroke);

	}

	void undo() const

	{

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

		if (!app)

			return;

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

		assert(!!img);

		if (!img)

			return;

		if (m_regionFillInformation) {

			for (UINT i = 0; i < m_regionFillInformation->size(); i++) {

				TRegion *reg = img->getRegion((*m_regionFillInformation)[i].m_regionId);

				if (reg)

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

			}

		}

		if (m_strokeFillInformation) {

			for (UINT i = 0; i < m_strokeFillInformation->size(); i++) {

				TStroke *s = img->getStroke((*m_strokeFillInformation)[i].first);

				s->setStyle((*m_strokeFillInformation)[i].second);

			}

		}

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

		notifyImageChanged();

	}

	void redo() const

	{

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

		if (!app)

			return;

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

		assert(img);

		if (!img)

			return;

		img->selectFill(m_selectionArea, m_stroke, m_styleId, m_unpaintedOnly, m_regionFillInformation != 0, m_strokeFillInformation != 0);

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

		notifyImageChanged();

	}

	void onAdd()

	{

	}

	int getSize() const

	{

		int size1 = m_regionFillInformation ? m_regionFillInformation->capacity() * sizeof(m_regionFillInformation) : 0;

		int size2 = m_strokeFillInformation ? m_strokeFillInformation->capacity() * sizeof(m_strokeFillInformation) : 0;

		return sizeof(*this) + size1 + size2 + 500;

	}

	virtual QString getToolName()

	{

		return QString("Fill Tool : ");

	}

	int getHistoryType()

	{

		return HistoryType::FillTool;

	}

};

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

// RasterFillUndo

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

class RasterFillUndo : public TRasterUndo

{

	FillParameters m_params;

	bool m_saveboxOnly;

public:

	/*RasterFillUndo(TTileSetCM32 *tileSet, TPoint fillPoint,

								 int paintId, int fillDepth,

								 wstring fillType, bool isSegment,

								 bool selective, bool isShiftFill,

								 TXshSimpleLevel* sl, const TFrameId& fid)*/

	RasterFillUndo(TTileSetCM32 *tileSet, const FillParameters ¶ms,

				   TXshSimpleLevel *sl, const TFrameId &fid, bool saveboxOnly)

		: TRasterUndo(tileSet, sl, fid, false, false, 0), m_params(params), m_saveboxOnly(saveboxOnly)

	{

	}

	void redo() const

	{

		TToonzImageP image = getImage();

		if (!image)

			return;

		bool recomputeSavebox = false;

		TRasterCM32P r;

		if (m_saveboxOnly) {

			TRectD temp = image->getBBox();

			TRect ttemp = convert(temp);

			r = image->getRaster()->extract(ttemp);

		} else

			r = image->getRaster();

		if (m_params.m_fillType == ALL || m_params.m_fillType == AREAS) {

			if (m_params.m_shiftFill) {

				FillParameters aux(m_params);

				aux.m_styleId = (m_params.m_styleId == 0) ? 1 : 0;

				recomputeSavebox = fill(r, aux);

			}

			recomputeSavebox = fill(r, m_params);

		}

		if (m_params.m_fillType == ALL || m_params.m_fillType == LINES) {

			if (m_params.m_segment)

				inkSegment(r, m_params.m_p, m_params.m_styleId, 2.51, true);

			else

				inkFill(r, m_params.m_p, m_params.m_styleId, 2);

		}

		if (recomputeSavebox)

			ToolUtils::updateSaveBox();

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

		if (app) {

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

			notifyImageChanged();

		}

	}

	int getSize() const

	{

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

	}

	virtual QString getToolName()

	{

		return QString("Fill Tool : %1").arg(QString::fromStdWString(m_params.m_fillType));

	}

	int getHistoryType()

	{

		return HistoryType::FillTool;

	}

};

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

// RasterRectFillUndo

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

class RasterRectFillUndo : public TRasterUndo

{

	TRect m_fillArea;

	int m_paintId;

	wstring m_colorType;

	TStroke *m_s;

	bool m_onlyUnfilled;

	TPalette *m_palette;

public:

	~RasterRectFillUndo()

	{

		if (m_s)

			delete m_s;

	}

	RasterRectFillUndo(TTileSetCM32 *tileSet, TStroke *s,

					   TRect fillArea, int paintId,

					   TXshSimpleLevel *level,

					   wstring colorType, bool onlyUnfilled,

					   const TFrameId &fid, TPalette *palette)

		: TRasterUndo(tileSet, level, fid, false, false, 0), m_fillArea(fillArea), m_paintId(paintId), m_colorType(colorType), m_onlyUnfilled(onlyUnfilled), m_palette(palette)

	{

		m_s = s ? new TStroke(*s) : 0;

	}

	void redo() const

	{

		TToonzImageP image = getImage();

		if (!image)

			return;

		TRasterCM32P ras = image->getRaster();

		AreaFiller filler(ras);

		if (!m_s)

			filler.rectFill(m_fillArea, m_paintId, m_onlyUnfilled, m_colorType != LINES, m_colorType != AREAS);

		else

			filler.strokeFill(m_s, m_paintId, m_onlyUnfilled, m_colorType != LINES, m_colorType != AREAS);

		if (m_palette) {

			TRect rect = m_fillArea;

			TRect bounds = ras->getBounds();

			if (bounds.overlaps(rect)) {

				rect *= bounds;

				const TTileSetCM32::Tile *tile = m_tiles->getTile(m_tiles->getTileCount() - 1);

				TRasterCM32P rbefore;

				tile->getRaster(rbefore);

				fillautoInks(ras, rect, rbefore, m_palette);

			}

		}

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

		if (app) {

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

			notifyImageChanged();

		}

	}

	int getSize() const

	{

		int size = m_s ? m_s->getControlPointCount() * sizeof(TThickPoint) + 100 : 0;

		return sizeof(*this) + TRasterUndo::getSize() + size;

	}

	virtual QString getToolName()

	{

		return QString("Fill Tool : %1").arg(QString::fromStdWString(m_colorType));

	}

	int getHistoryType()

	{

		return HistoryType::FillTool;

	}

};

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

// RasterRectAutoFillUndo

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

class RasterRectAutoFillUndo : public TRasterUndo

{

	TRect m_rectToFill;

	TFrameId m_fidToLearn;

	bool m_onlyUnfilled;

public:

	~RasterRectAutoFillUndo()

	{

	}

	RasterRectAutoFillUndo(TTileSetCM32 *tileSet,

						   const TRect &rectToFill,

						   TXshSimpleLevel *level,

						   bool onlyUnfilled,

						   const TFrameId ¤tFid, const TFrameId &fidToLearn)

		: TRasterUndo(tileSet, level, currentFid, false, false, 0), m_rectToFill(rectToFill), m_onlyUnfilled(onlyUnfilled), m_fidToLearn(fidToLearn)

	{

	}

	void redo() const

	{

		TToonzImageP image = getImage();

		TToonzImageP imageToLearn = m_level->getFrame(m_fidToLearn, false);

		if (!image || !imageToLearn)

			return;

		rect_autofill_learn(imageToLearn,

							m_rectToFill.x0,

							m_rectToFill.y0,

							m_rectToFill.x1,

							m_rectToFill.y1);

		TTileSetCM32 tileSet(image->getRaster()->getSize());

		bool recomputeBBox = rect_autofill_apply(image,

												 m_rectToFill.x0,

												 m_rectToFill.y0,

												 m_rectToFill.x1,

												 m_rectToFill.y1,

												 m_onlyUnfilled, &tileSet);

		if (recomputeBBox)

			ToolUtils::updateSaveBox();

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

		if (app) {

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

			notifyImageChanged();

		}

	}

	int getSize() const

	{

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

	}

};

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

// RasterStrokeAutoFillUndo

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

class RasterStrokeAutoFillUndo : public TRasterUndo

{

	TTileSetCM32 *m_tileSet;

public:

	~RasterStrokeAutoFillUndo()

	{

		if (m_tileSet)

			delete m_tileSet;

	}

	RasterStrokeAutoFillUndo(TTileSetCM32 *tileSet,

							 TXshSimpleLevel *level,

							 const TFrameId ¤tFid)

		: TRasterUndo(tileSet, level, currentFid, false, false, 0), m_tileSet(0)

	{

	}

	void setTileSet(TTileSetCM32 *tileSet) { m_tileSet = tileSet; }

	void redo() const

	{

		TToonzImageP image = getImage();

		if (!image)

			return;

		ToonzImageUtils::paste(image, m_tileSet);

		ToolUtils::updateSaveBox(m_level, m_frameId);

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

		if (app) {

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

			notifyImageChanged();

		}

	}

	int getSize() const

	{

		return sizeof(*this) + TRasterUndo::getSize() + m_tileSet->getMemorySize();

	}

};

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

// RasterRectAutoFillUndo

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

class VectorAutoFillUndo : public TToolUndo

{

	vector<tfilledregioninf> *m_regionFillInformation;</tfilledregioninf>

	TRectD m_selectionArea;

	TStroke *m_selectingStroke;

	bool m_unpaintedOnly;

	TFrameId m_onionFid;

	int m_row;

	int m_column;

public:

	~VectorAutoFillUndo()

	{

		if (m_regionFillInformation)

			delete m_regionFillInformation;

		if (m_selectingStroke)

			delete m_selectingStroke;

	}

	VectorAutoFillUndo(

		vector<tfilledregioninf> *regionFillInformation,</tfilledregioninf>

		TRectD selectionArea,

		TStroke *selectingStroke,

		bool unpaintedOnly,

		TXshSimpleLevel *sl,

		const TFrameId &fid,

		const TFrameId &onionFid)

		: TToolUndo(sl, fid), m_regionFillInformation(regionFillInformation), m_selectionArea(selectionArea), m_unpaintedOnly(unpaintedOnly), m_onionFid(onionFid)

	{

		m_selectingStroke = selectingStroke ? new TStroke(*selectingStroke) : 0;

	}

	void undo() const

	{

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

		if (!app)

			return;

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

		;

		assert(!!img);

		if (!img)

			return;

		if (m_regionFillInformation) {

			for (UINT i = 0; i < m_regionFillInformation->size(); i++) {

				TRegion *reg = img->getRegion((*m_regionFillInformation)[i].m_regionId);

				if (reg)

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

			}

		}

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

		notifyImageChanged();

	}

	void redo() const

	{

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

		if (!app)

			return;

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

		assert(img);

		if (!img)

			return;

		TVectorImageP onionImg = m_level->getFrame(m_onionFid, false);

		if (!onionImg)

			return;

		if (m_selectingStroke) {

			stroke_autofill_learn(onionImg, m_selectingStroke);

			stroke_autofill_apply(img, m_selectingStroke, m_unpaintedOnly);

		} else {

			rect_autofill_learn(onionImg, m_selectionArea);

			rect_autofill_apply(img, m_selectionArea, m_unpaintedOnly);

		}

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

		notifyImageChanged();

	}

	int getSize() const

	{

		int size = m_selectingStroke ? m_selectingStroke->getControlPointCount() * sizeof(TThickPoint) + 100 : 0;

		return sizeof(*this) + m_regionFillInformation->capacity() * sizeof(m_regionFillInformation) + 500 + size;

	}

};

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

void doRectAutofill(const TImageP &img, const TRectD selectingRect, bool onlyUnfilled, const OnionSkinMask &osMask,

					TXshSimpleLevel *sl, const TFrameId ¤tFid)

{

	TToonzImageP ti(img);

	TVectorImageP vi(img);

	if (!img || !sl)

		return;

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

	osMask.getAll(sl->guessIndex(currentFid), rows);

	if (rows.empty())

		return;

	TFrameId onionFid;

	int i;

	for (i = 0; i < (int)rows.size(); i++) {

		const TFrameId &app = sl->index2fid(rows[i]);

		if (app > currentFid)

			break;

		onionFid = app;

	}

	if (onionFid.isEmptyFrame())

		onionFid = sl->index2fid(rows[0]);

	if (onionFid.isEmptyFrame() || onionFid == currentFid || !sl->isFid(onionFid))

		return;

	if (ti) {

		TRect rect = ToonzImageUtils::convertWorldToRaster(selectingRect, ti);

		TToonzImageP onionImg(sl->getFrame(onionFid, false));

		if (!onionImg)

			return;

		TRect workRect = rect * ti->getRaster()->getBounds();

		if (workRect.isEmpty())

			return;

		rect_autofill_learn(onionImg,

							workRect.x0,

							workRect.y0,

							workRect.x1,

							workRect.y1);

		TTileSetCM32 *tileSet = new TTileSetCM32(ti->getRaster()->getSize());

		bool recomputeBBox = rect_autofill_apply(ti,

												 workRect.x0,

												 workRect.y0,

												 workRect.x1,

												 workRect.y1,

												 onlyUnfilled, tileSet);

		if (recomputeBBox)

			ToolUtils::updateSaveBox();

		if (tileSet->getTileCount() > 0)

			TUndoManager::manager()->add(new RasterRectAutoFillUndo(tileSet, workRect, sl, onlyUnfilled,

																	currentFid, onionFid));

	} else if (vi) {

		TVectorImageP onionImg(sl->getFrame(onionFid, false));

		if (!onionImg)

			return;

		vector<tfilledregioninf> *regionFillInformation = new vector<tfilledregioninf>;</tfilledregioninf></tfilledregioninf>

		ImageUtils::getFillingInformationInArea(vi, *regionFillInformation, selectingRect);

		onionImg->findRegions();

		vi->findRegions();

		rect_autofill_learn(onionImg, selectingRect);

		bool hasFilled = rect_autofill_apply(vi, selectingRect, onlyUnfilled);

		if (hasFilled)

			TUndoManager::manager()->add(new VectorAutoFillUndo(regionFillInformation, selectingRect, 0,

																onlyUnfilled, sl, currentFid, onionFid));

	}

}

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

void doStrokeAutofill(const TImageP &img, TStroke *selectingStroke, bool onlyUnfilled, const OnionSkinMask &osMask,

					  TXshSimpleLevel *sl, const TFrameId ¤tFid)

{

	TToonzImageP ti(img);

	TVectorImageP vi(img);

	if (!img || !sl)

		return;

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

	osMask.getAll(sl->guessIndex(currentFid), rows);

	if (rows.empty())

		return;

	TFrameId onionFid;

	int i;

	for (i = 0; i < (int)rows.size(); i++) {

		const TFrameId &app = sl->index2fid(rows[i]);

		if (app > currentFid)

			break;

		onionFid = app;

	}

	if (onionFid.isEmptyFrame())

		onionFid = sl->index2fid(rows[0]);

	if (onionFid.isEmptyFrame() || onionFid == currentFid || !sl->isFid(onionFid))

		return;

	if (ti) {

		TToonzImageP onionImg(sl->getFrame(onionFid, false));

		if (!onionImg)

			return;

		TRasterCM32P ras = onionImg->getRaster();

		TPointD center = ras->getCenterD();

		TPoint pos;

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

		TRect bbox = (image->getBounds() + pos).enlarge(2);

		pos = bbox.getP00();

		TRasterCM32P onionAppRas = ras->extract(bbox)->clone();

		TRasterCM32P tiAppRas = ti->getRaster()->extract(bbox)->clone();

		TRect workRect = onionAppRas->getBounds().enlarge(-1);

		TToonzImageP onionApp(onionAppRas, workRect);

		TToonzImageP tiApp(tiAppRas, workRect);

		ToonzImageUtils::eraseImage(onionApp, image, TPoint(2, 2), true, true, true, false, 1);

		ToonzImageUtils::eraseImage(tiApp, image, TPoint(2, 2), true, true, true, false, 1);

		rect_autofill_learn(onionApp,

							workRect.x0,

							workRect.y0,

							workRect.x1,

							workRect.y1);

		TTileSetCM32 *tileSet = new TTileSetCM32(ti->getRaster()->getSize());

		bool recomputeBBox = rect_autofill_apply(tiApp,

												 workRect.x0,

												 workRect.y0,

												 workRect.x1,

												 workRect.y1,

												 onlyUnfilled, tileSet);

		delete tileSet;

		tileSet = new TTileSetCM32(ti->getRaster()->getSize());

		tileSet->add(ti->getRaster(), bbox);

		RasterStrokeAutoFillUndo *undo = new RasterStrokeAutoFillUndo(tileSet, sl, currentFid);

		TRop::over(ti->getRaster(), tiAppRas, pos);

		TTileSetCM32 *newTileSet = new TTileSetCM32(ti->getRaster()->getSize());

		newTileSet->add(ti->getRaster(), bbox);

		undo->setTileSet(newTileSet);

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

	} else if (vi) {

		TVectorImageP onionImg(sl->getFrame(onionFid, false));

		if (!onionImg)

			return;

		vector<tfilledregioninf> *regionFillInformation = new vector<tfilledregioninf>;</tfilledregioninf></tfilledregioninf>

		ImageUtils::getFillingInformationInArea(vi, *regionFillInformation, selectingStroke->getBBox());

		onionImg->findRegions();

		vi->findRegions();

		stroke_autofill_learn(onionImg, selectingStroke);

		bool hasFilled = stroke_autofill_apply(vi, selectingStroke, onlyUnfilled);

		if (hasFilled)

			TUndoManager::manager()->add(new VectorAutoFillUndo(regionFillInformation, TRectD(), selectingStroke,

																onlyUnfilled, sl, currentFid, onionFid));

	}

}

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

// fillRectWithUndo

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

bool inline hasAutoInks(const TPalette *plt)

{

	for (int i = 0; i < plt->getStyleCount(); i++)

		if (plt->getStyle(i)->getFlags() != 0)

			return true;

	return false;

}

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

void fillAreaWithUndo(

	const TImageP &img,

	const TRectD &area,

	TStroke *stroke,

	bool onlyUnfilled,

	wstring colorType,

	TXshSimpleLevel *sl,

	const TFrameId &fid,

	int cs)

{

	TRectD selArea = stroke ? stroke->getBBox() : area;

	if (TToonzImageP ti = img) {

		//allargo di 1 la savebox, perche cosi' il rectfill di tutta l'immagine fa una sola fillata

		TRect enlargedSavebox = ti->getSavebox().enlarge(1) * TRect(TPoint(0, 0), ti->getSize());

		TRect rasterFillArea = ToonzImageUtils::convertWorldToRaster(selArea, ti) * enlargedSavebox;

		if (rasterFillArea.isEmpty())

			return;

		TRasterCM32P ras = ti->getRaster();

		/*-- tileSetでFill範囲のRectをUndoに格納しておく --*/

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

		tileSet->add(ras, rasterFillArea);

		AreaFiller filler(ti->getRaster());

		if (!stroke)

			filler.rectFill(rasterFillArea, cs, onlyUnfilled, colorType != LINES, colorType != AREAS);

		else

			filler.strokeFill(stroke, cs, onlyUnfilled, colorType != LINES, colorType != AREAS);

		TPalette *plt = ti->getPalette();

		if (plt && !hasAutoInks(plt))

			plt = 0;

		std::set<int> autoInks;</int>

		autoInks.insert(3);

		autoInks.insert(4);

		autoInks.insert(5);

		if (plt) {

			TRect rect = rasterFillArea;

			TRect bounds = ras->getBounds();

			if (bounds.overlaps(rect)) {

				rect *= bounds;

				const TTileSetCM32::Tile *tile = tileSet->getTile(tileSet->getTileCount() - 1);

				TRasterCM32P rbefore;

				tile->getRaster(rbefore);

				fillautoInks(ras, rect, rbefore, plt);

			}

		}

		ToolUtils::updateSaveBox(sl, fid);

		TUndoManager::manager()->add(new RasterRectFillUndo(tileSet, stroke,

															rasterFillArea,

															cs, sl, colorType,

															onlyUnfilled, fid, plt));

	} else if (TVectorImageP vi = img) {

		TPalette *palette = vi->getPalette();

		assert(palette);

		const TColorStyle *style = palette->getStyle(cs);

		//if( !style->isRegionStyle() )

		//return;

		vi->findRegions();

		vector<tfilledregioninf> *regionFillInformation = 0;</tfilledregioninf>

		vector<pair<int, int="">> *strokeFillInformation = 0;</pair<int,>

		if (colorType != LINES) {

			regionFillInformation = new vector<tfilledregioninf>;</tfilledregioninf>

			ImageUtils::getFillingInformationInArea(vi, *regionFillInformation, selArea);