#include "toonzqt/fxschematicscene.h"

// TnzQt includes

#include "toonzqt/fxschematicnode.h"

#include "toonzqt/gutil.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/fxselection.h"

#include "toonzqt/schematicgroupeditor.h"

#include "toonzqt/swatchviewer.h"

#include "toonzqt/tselectionhandle.h"

// TnzLib includes

#include "toonz/txsheet.h"

#include "toonz/toonzscene.h"

#include "toonz/tcolumnfxset.h"

#include "toonz/fxdag.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/tcolumnfx.h"

#include "toonz/txshpalettecolumn.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/fxcommand.h"

#include "toonz/txsheethandle.h"

#include "toonz/tfxhandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tframehandle.h"

#include "toonz/tobjecthandle.h"

// TnzBase includes

#include "tmacrofx.h"

#include "fxdata.h"

#include "tpassivecachemanager.h"

#include "tfxattributes.h"

// TnzCore includes

#include "tconst.h"

// Qt includes

#include <qmenu></qmenu>

#include <qapplication></qapplication>

#include <qgraphicsscenecontextmenuevent></qgraphicsscenecontextmenuevent>

namespace

{

class MatchesFx

{

	TFxP m_fx;

public:

	MatchesFx(const TFxP &fx) : m_fx(fx) {}

	bool operator()(const TFxP &fx)

	{

		TZeraryColumnFx *zfx = dynamic_cast<tzerarycolumnfx *="">(fx.getPointer());</tzerarycolumnfx>

		return (m_fx.getPointer() == fx.getPointer()) || (zfx && m_fx.getPointer() == zfx->getZeraryFx());

	}

};

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

void keepSubgroup(QMap<int, *="" qlist<schematicnode="">> &editedGroup)</int,>

{

	QMap<int, *="" qlist<schematicnode="">>::iterator it;</int,>

	for (it = editedGroup.begin(); it != editedGroup.end(); it++) {

		QList<schematicnode *=""> groupedNodes = it.value();</schematicnode>

		int i;

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

			FxSchematicNode *node = dynamic_cast<fxschematicnode *="">(groupedNodes[i]);</fxschematicnode>

			if (!node)

				continue;

			TFx *fx = node->getFx();

			assert(fx);

			QMap<int, *="" qlist<schematicnode="">>::iterator it2;</int,>

			for (it2 = editedGroup.begin(); it2 != editedGroup.end(); it2++) {

				if (fx->getAttributes()->isContainedInGroup(it2.key()) &&

					!editedGroup[it2.key()].contains(node))

					editedGroup[it2.key()].append(node);

			}

		}

	}

}

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

//! Find the input and the output fx contained in \b visitedFxs.

//! \b visitedFxs must be a connected fx selection. In \b outputFx is put the root of the connected fx selection.

//! In \b inputFx is put a leaf of the connected fx selection.

void findBoundariesFxs(TFx *&inputFx, TFx *&outputFx, QMap<tfx *,="" bool=""> &visitedFxs, TFx *currentFx = 0)</tfx>

{

	if (visitedFxs.isEmpty())

		return;

	if (!currentFx)

		currentFx = visitedFxs.begin().key();

	int inputPortCount = currentFx->getInputPortCount();

	int outputConnectionCount = currentFx->getOutputConnectionCount();

	if (inputPortCount > 0 && !visitedFxs[currentFx]) {

		visitedFxs[currentFx] = true;

		TFxPort *fxPort = currentFx->getInputPort(0);

		TFx *fx = fxPort->getFx();

		if (fx && visitedFxs.count(fx) == 1) {

			if (!visitedFxs[fx])

				findBoundariesFxs(inputFx, outputFx, visitedFxs, fx);

		} else

			inputFx = currentFx;

	} else

		inputFx = currentFx;

	if (!outputFx) {

		if (outputConnectionCount > 0) {

			TFx *fx = currentFx->getOutputConnection(0)->getOwnerFx();

			if (fx && visitedFxs.count(fx) == 1) {

				if (!visitedFxs[fx])

					findBoundariesFxs(inputFx, outputFx, visitedFxs, fx);

			} else

				outputFx = currentFx;

		} else

			outputFx = currentFx;

	}

}

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

bool canDisconnectSelection(FxSelection *selection)

{

	QList<tfxp> selectedFx = selection->getFxs();</tfxp>

	int i;

	for (i = 0; i < selectedFx.size(); i++) // .....

	{

		TFx *fx = selectedFx[i].getPointer();

		TLevelColumnFx *lcFx = dynamic_cast<tlevelcolumnfx *="">(fx);</tlevelcolumnfx>

		TPaletteColumnFx *pfx = dynamic_cast<tpalettecolumnfx *="">(fx);</tpalettecolumnfx>

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

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

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

		return (!lcFx && !pfx && !xfx && !ofx && (!zfx || zfx->getInputPortCount() > 0)); // !!!!!

	}

	return false;

}

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

QList<tfxp> getRoots(const QList<tfxp> &fxs, TFxSet *terminals)</tfxp></tfxp>

{

	QList<tfxp> roots;</tfxp>

	int i;

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

		TFx *fx = fxs[i].getPointer();

		int j;

		bool isRoot = true;

		for (j = 0; j < fx->getOutputConnectionCount(); j++) {

			TFx *outFx = fx->getOutputConnection(j)->getOwnerFx();

			if (outFx && std::find_if(fxs.begin(), fxs.end(), MatchesFx(outFx)) != fxs.end() &&

				!terminals->containsFx(fx))

				isRoot = false;

		}

		if (isRoot)

			roots.append(fx);

	}

	return roots;

}

} // namespace

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

//

// FxSchematicScene::SupportLinks

//

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

void FxSchematicScene::SupportLinks::addBridgeLink(SchematicLink *link)

{

	if (link && !m_bridges.contains(link))

		m_bridges.push_back(link);

}

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

void FxSchematicScene::SupportLinks::addOutputLink(SchematicLink *link)

{

	if (link && !m_outputs.contains(link))

		m_outputs.push_back(link);

}

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

void FxSchematicScene::SupportLinks::addInputLink(SchematicLink *link)

{

	if (link && !m_inputs.contains(link))

		m_inputs.push_back(link);

}

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

void FxSchematicScene::SupportLinks::hideBridgeLinks()

{

	int i;

	for (i = 0; i < m_bridges.size(); i++)

		m_bridges[i]->hide();

}

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

void FxSchematicScene::SupportLinks::hideInputLinks()

{

	int i;

	for (i = 0; i < m_inputs.size(); i++)

		m_inputs[i]->hide();

}

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

void FxSchematicScene::SupportLinks::hideOutputLinks()

{

	int i;

	for (i = 0; i < m_outputs.size(); i++)

		m_outputs[i]->hide();

}

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

void FxSchematicScene::SupportLinks::showBridgeLinks()

{

	int i;

	for (i = 0; i < m_bridges.size(); i++)

		m_bridges[i]->show();

}

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

void FxSchematicScene::SupportLinks::showInputLinks()

{

	int i;

	for (i = 0; i < m_inputs.size(); i++)

		m_inputs[i]->show();

}

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

void FxSchematicScene::SupportLinks::showOutputLinks()

{

	int i;

	for (i = 0; i < m_outputs.size(); i++)

		m_outputs[i]->show();

}

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

void FxSchematicScene::SupportLinks::removeBridgeLinks(bool deleteLink)

{

	int i;

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

		SchematicLink *link = m_bridges[i];

		m_bridges.removeAt(i);

		if (deleteLink) {

			link->getStartPort()->removeLink(link);

			link->getEndPort()->removeLink(link);

			delete link;

		}

	}

}

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

void FxSchematicScene::SupportLinks::removeInputLinks(bool deleteLink)

{

	int i;

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

		SchematicLink *link = m_inputs[i];

		m_inputs.removeAt(i);

		if (deleteLink) {

			link->getStartPort()->removeLink(link);

			link->getEndPort()->removeLink(link);

			delete link;

		}

	}

}

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

void FxSchematicScene::SupportLinks::removeOutputLinks(bool deleteLink)

{

	int i;

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

		SchematicLink *link = m_outputs[i];

		m_outputs.removeAt(i);

		if (deleteLink) {

			link->getStartPort()->removeLink(link);

			link->getEndPort()->removeLink(link);

			delete link;

		}

	}

}

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

void FxSchematicScene::SupportLinks::clearAll()

{

	m_bridges.clear();

	m_inputs.clear();

	m_outputs.clear();

}

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

int FxSchematicScene::SupportLinks::size()

{

	return m_bridges.size() + m_inputs.size() + m_outputs.size();

}

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

//

// FxSchematicScene

//

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

FxSchematicScene::FxSchematicScene(QWidget *parent)

	: SchematicScene(parent), m_firstPoint(sceneRect().center()), m_xshHandle(0), m_fxHandle(0), m_addFxContextMenu(), m_disconnectionLinks(), m_connectionLinks(), m_isConnected(false), m_linkUnlinkSimulation(false), m_altPressed(false), m_lastPos(0, 0), m_currentFxNode(0), m_gridDimension(eSmall), m_isLargeScaled(true)

{

	m_selection = new FxSelection();

	m_selection->setFxSchematicScene(this);

	connect(m_selection, SIGNAL(doCollapse(const QList<tfxp> &)), this, SLOT(onCollapse(const QList<tfxp> &)));</tfxp></tfxp>

	connect(m_selection, SIGNAL(doExplodeChild(const QList<tfxp> &)), this, SIGNAL(doExplodeChild(const QList<tfxp> &)));</tfxp></tfxp>

	connect(this, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));

	m_addFxContextMenu.setSelection(m_selection);

	m_highlightedLinks.clear();

}

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

FxSchematicScene::~FxSchematicScene()

{

	if (m_selection)

		delete m_selection;

}

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

void FxSchematicScene::setApplication(TApplication *app)

{

	m_app = app;

	m_xshHandle = app->getCurrentXsheet();

	m_fxHandle = app->getCurrentFx();

	m_frameHandle = app->getCurrentFrame();

	m_columnHandle = app->getCurrentColumn();

	if (m_fxHandle)

		connect(m_fxHandle, SIGNAL(fxSwitched()), this, SLOT(onCurrentFxSwitched()));

	m_addFxContextMenu.setApplication(app);

	m_selection->setXsheetHandle(m_xshHandle);

	m_selection->setFxHandle(m_fxHandle);

}

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

void FxSchematicScene::updateScene()

{

	if (!views().empty())

#if QT_VERSION >= 0x050000

		m_isLargeScaled = views().at(0)->matrix().determinant() >= 1.0;

#else

		m_isLargeScaled = views().at(0)->matrix().det() >= 1.0;

#endif

	m_disconnectionLinks.clearAll();

	m_connectionLinks.clearAll();

	m_selectionOldPos.clear();

	clearSelection();

	clearAllItems();

	m_table.clear();

	m_groupedTable.clear();

	m_groupEditorTable.clear();

	m_macroEditorTable.clear();

	m_currentFxNode = 0;

	// GroupId->Fx

	QMap<int, qlist<tfxp="">> groupedFxs;</int,>

	QMap<int, *="" qlist<schematicnode="">> editedGroup;</int,>

	QMap<tmacrofx *="" *,="" qlist<schematicnode="">> editedMacro;</tmacrofx>

	TXsheet *xsh = m_xshHandle->getXsheet();

	m_gridDimension = xsh->getFxDag()->getDagGridDimension();

	TFxSet *fxSet = xsh->getFxDag()->getInternalFxs();

	int i;

	FxDag *fxDag = xsh->getFxDag();

	//Add XSheetFX node

	addFxSchematicNode(fxDag->getXsheetFx());

	//Add outputFx nodes

	int k;

	for (k = 0; k < fxDag->getOutputFxCount(); k++) {

		TOutputFx *fx = fxDag->getOutputFx(k);

		if (fx->getAttributes()->isGrouped() && !fx->getAttributes()->isGroupEditing()) {

			groupedFxs[fx->getAttributes()->getGroupId()].push_back(fx);

			continue;

		}

		SchematicNode *node = addFxSchematicNode(fx);

		if (fx->getAttributes()->isGrouped())

			editedGroup[fx->getAttributes()->getEditingGroupId()].append(node);

	}

	//Add columnFx and zeraryFx nodes

	for (i = 0; i < xsh->getColumnCount(); i++) {

		TXshColumn *column = xsh->getColumn(i);

		TFx *fx = 0;

		if (TXshLevelColumn *lc = column->getLevelColumn())

			fx = lc->getLevelColumnFx();

		else if (TXshPaletteColumn *pc = dynamic_cast<txshpalettecolumn *="">(column))</txshpalettecolumn>

			fx = pc->getPaletteColumnFx();

		else if (TXshZeraryFxColumn *zc = dynamic_cast<txshzeraryfxcolumn *="">(column))</txshzeraryfxcolumn>

			fx = zc->getZeraryColumnFx();

		if (!fx)

			continue;

		if (fx->getAttributes()->isGrouped() && !fx->getAttributes()->isGroupEditing()) {

			groupedFxs[fx->getAttributes()->getGroupId()].push_back(fx);

			continue;

		}

		if (column->isEmpty() && fx && fx->getOutputConnectionCount() == 0)

			continue;

		SchematicNode *node = addFxSchematicNode(fx);

		if (fx->getAttributes()->isGrouped())

			editedGroup[fx->getAttributes()->getEditingGroupId()].append(node);

	}

	//Add normalFx

	for (i = 0; i < fxSet->getFxCount(); i++) {

		TFx *fx = fxSet->getFx(i);

		TMacroFx *macro = dynamic_cast<tmacrofx *="">(fx);</tmacrofx>

		if (fx->getAttributes()->isGrouped() && !fx->getAttributes()->isGroupEditing()) {

			groupedFxs[fx->getAttributes()->getGroupId()].push_back(fx);

			continue;

		} else if (macro && macro->isEditing()) {

			vector<tfxp> fxs = macro->getFxs();</tfxp>

			int j;

			for (j = 0; j < (int)fxs.size(); j++) {

				SchematicNode *node = addFxSchematicNode(fxs[j].getPointer());

				editedMacro[macro].append(node);

				if (fxs[j]->getAttributes()->isGrouped() && macro->getAttributes()->isGroupEditing())

					editedGroup[fx->getAttributes()->getEditingGroupId()].append(node);

			}

			continue;

		}

		SchematicNode *node = addFxSchematicNode(fx);

		if (fx->getAttributes()->isGrouped())

			editedGroup[fx->getAttributes()->getEditingGroupId()].append(node);

	}

	//grouped node

	QMap<int, qlist<tfxp="">>::const_iterator it;</int,>

	for (it = groupedFxs.begin(); it != groupedFxs.end(); it++) {

		FxSchematicNode *node = addGroupedFxSchematicNode(it.key(), it.value());

		TFx *fx = node->getFx();

		assert(fx);

		int editingGroupId = fx->getAttributes()->getEditingGroupId();

		if (editingGroupId != -1)

			editedGroup[editingGroupId].append(node);

	}

	keepSubgroup(editedGroup);

	updateEditedGroups(editedGroup);

	updateEditedMacros(editedMacro);

	updateLink();

	m_nodesToPlace.clear();

}

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

void FxSchematicScene::updateEditedGroups(const QMap<int, *="" qlist<schematicnode="">> &editedGroup)</int,>

{

	QMap<int, *="" qlist<schematicnode="">>::const_iterator it;</int,>

	for (it = editedGroup.begin(); it != editedGroup.end(); it++) {

		int zValue = 2;

		QMap<int, *="" qlist<schematicnode="">>::const_iterator it2 = editedGroup.begin();</int,>

		while (it2 != editedGroup.end()) {

			FxSchematicNode *placedFxNode = dynamic_cast<fxschematicnode *="">(it2.value()[0]);</fxschematicnode>

			FxSchematicNode *fxNode = dynamic_cast<fxschematicnode *="">(it.value()[0]);</fxschematicnode>

			if (!placedFxNode || !fxNode) {

				it2++;

				continue;

			}

			int placedGroupedId = placedFxNode->getFx()->getAttributes()->getEditingGroupId();

			if (fxNode->getFx()->getAttributes()->isContainedInGroup(placedGroupedId) &&

				fxNode->getFx()->getAttributes()->getEditingGroupId() != it2.key())

				zValue += 2;

			it2++;

		}

		FxSchematicGroupEditor *node = addEditedGroupedFxSchematicNode(it.key(), it.value());

		node->setZValue(zValue);

		node->setGroupedNodeZValue(zValue + 1);

	}

}

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

void FxSchematicScene::updateEditedMacros(const QMap<tmacrofx *="" *,="" qlist<schematicnode="">> &editedMacro)</tmacrofx>

{

	QMap<tmacrofx *="" *,="" qlist<schematicnode="">>::const_iterator it;</tmacrofx>

	for (it = editedMacro.begin(); it != editedMacro.end(); it++) {

		TMacroFx *macro = it.key();

		int zValue = 2;

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

			FxSchematicGroupEditor *containingGroup = m_groupEditorTable[macro->getAttributes()->getEditingGroupId()];

			assert(containingGroup);

			zValue = containingGroup->zValue() + 2;

		}

		FxSchematicMacroEditor *node = addEditedMacroFxSchematicNode(it.key(), it.value());

		node->setZValue(zValue);

		node->setGroupedNodeZValue(zValue + 1);

	}

}

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

FxSchematicNode *FxSchematicScene::addFxSchematicNode(TFx *fx)

{

	FxSchematicNode *node = createFxSchematicNode(fx);

	if (!node)

		return 0;

	connect(node, SIGNAL(sceneChanged()), this, SLOT(onSceneChanged()));

	connect(node, SIGNAL(xsheetChanged()), this, SLOT(onXsheetChanged()));

	connect(node, SIGNAL(switchCurrentFx(TFx *)), this, SLOT(onSwitchCurrentFx(TFx *)));

	connect(node, SIGNAL(currentColumnChanged(int)), this, SLOT(onCurrentColumnChanged(int)));

	connect(node, SIGNAL(fxNodeDoubleClicked()), this, SLOT(onFxNodeDoubleClicked()));

	if (fx->getAttributes()->getDagNodePos() == TConst::nowhere) {

		node->resize(m_gridDimension == 0);

		placeNode(node);

	} else

		updatePosition(node, fx->getAttributes()->getDagNodePos());

	m_table[fx] = node;

	return node;

}

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

FxSchematicNode *FxSchematicScene::addGroupedFxSchematicNode(int groupId, const QList<tfxp> &groupedFxs)</tfxp>

{

	TFxSet *terminals = getXsheet()->getFxDag()->getTerminalFxs();

	QList<tfxp> roots = getRoots(groupedFxs, terminals);</tfxp>

	if (roots.isEmpty())

		return 0;

	wstring name = roots[0]->getAttributes()->getGroupName(false);

	FxGroupNode *node = new FxGroupNode(this, groupedFxs, roots, groupId, name);

	if (!node)

		return 0;

	connect(node, SIGNAL(sceneChanged()), this, SLOT(onSceneChanged()));

	connect(node, SIGNAL(xsheetChanged()), this, SLOT(onXsheetChanged()));

	connect(node, SIGNAL(switchCurrentFx(TFx *)), this, SLOT(onSwitchCurrentFx(TFx *)));

	connect(node, SIGNAL(currentColumnChanged(int)), this, SLOT(onCurrentColumnChanged(int)));

	m_groupedTable[groupId] = node;

	return node;

}

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

FxSchematicGroupEditor *FxSchematicScene::addEditedGroupedFxSchematicNode(int groupId,

																		  const QList<schematicnode *=""> &groupedFxs)</schematicnode>

{

	FxSchematicGroupEditor *editorGroup = new FxSchematicGroupEditor(groupId, groupedFxs, this);

	m_groupEditorTable[groupId] = editorGroup;

	return editorGroup;

}

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

FxSchematicMacroEditor *FxSchematicScene::addEditedMacroFxSchematicNode(TMacroFx *macro, const QList<schematicnode *=""> &groupedFxs)</schematicnode>

{

	FxSchematicMacroEditor *editorMacro = new FxSchematicMacroEditor(macro, groupedFxs, this);

	m_macroEditorTable[macro] = editorMacro;

	return editorMacro;

}

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

void FxSchematicScene::updatePosition(FxSchematicNode *node, const TPointD &pos)

{

	node->setPos(QPointF(pos.x, pos.y));

	node->getFx()->getAttributes()->setDagNodePos(pos);

	QVector<schematicnode *=""> placedNodes = getPlacedNode(node);</schematicnode>

	int step = m_gridDimension == eLarge ? 100 : 50;

	TPointD offset(0, -step);

	int i;

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

		FxSchematicNode *placedNode = dynamic_cast<fxschematicnode *="">(placedNodes[i]);</fxschematicnode>

		assert(placedNode);

		TPointD newPos = placedNode->getFx()->getAttributes()->getDagNodePos() + offset;

		updatePosition(placedNode, newPos);

	}

}

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

/*! create node depends on the fx type

*/

FxSchematicNode *FxSchematicScene::createFxSchematicNode(TFx *fx)

{

	if (TLevelColumnFx *lcFx = dynamic_cast<tlevelcolumnfx *="">(fx))</tlevelcolumnfx>

		return new FxSchematicColumnNode(this, lcFx);

	else if (TPaletteColumnFx *pfx = dynamic_cast<tpalettecolumnfx *="">(fx))</tpalettecolumnfx>

		return new FxSchematicPaletteNode(this, pfx);

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

		return new FxSchematicZeraryNode(this, zfx);

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

		return new FxSchematicXSheetNode(this, xfx);

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

		return new FxSchematicOutputNode(this, ofx);

	else

		return new FxSchematicNormalFxNode(this, fx);

}

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

/*! place nodes of which positions are not specified manually

*/

void FxSchematicScene::placeNode(FxSchematicNode *node)

{

	if (!node)

		return;

	int step = m_gridDimension == eLarge ? 100 : 50;

	FxDag *fxDag = m_xshHandle->getXsheet()->getFxDag();

	QRectF nodeRect = node->boundingRect();

	if (node->isA(eOutpuFx)) {

		//I'm placing an output node

		TFx *xsheetFx = fxDag->getXsheetFx();

		TFxPort *outPort = xsheetFx->getOutputConnection(0);

		TFx *connectedOutput = outPort ? outPort->getOwnerFx() : 0;

		if (connectedOutput && connectedOutput == node->getFx()) {

			//The output node is connected to the xsheet node

			TPointD pos = xsheetFx->getAttributes()->getDagNodePos();

			if (pos != TConst::nowhere)

				nodeRect.translate(pos.x + 120, pos.y);

			else

				nodeRect.translate(sceneRect().center());

			while (!isAnEmptyZone(nodeRect))

				nodeRect.translate(0, step);

		} else {

			//The output node is not connected to the xsheet node

			TFx *fx = node->getFx();

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

			TFx *inputFx = port->getFx();

			if (inputFx) {

				//The output node is connected to another node

				TPointD pos = inputFx->getAttributes()->getDagNodePos();

				if (pos != TConst::nowhere)

					nodeRect.translate(pos.x + 120, pos.y);

				else {

					m_nodesToPlace[inputFx].append(node);

					return;

				}

			} else {

				//The output node is not connected

				QPointF pos = sceneRect().center();

				nodeRect.translate(pos);

			}

		}

		while (!isAnEmptyZone(nodeRect))

			nodeRect.translate(0, step);

		QPointF newPos = nodeRect.topLeft();

		node->getFx()->getAttributes()->setDagNodePos(TPointD(newPos.x(), newPos.y()));

		node->setPos(newPos);

		return;

	} else if (node->isA(eXSheetFx)) {

		//I'm placing the xsheet node

		TFxSet *terminalFxs = fxDag->getTerminalFxs();

		int i;

		double maxX = m_firstPoint.x();

		for (i = 0; i < terminalFxs->getFxCount(); i++) {

			TFx *terminalFx = terminalFxs->getFx(i);

			if (terminalFx->getAttributes()->getDagNodePos() == TConst::nowhere)

				continue;

			maxX = tmax(maxX, terminalFx->getAttributes()->getDagNodePos().x);

		}

		TPointD oldPos = node->getFx()->getAttributes()->getDagNodePos();

		QPointF pos;

		if (oldPos == TConst::nowhere)

			pos = QPointF(maxX + 120, m_firstPoint.y());

		else

			pos = QPointF(maxX + 120 > oldPos.x ? maxX + 120 : oldPos.x, oldPos.y);

		node->getFx()->getAttributes()->setDagNodePos(TPointD(pos.x(), pos.y()));

		node->setPos(pos);

		return;

	} else if (node->isA(eMacroFx) || node->isA(eNormalFx) ||

			   node->isA(eNormalLayerBlendingFx) || node->isA(eNormalMatteFx) || node->isA(eNormalImageAdjustFx)) {

		//I'm placing an effect or a macro

		TFx *inputFx = node->getFx()->getInputPort(0)->getFx();

		QPointF pos;

		if (inputFx) {

			if (inputFx->getAttributes()->getDagNodePos() != TConst::nowhere) {

				TPointD dagPos = inputFx->getAttributes()->getDagNodePos() + TPointD(150, 0);

				pos = QPointF(dagPos.x, dagPos.y);

				nodeRect.moveTopLeft(pos);

				while (!isAnEmptyZone(nodeRect))

					nodeRect.translate(0, -step);

				pos = nodeRect.topLeft();

			} else {

				m_nodesToPlace[inputFx].append(node);

				return;

			}

		} else {

			pos = sceneRect().center();

			nodeRect.moveTopLeft(pos);

			while (!isAnEmptyZone(nodeRect))

				nodeRect.translate(0, -step);

			pos = nodeRect.topLeft();

		}

		node->getFx()->getAttributes()->setDagNodePos(TPointD(pos.x(), pos.y()));

		node->setPos(QPointF(pos));

		if (m_nodesToPlace.contains(node->getFx())) {

			QList<fxschematicnode *=""> nodes = m_nodesToPlace[node->getFx()];</fxschematicnode>

			int i;

			for (i = 0; i < nodes.size(); i++)

				placeNode(nodes[i]);

		}

		return;

	} else if (node->isA(eZeraryFx) || node->isA(eColumnFx) || node->isA(eGroupedFx)) {

		//I'm placing a column

		nodeRect.translate(m_firstPoint);

		nodeRect.translate(10, 10);

		while (!isAnEmptyZone(nodeRect))

			nodeRect.translate(0, -step);

		QPointF newPos = nodeRect.topLeft();

		node->getFx()->getAttributes()->setDagNodePos(TPointD(newPos.x(), newPos.y()));

		node->setPos(QPointF(newPos));

		return;

	}

}

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

void FxSchematicScene::updateLink()

{

	TXsheet *xsh = m_xshHandle->getXsheet();

	// Iterate the fxs table

	QMap<tfx *="" *,="" fxschematicnode="">::iterator it;</tfx>

	for (it = m_table.begin(); it != m_table.end(); ++it) {

		FxSchematicNode *node = it.value();

		if (!node)

			continue; // Should be asserted? Is it legal?

		TFx *fx = it.key();

		TFx *inputPortsFx = fx;

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

			inputPortsFx = fx2->getZeraryFx();

			if (!inputPortsFx)

				return; // Should really never happen. Should be asserted...

		}

		for (int i = 0; i != inputPortsFx->getInputPortCount(); ++i) {

			TFxPort *port = inputPortsFx->getInputPort(i);

			if (TFx *linkedFx = port->getFx()) {

				if (!linkedFx->getAttributes()->isGrouped() || linkedFx->getAttributes()->isGroupEditing()) {

					// Not in a group / open group case

					assert(m_table.contains(linkedFx));

					if (m_table.contains(linkedFx)) {

						FxSchematicNode *linkedNode = m_table[linkedFx];

						SchematicPort *p0 = linkedNode->getOutputPort();

						SchematicPort *p1 = node->getInputPort(i);

						if (p0 && p1)

							p0->makeLink(p1);

					}

				} else {

					assert(m_groupedTable.contains(linkedFx->getAttributes()->getGroupId()));

					if (m_groupedTable.contains(linkedFx->getAttributes()->getGroupId())) {

						FxSchematicNode *linkedNode = m_groupedTable[linkedFx->getAttributes()->getGroupId()];

						SchematicPort *p0 = linkedNode->getOutputPort();

						SchematicPort *p1 = node->getInputPort(i);

						if (p0 && p1)

							p0->makeLink(p1);

					}

				}

			}

		}

		if (xsh->getFxDag()->getTerminalFxs()->containsFx(fx)) {

			SchematicPort *p0 = node->getOutputPort();

			SchematicPort *p1 = m_table[xsh->getFxDag()->getXsheetFx()]->getInputPort(0);

			p0->makeLink(p1);

		}

	}

	QMap<int, *="" fxgroupnode="">::iterator it2;</int,>

	for (it2 = m_groupedTable.begin(); it2 != m_groupedTable.end(); it2++) {

		FxGroupNode *node = it2.value();

		if (!node)

			continue;

		int i, fxCount = node->getFxCount();

		bool xsheetConnected = false;

		for (i = 0; i < fxCount; i++) {

			TFx *fx = node->getFx(i);

			if (xsh->getFxDag()->getTerminalFxs()->containsFx(fx) && !xsheetConnected) {

				SchematicPort *p0 = node->getOutputPort();

				SchematicPort *p1 = m_table[xsh->getFxDag()->getXsheetFx()]->getInputPort(0);

				p0->makeLink(p1);

				xsheetConnected = true;

			}

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

			if (zfx)

				fx = zfx->getZeraryFx();

			if (fx) {

				int j;

				for (j = 0; j < fx->getInputPortCount(); j++) {

					TFx *linkedFx = fx->getInputPort(j)->getFx();

					if (!linkedFx)

						continue;

					if (!linkedFx->getAttributes()->isGrouped() || linkedFx->getAttributes()->isGroupEditing()) {

						assert(m_table.contains(linkedFx));

						if (m_table.contains(linkedFx)) {

							FxSchematicNode *linkedNode = m_table[linkedFx];

							SchematicPort *p0 = linkedNode->getOutputPort();

							SchematicPort *p1 = node->getInputPort(0);

							if (p0 && p1)

								p0->makeLink(p1);

						}

					} else {

						int linkedGroupId = linkedFx->getAttributes()->getGroupId();

						assert(m_groupedTable.contains(linkedGroupId));

						if (m_groupedTable.contains(linkedGroupId)) {

							FxGroupNode *linkedNode = m_groupedTable[linkedGroupId];

							if (linkedNode == node)

								continue;

							SchematicPort *p0 = linkedNode->getOutputPort();

							SchematicPort *p1 = node->getInputPort(0);

							if (p0 && p1 && !p0->isLinkedTo(p1))

								p0->makeLink(p1);

						}

					}

				}

			}

		}

	}

	//to solve an edit macro problem: create a dummy link

	QMap<tmacrofx *="" *,="" fxschematicmacroeditor="">::iterator it3;</tmacrofx>

	for (it3 = m_macroEditorTable.begin(); it3 != m_macroEditorTable.end(); it3++) {

		TMacroFx *macro = it3.key();

		int i;

		FxSchematicNode *root = m_table[macro->getRoot()];

		SchematicPort *p0 = root->getOutputPort();

		for (i = 0; i < macro->getOutputConnectionCount(); i++) {

			TFxPort *outConnection = macro->getOutputConnection(i);

			TFx *outFx = outConnection->getOwnerFx();

			TMacroFx *outMacroFx = dynamic_cast<tmacrofx *="">(outFx);</tmacrofx>

			if (outMacroFx && outMacroFx->isEditing()) {

				vector<tfxp> fxs = outMacroFx->getFxs();</tfxp>

				int k;

				for (k = 0; k < (int)fxs.size(); k++) {

					TFx *fx = fxs[k].getPointer();

					int j;

					for (j = 0; j < fx->getInputPortCount(); j++)

						if (outConnection == fx->getInputPort(j)) {

							outFx = fx;

							break;

						}

					if (outFx != outMacroFx)

						break;

				}

			}

			int j;

			for (j = 0; j < outFx->getInputPortCount(); j++)

				if (outFx->getInputPort(j)->getFx() == macro) {

					SchematicPort *p1 = m_table[outFx]->getInputPort(j);

					p0->makeLink(p1);