#include "toonzqt/fxschematicscene.h"

// TnzQt includes

#include "toonzqt/fxtypes.h"

#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"

#include "toonz/childstack.h"

// TnzBase includes

#include "tmacrofx.h"

#include "fxdata.h"

#include "tpassivecachemanager.h"

#include "tfxattributes.h"

// TnzCore includes

#include "tconst.h"

#include "tenv.h"

// Qt includes

#include <qmenu></qmenu>

#include <qapplication></qapplication>

#include <qgraphicsscenecontextmenuevent></qgraphicsscenecontextmenuevent>

TEnv::IntVar IconifyFxSchematicNodes("IconifyFxSchematicNodes", 0);

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_isNormalIconView(!IconifyFxSchematicNodes)

    , m_viewer() {

  m_viewer = (SchematicViewer *)parent;

  m_selection = new FxSelection();

  m_selection->setFxSchematicScene(this);

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

          SLOT(onCollapse(const QList<tfxp> &)));</tfxp>

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

          SIGNAL(doExplodeChild(const QList<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()) 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()) {

      std::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;

  std::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 = std::max(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()) {

        std::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);

          break;

        }

    }

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

      assert(root);

      if (!root) continue;

      SchematicPort *p1 =

          m_table[xsh->getFxDag()->getXsheetFx()]->getInputPort(0);

      p0->makeLink(p1);

    }