#include "toonz/fxcommand.h"

// TnzLib includes

#include "toonz/txsheet.h"

#include "toonz/tcolumnfx.h"

#include "toonz/fxdag.h"

#include "toonz/tcolumnfxset.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshpalettecolumn.h"

#include "toonz/toonzscene.h"

#include "toonz/txsheethandle.h"

#include "toonz/tfxhandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tscenehandle.h"

#include "historytypes.h"

// TnzBase includes

#include "tparamcontainer.h"

#include "tparamset.h"

#include "tfxattributes.h"

#include "tmacrofx.h"

#include "tpassivecachemanager.h"

// TnzCore includes

#include "tundo.h"

#include "tconst.h"

// Qt includes

#include <qmap></qmap>

// tcg includes

#include "tcg/tcg_macros.h"

#include "tcg/tcg_base.h"

#include "tcg/tcg_function_types.h"

#include "tcg/tcg_iterator_ops.h"

#include <memory></memory>

/*

  Toonz currently has THREE different APIs to deal with scene objects commands:

    1. From the xsheet, see columncommand.cpp

    2. From the stage schematic

    3. From the fx schematic

  *This* is the one version that should 'rule them all' - we still have to

  unify them, though.

TODO:

  - Associated Stage Object copies when copying columns

  - Stage schematic currently ignored (eg delete columns undo)

  - Double-check macro fxs behavior

  - Double-check group behavior

  - Enforce dynamic link groups consistency

*/

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

//    Local Namespace  stuff

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

namespace

{

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

inline TFx *getActualIn(TFx *fx)

{

	TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx);</tzerarycolumnfx>

	return zcfx ? (assert(zcfx->getZeraryFx()), zcfx->getZeraryFx()) : fx;

}

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

inline TFx *getActualOut(TFx *fx)

{

	TZeraryFx *zfx = dynamic_cast<tzeraryfx *="">(fx);</tzeraryfx>

	return (zfx && zfx->getColumnFx()) ? zfx->getColumnFx() : fx;

}

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

inline int inputPortIndex(TFx *fx, TFxPort *port)

{

	int p, pCount = fx->getInputPortCount();

	for (p = 0; p != pCount; ++p)

		if (fx->getInputPort(p) == port)

			break;

	return p;

}

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

/*!

  Returns whether the specified fx is internal to a macro fx. Fxs

  inside a macro should not be affected by most editing commands - the

  macro is required to be exploded first.

*/

bool isInsideAMacroFx(TFx *fx, TXsheet *xsh)

{

	if (!fx)

		return false;

	TColumnFx *cfx = dynamic_cast<tcolumnfx *="">(fx);</tcolumnfx>

	TXsheetFx *xfx = dynamic_cast<txsheetfx *="">(fx);</txsheetfx>

	TOutputFx *ofx = dynamic_cast<toutputfx *="">(fx);</toutputfx>

	return !cfx && !xfx && !ofx &&

		   !(xsh->getFxDag()->getInternalFxs()->containsFx(fx));

}

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

template <typename paramcont=""></typename>

void setParamsToCurrentScene(TXsheet *xsh, const ParamCont *cont)

{

	for (int p = 0; p != cont->getParamCount(); ++p) {

		TParam ¶m = *cont->getParam(p);

		if (TDoubleParam *dp = dynamic_cast<tdoubleparam *="">(¶m))</tdoubleparam>

			xsh->getStageObjectTree()->setGrammar(dp);

		else if (TParamSet *paramSet = dynamic_cast<tparamset *="">(¶m))</tparamset>

			setParamsToCurrentScene(xsh, paramSet);

	}

}

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

inline void setFxParamToCurrentScene(TFx *fx, TXsheet *xsh)

{

	setParamsToCurrentScene(xsh, fx->getParams());

}

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

void initializeFx(TXsheet *xsh, TFx *fx)

{

	if (TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx))</tzerarycolumnfx>

		fx = zcfx->getZeraryFx();

	xsh->getFxDag()->assignUniqueId(fx);

	setFxParamToCurrentScene(fx, xsh);

}

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

void showFx(TXsheet *xsh, TFx *fx)

{

	fx->getAttributes()->setIsOpened(xsh->getFxDag()->getDagGridDimension() == 0);

	if (TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx))</tzerarycolumnfx>

		fx = zcfx->getZeraryFx();

	fx->getAttributes()->passiveCacheDataIdx() = -1;

}

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

void hideFx(TXsheet *xsh, TFx *fx)

{

	if (TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx))</tzerarycolumnfx>

		fx = zcfx->getZeraryFx();

	TPassiveCacheManager::instance()->disableCache(fx);

}

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

void addFxToCurrentScene(TFx *fx, TXsheet *xsh, bool isNewFx = true)

{

	if (isNewFx)

		initializeFx(xsh, fx);

	xsh->getFxDag()->getInternalFxs()->addFx(fx);

	showFx(xsh, fx);

}

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

void removeFxFromCurrentScene(TFx *fx, TXsheet *xsh)

{

	xsh->getFxDag()->getInternalFxs()->removeFx(fx);

	xsh->getFxDag()->getTerminalFxs()->removeFx(fx);

	hideFx(xsh, fx);

}

} // namespace

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

//    Filter Functors  definition

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

namespace

{

struct FilterInsideAMacro {

	TXsheet *m_xsh;

	inline bool operator()(const TFxP &fx)

	{

		return ::isInsideAMacroFx(fx.getPointer(), m_xsh);

	}

	inline bool operator()(const TFxCommand::Link &link)

	{

		return ::isInsideAMacroFx(link.m_inputFx.getPointer(), m_xsh) ||

			   ::isInsideAMacroFx(link.m_outputFx.getPointer(), m_xsh);

	}

};

struct FilterNonTerminalFxs {

	TXsheet *xsh;

	inline bool operator()(const TFxP &fx)

	{

		return !xsh->getFxDag()->getTerminalFxs()->containsFx(fx.getPointer());

	}

};

struct FilterTerminalFxs {

	TXsheet *xsh;

	inline bool operator()(const TFxP &fx)

	{

		return xsh->getFxDag()->getTerminalFxs()->containsFx(fx.getPointer());

	}

};

struct FilterColumnFxs {

	inline bool operator()(const TFxP &fx) { return dynamic_cast<tlevelcolumnfx *="">(fx.getPointer()); }</tlevelcolumnfx>

};

} // namespace

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

//    CloneFxFunctor  definition

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

namespace

{

struct CloneFxFunctor {

	TFxP m_src;

	bool m_ownsSrc;

	TFx *operator()()

	{

		if (m_ownsSrc)

			m_ownsSrc = false; // Transfer m_src and ownership if it

		else				   // was surrendered

		{

			assert(m_src->getRefCount() > 1); // We'll be linking params to the cloned

											  // fx - so it MUST NOT be destroyed on release

			TFx *src = m_src.getPointer();

			m_src = m_src->clone(false); // Duplicate and link parameters all

			m_src->linkParams(src);		 // the following times

		}

		return m_src.getPointer();

	}

};

} // namespace

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

//    FxCommandUndo  definition

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

class FxCommandUndo : public TUndo

{

public:

	virtual ~FxCommandUndo() {}

	virtual bool isConsistent() const = 0;

public:

	template <typename pred=""></typename>

	static TFx *leftmostConnectedFx(TFx *fx, Pred pred);

	template <typename pred=""></typename>

	static TFx *rightmostConnectedFx(TFx *fx, Pred pred);

	static TFx *leftmostConnectedFx(TFx *fx);

	static TFx *rightmostConnectedFx(TFx *fx);

	static std::vector<tfxcommand::link> inputLinks(TXsheet *xsh, TFx *fx);</tfxcommand::link>

	static std::vector<tfxcommand::link> outputLinks(TXsheet *xsh, TFx *fx);</tfxcommand::link>

	int getHistoryType() { return HistoryType::Schematic; }

protected:

	static TXshZeraryFxColumn *createZeraryFxColumn(TXsheet *xsh, TFx *zfx, int row = 0);

	static void cloneGroupStack(const QStack<int> &groupIds, const QStack<std::wstring> &groupNames, TFx *toFx);</std::wstring></int>

	static void cloneGroupStack(TFx *fromFx, TFx *toFx);

	static void copyGroupEditLevel(int editGroupId, TFx *toFx);

	static void copyGroupEditLevel(TFx *fromFx, TFx *toFx);

	static void copyDagPosition(TFx *fromFx, TFx *toFx);

	static void attach(TXsheet *xsh, TFx *inputFx, TFx *outputFx, int port, bool copyGroupData);

	static void attach(TXsheet *xsh, const TFxCommand::Link &link, bool copyGroupData);

	static void attachOutputs(TXsheet *xsh, TFx *insertedFx, TFx *inputFx);

	static void detachFxs(TXsheet *xsh, TFx *fxLeft, TFx *fxRight, bool detachLeft = true);

	static void insertFxs(TXsheet *xsh, const TFxCommand::Link &link, TFx *fxLeft, TFx *fxRight);

	static void insertColumn(TXsheet *xsh, TXshColumn *column, int colIdx,

							 bool removeHole = false, bool autoTerminal = false);

	static void removeFxOrColumn(TXsheet *xsh, TFx *fx, int colIdx,

								 bool insertHole = false, bool unlinkParams = true);

	static void linkParams(TFx *fx, TFx *linkedFx);

	static void unlinkParams(TFx *fx);

	static void makeNotCurrent(TFxHandle *fxHandle, TFx *fx);

private:

	static void removeColumn(TXsheet *xsh, int colIdx, bool insertHole);

	static void removeNormalFx(TXsheet *xsh, TFx *fx);

	static void removeOutputFx(TXsheet *xsh, TOutputFx *outputFx);

};

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

TXshZeraryFxColumn *FxCommandUndo::createZeraryFxColumn(TXsheet *xsh, TFx *zfx, int row)

{

	int frameCount = xsh->getScene()->getFrameCount() - row;

	TXshZeraryFxColumn *column = new TXshZeraryFxColumn(frameCount > 0 ? frameCount : 100);

	column->getZeraryColumnFx()->setZeraryFx(zfx);

	column->insertEmptyCells(0, row);

	return column;

}

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

void FxCommandUndo::cloneGroupStack(

	const QStack<int> &groupIds, const QStack<std::wstring> &groupNames, TFx *toFx)</std::wstring></int>

{

	toFx->getAttributes()->removeFromAllGroup();

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

		toFx->getAttributes()->setGroupId(groupIds[i]);

		toFx->getAttributes()->setGroupName(groupNames[i]);

	}

}

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

void FxCommandUndo::cloneGroupStack(TFx *fromFx, TFx *toFx)

{

	if (fromFx->getAttributes()->isGrouped()) {

		cloneGroupStack(fromFx->getAttributes()->getGroupIdStack(),

						fromFx->getAttributes()->getGroupNameStack(), toFx);

	}

}

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

void FxCommandUndo::copyGroupEditLevel(int editGroupId, TFx *toFx)

{

	toFx->getAttributes()->closeAllGroups();

	while (editGroupId != toFx->getAttributes()->getEditingGroupId() &&

		   toFx->getAttributes()->editGroup())

		;

	assert(editGroupId == toFx->getAttributes()->getEditingGroupId());

}

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

void FxCommandUndo::copyGroupEditLevel(TFx *fromFx, TFx *toFx)

{

	assert(toFx);

	if (fromFx && fromFx->getAttributes()->isGrouped())

		copyGroupEditLevel(fromFx->getAttributes()->getEditingGroupId(), toFx);

}

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

void FxCommandUndo::copyDagPosition(TFx *fromFx, TFx *toFx)

{

	assert(toFx);

	if (fromFx)

		toFx->getAttributes()->setDagNodePos(fromFx->getAttributes()->getDagNodePos());

}

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

void FxCommandUndo::attach(TXsheet *xsh, TFx *inputFx, TFx *outputFx, int link,

						   bool copyGroupData)

{

	if (outputFx) {

		FxDag *fxDag = xsh->getFxDag();

		inputFx = ::getActualOut(inputFx);

		outputFx = ::getActualIn(outputFx);

		if (inputFx && link < 0) {

			assert(dynamic_cast<txsheetfx *="">(outputFx));</txsheetfx>

			fxDag->addToXsheet(inputFx);

		} else {

			int ipCount = outputFx->getInputPortCount();

			if (ipCount > 0 && link < ipCount)

				outputFx->getInputPort(link)->setFx(inputFx);

			if (copyGroupData)

				copyGroupEditLevel(inputFx, outputFx);

		}

	}

}

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

void FxCommandUndo::attach(TXsheet *xsh, const TFxCommand::Link &link, bool copyGroupData)

{

	attach(xsh, link.m_inputFx.getPointer(), link.m_outputFx.getPointer(), link.m_index, copyGroupData);

}

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

void FxCommandUndo::attachOutputs(TXsheet *xsh, TFx *insertedFx, TFx *inputFx)

{

	TCG_ASSERT(inputFx, return );

	FxDag *fxDag = xsh->getFxDag();

	insertedFx = ::getActualOut(insertedFx);

	inputFx = ::getActualOut(inputFx);

	int p, pCount = inputFx->getOutputConnectionCount();

	for (p = pCount - 1; p >= 0; --p)					 // Backward iteration on output connections -

	{													 // it's necessary since TFxPort::setFx() REMOVES

		TFxPort *port = inputFx->getOutputConnection(p); // the corresponding port int the output connections

		port->setFx(insertedFx);						 // container - thus, it's better to start from the end

	}

	if (fxDag->getTerminalFxs()->containsFx(inputFx)) {

		fxDag->removeFromXsheet(inputFx);

		fxDag->addToXsheet(insertedFx);

	}

}

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

void FxCommandUndo::detachFxs(TXsheet *xsh, TFx *fxLeft, TFx *fxRight, bool detachLeft)

{

	assert(fxLeft && fxRight);

	fxLeft = ::getActualIn(fxLeft);

	fxRight = ::getActualOut(fxRight);

	int ipCount = fxLeft->getInputPortCount();

	// Redirect input/output ports

	TFx *inputFx0 = (ipCount > 0) ? fxLeft->getInputPort(0)->getFx() : 0;

	int p, opCount = fxRight->getOutputConnectionCount();

	for (p = opCount - 1; p >= 0; --p) // Backward iteration due to TFxPort::setFx()

	{

		TFxPort *outPort = fxRight->getOutputConnection(p);

		assert(outPort && outPort->getFx() == fxRight);

		outPort->setFx(inputFx0);

	}

	// Xsheet links redirection

	FxDag *fxDag = xsh->getFxDag();

	if (fxDag->getTerminalFxs()->containsFx(fxRight)) {

		fxDag->removeFromXsheet(fxRight);

		for (int p = 0; p != ipCount; ++p)

			if (TFx *inputFx = fxLeft->getInputPort(p)->getFx())

				fxDag->addToXsheet(inputFx);

	}

	if (detachLeft)

		fxLeft->disconnectAll();

}

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

void FxCommandUndo::insertFxs(TXsheet *xsh, const TFxCommand::Link &link,

							  TFx *fxLeft, TFx *fxRight)

{

	assert(fxLeft && fxRight);

	if (link.m_inputFx && link.m_outputFx) {

		FxCommandUndo::attach(xsh, link.m_inputFx.getPointer(), fxLeft, 0, false);

		FxCommandUndo::attach(xsh, fxRight, link.m_outputFx.getPointer(), link.m_index, false);

		if (link.m_index < 0)

			xsh->getFxDag()->removeFromXsheet(::getActualOut(link.m_inputFx.getPointer()));

	}

}

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

void FxCommandUndo::insertColumn(TXsheet *xsh, TXshColumn *column, int col,

								 bool removeHole, bool autoTerminal)

{

	FxDag *fxDag = xsh->getFxDag();

	TFx *fx = column->getFx();

	bool terminal = false;

	if (fx) {

		::showFx(xsh, fx);

		terminal = fxDag->getTerminalFxs()->containsFx(fx);

	}

	if (removeHole)

		xsh->removeColumn(col);

	xsh->insertColumn(col, column); // Attaches the fx to the xsheet, too -

									// but not if the column is a palette one.

	if (!autoTerminal) {

		// Preserve the initial terminal state.

		// This lets fxs to be linked to the xsheet while still hidden.

		fxDag->removeFromXsheet(fx);

		if (terminal)

			fxDag->addToXsheet(fx);

	}

	xsh->updateFrameCount();

}

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

void FxCommandUndo::removeColumn(TXsheet *xsh, int col, bool insertHole)

{

	if (TFx *colFx = xsh->getColumn(col)->getFx()) {

		detachFxs(xsh, colFx, colFx);

		::hideFx(xsh, colFx);

	}

	xsh->removeColumn(col);		// Already detaches any fx in output,

	if (insertHole)				// including the terminal case

		xsh->insertColumn(col); // Note that fxs in output are not

								// removed - just detached.

	xsh->updateFrameCount();

}

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

void FxCommandUndo::removeNormalFx(TXsheet *xsh, TFx *fx)

{

	detachFxs(xsh, fx, fx);

	::removeFxFromCurrentScene(fx, xsh); // Already hideFx()s

}

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

void FxCommandUndo::removeOutputFx(TXsheet *xsh, TOutputFx *outputFx)

{

	detachFxs(xsh, outputFx, outputFx);

	xsh->getFxDag()->removeOutputFx(outputFx);

}

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

void FxCommandUndo::linkParams(TFx *fx, TFx *linkedFx)

{

	if (linkedFx)

		::getActualIn(fx)->linkParams(::getActualIn(linkedFx));

}

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

void FxCommandUndo::unlinkParams(TFx *fx)

{

	if (fx = ::getActualIn(fx), fx->getLinkedFx())

		fx->unlinkParams();

}

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

void FxCommandUndo::makeNotCurrent(TFxHandle *fxHandle, TFx *fx)

{

	if (fx = ::getActualOut(fx), fx == fxHandle->getFx())

		fxHandle->setFx(0);

}

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

void FxCommandUndo::removeFxOrColumn(TXsheet *xsh, TFx *fx, int colIdx,

									 bool insertHole, bool unlinkParams)

{

	assert(fx || colIdx >= 0);

	if (!fx)

		fx = xsh->getColumn(colIdx)->getFx();

	else if (TColumnFx *colFx = dynamic_cast<tcolumnfx *="">(fx))</tcolumnfx>

		colIdx = colFx->getColumnIndex();

	else if (TZeraryFx *zfx = dynamic_cast<tzeraryfx *="">(fx)) {</tzeraryfx>

		if (zfx->getColumnFx())

			fx = zfx->getColumnFx(), colIdx = static_cast<tcolumnfx *="">(fx)->getColumnIndex();</tcolumnfx>

	}

	if (fx) {

		// Discriminate special fx types

		if (TZeraryColumnFx *zcfx = dynamic_cast<tzerarycolumnfx *="">(fx)) {</tzerarycolumnfx>

			// Removed as a column

			fx = zcfx->getZeraryFx();

		} else if (TOutputFx *outputFx = dynamic_cast<toutputfx *="">(fx)) {</toutputfx>

			assert(xsh->getFxDag()->getOutputFxCount() > 1);

			FxCommandUndo::removeOutputFx(xsh, outputFx);

		} else if (colIdx < 0)

			FxCommandUndo::removeNormalFx(xsh, fx);

		if (unlinkParams)

			FxCommandUndo::unlinkParams(fx);

	}

	if (colIdx >= 0)

		FxCommandUndo::removeColumn(xsh, colIdx, insertHole);

}

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

template <typename pred=""></typename>

TFx *FxCommandUndo::leftmostConnectedFx(TFx *fx, Pred pred)

{

	assert(fx);

	fx = rightmostConnectedFx(fx, pred); // The rightmost fx should be discovered first,

										 // then, we'll descend from that

	do {

		fx = ::getActualIn(fx);

		if (!((fx->getInputPortCount() > 0) &&

			  fx->getInputPort(0)->isConnected() &&

			  pred(fx->getInputPort(0)->getFx())))

			break;

		fx = fx->getInputPort(0)->getFx();

	} while (true);

	return fx;

}

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

template <typename pred=""></typename>

TFx *FxCommandUndo::rightmostConnectedFx(TFx *fx, Pred pred)

{

	assert(fx);

	do {

		fx = ::getActualOut(fx);

		if (!(fx->getOutputConnectionCount() > 0 &&

			  pred(fx->getOutputConnection(0)->getOwnerFx())))

			break;

		fx = fx->getOutputConnection(0)->getOwnerFx();

	} while (true);

	return fx;

}

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

namespace

{

struct True_pred {

	bool operator()(TFx *fx) { return true; }

};

}

TFx *FxCommandUndo::leftmostConnectedFx(TFx *fx)

{

	return leftmostConnectedFx(fx, ::True_pred());

}

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

TFx *FxCommandUndo::rightmostConnectedFx(TFx *fx)

{

	return rightmostConnectedFx(fx, ::True_pred());

}

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

std::vector<tfxcommand::link> FxCommandUndo::inputLinks(TXsheet *xsh, TFx *fx)</tfxcommand::link>

{

	std::vector<tfxcommand::link> result;</tfxcommand::link>

	fx = ::getActualIn(fx);

	int il, ilCount = fx->getInputPortCount();

	for (il = 0; il != ilCount; ++il) {

		TFxPort *port = fx->getInputPort(il);

		assert(port);

		if (port->isConnected())

			result.push_back(TFxCommand::Link(port->getFx(), fx, il));

	}

	return result;

}

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

std::vector<tfxcommand::link> FxCommandUndo::outputLinks(TXsheet *xsh, TFx *fx)</tfxcommand::link>

{

	std::vector<tfxcommand::link> result;</tfxcommand::link>

	fx = ::getActualOut(fx);

	int ol, olCount = fx->getOutputConnectionCount();

	for (ol = 0; ol != olCount; ++ol) {

		TFxPort *port = fx->getOutputConnection(ol);

		TFx *ownerFx = port->getOwnerFx();

		int portIndex = ::inputPortIndex(ownerFx, port);

		result.push_back(TFxCommand::Link(fx, ownerFx, portIndex));

	}

	FxDag *fxDag = xsh->getFxDag();

	if (fxDag->getTerminalFxs()->containsFx(fx))

		result.push_back(TFxCommand::Link(fx, fxDag->getXsheetFx(), -1));

	return result;

}

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

//    Insert Fx  command

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

class InsertFxUndo : public FxCommandUndo

{

	QList<tfxp> m_selectedFxs;</tfxp>

	QList<tfxcommand::link> m_selectedLinks;</tfxcommand::link>

	TApplication *m_app;

	QList<tfxp> m_insertedFxs;</tfxp>

	TXshZeraryFxColumnP m_insertedColumn;

	int m_colIdx;

	bool m_columnReplacesHole;

	bool m_attachOutputs;

public:

	InsertFxUndo(const TFxP &fx, int row, int col,

				 const QList<tfxp> &selectedFxs, QList<tfxcommand::link> selectedLinks,</tfxcommand::link></tfxp>

				 TApplication *app, bool attachOutputs = true)

		: m_selectedFxs(selectedFxs), m_selectedLinks(selectedLinks), m_insertedColumn(0), m_app(app), m_colIdx(col), m_columnReplacesHole(false), m_attachOutputs(attachOutputs)

	{

		initialize(fx, row, col);

	}

	bool isConsistent() const { return !m_insertedFxs.isEmpty(); }

	void redo() const;

	void undo() const;

	int getSize() const { return sizeof(*this); }

	QString getHistoryString();

private:

	void initialize(const TFxP &newFx, int row, int col);

};

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

inline bool has_fx_column(TFx *fx)

{

	if (TPluginInterface *plgif = dynamic_cast<tplugininterface *="">(fx))</tplugininterface>

		return plgif->isPluginZerary();

	else if (TZeraryFx *zfx = dynamic_cast<tzeraryfx *="">(fx))</tzeraryfx>

		return zfx->isZerary();

	return false;

}

namespace

{

bool containsInputFx(const QList<tfxp> &fxs, const TFxCommand::Link &link)</tfxp>

{

	return fxs.contains(link.m_inputFx);

}

typedef tcg::function<bool (*)(const="" qlist<tfxp=""> &, const TFxCommand::Link &), containsInputFx> ContainsInputFx_fun;</bool>

} // namespace

void InsertFxUndo::initialize(const TFxP &newFx, int row, int col)

{

	struct Locals {

		InsertFxUndo *m_this;

		inline void storeFx(TXsheet *xsh, TFx *fx)

		{

			::initializeFx(xsh, fx);

			m_this->m_insertedFxs.push_back(fx);

		}

	} locals = {this};

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

	TFx *fx = newFx.getPointer();

	assert(!dynamic_cast<tzerarycolumnfx *="">(fx));</tzerarycolumnfx>

	TZeraryFx *zfx = dynamic_cast<tzeraryfx *="">(fx);</tzeraryfx>

	if (has_fx_column(fx)) {

		m_insertedColumn = InsertFxUndo::createZeraryFxColumn(xsh, fx, row);

		locals.storeFx(xsh, fx);

		if (xsh->getColumn(col) && xsh->getColumn(col)->isEmpty())

			m_columnReplacesHole = true;

	} else {

		if (m_selectedFxs.isEmpty() && m_selectedLinks.isEmpty()) {

			// Attempt retrieval of current Fx from the fxHandle

			if (TFx *currentFx = m_app->getCurrentFx()->getFx())

				m_selectedFxs.push_back(currentFx);

			else {

				// Isolated case

				locals.storeFx(xsh, fx);

				return;

			}

		}

		// Remove all unacceptable input fxs

		::FilterInsideAMacro filterInMacroFxs = {xsh};

		m_selectedFxs.erase(std::remove_if(m_selectedFxs.begin(), m_selectedFxs.end(), filterInMacroFxs),

							m_selectedFxs.end());

		// Remove all unacceptable links or links whose input fx was already selected

		m_selectedLinks.erase(std::remove_if(m_selectedLinks.begin(), m_selectedLinks.end(), filterInMacroFxs),

							  m_selectedLinks.end());

		m_selectedLinks.erase(std::remove_if(m_selectedLinks.begin(), m_selectedLinks.end(),

											 tcg::bind1st(::ContainsInputFx_fun(), m_selectedFxs)),

							  m_selectedLinks.end());

		// Build an fx for each of the specified inputs

		::CloneFxFunctor cloneFx = {fx, true};

		int f, fCount = m_selectedFxs.size();

		for (f = 0; f != fCount; ++f) {

			TFx *fx = cloneFx();

			FxCommandUndo::cloneGroupStack(m_selectedFxs[f].getPointer(), fx);

			locals.storeFx(xsh, fx);

		}

		fCount = m_selectedLinks.size();

		for (f = 0; f != fCount; ++f) {

			TFx *fx = cloneFx();

			FxCommandUndo::cloneGroupStack(m_selectedLinks[f].m_inputFx.getPointer(), fx);

			locals.storeFx(xsh, fx);

		}

	}

}

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

void InsertFxUndo::redo() const

{

	struct OnExit {

		const InsertFxUndo *m_this;

		~OnExit()

		{

			m_this->m_app->getCurrentFx()->setFx(m_this->m_insertedFxs.back().getPointer());

			m_this->m_app->getCurrentXsheet()->notifyXsheetChanged();

			m_this->m_app->getCurrentScene()->setDirtyFlag(true);

		}

	} onExit = {this};

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

	// Zerary case

	if (m_insertedColumn) {

		FxCommandUndo::insertColumn(

			xsh, m_insertedColumn.getPointer(), m_colIdx, m_columnReplacesHole, true);

		return;

	}

	// Isolated Fx case

	if (m_selectedLinks.isEmpty() && m_selectedFxs.isEmpty()) {

		assert(m_insertedFxs.size() == 1);

		::addFxToCurrentScene(m_insertedFxs.back().getPointer(), xsh, false); // Already showFx()s

	} else {

		// Selected links