tahoma2d/toonz/sources/toonzqt/fxdata.cpp

// TnzBase includes
#include "tfxattributes.h"

// TnzLib includes
#include "toonz/tcolumnfx.h"
#include "toonz/txsheet.h"
#include "toonz/txshzeraryfxcolumn.h"

#include "fxdata.h"

//******************************************************************
//    Local namespace  stuff
//******************************************************************

namespace {

void linkFxs(const QMap<TFx *, TFx *> &clonedFxs,
             const QList<Link> &selectedLinks) {
  int i;
  for (i = 0; i < selectedLinks.size(); i++) {
    TFx *outFx = selectedLinks[i].m_outputFx.getPointer();

    TZeraryColumnFx *zerayFx = dynamic_cast<TZeraryColumnFx *>(outFx);
    if (zerayFx) outFx       = zerayFx->getZeraryFx();

    TFx *inFx         = selectedLinks[i].m_inputFx.getPointer();
    zerayFx           = dynamic_cast<TZeraryColumnFx *>(inFx);
    if (zerayFx) inFx = zerayFx->getZeraryFx();

    if (!clonedFxs.contains(outFx) || !clonedFxs.contains(inFx)) continue;

    TFx *clonedOutFx = clonedFxs[outFx];
    TFx *clonedInFx  = clonedFxs[inFx];
    assert(clonedOutFx && clonedInFx);

    clonedOutFx->getInputPort(selectedLinks[i].m_index)->setFx(clonedInFx);
  }
}

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

void linkFxs(const QMap<TFx *, TFx *> &clonedFxs) {
  QMap<TFx *, TFx *>::const_iterator it;
  for (it = clonedFxs.begin(); it != clonedFxs.end(); it++) {
    TFx *fx = it.key();
    int j, portCount = fx->getInputPortCount();
    for (j = 0; j < portCount; j++) {
      TFx *inputFx = fx->getInputPort(j)->getFx();
      if (!clonedFxs.contains(inputFx)) continue;

      TFx *clonedFx      = clonedFxs[fx];
      TFx *inputClonedFx = clonedFxs[inputFx];
      assert(clonedFx && inputClonedFx);
      clonedFx->getInputPort(j)->setFx(inputClonedFx);
    }
  }
}

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

bool canCopyFx(TFx *fx) {
  TLevelColumnFx *lcFx  = dynamic_cast<TLevelColumnFx *>(fx);
  TPaletteColumnFx *pfx = dynamic_cast<TPaletteColumnFx *>(fx);
  TXsheetFx *xfx        = dynamic_cast<TXsheetFx *>(fx);
  TOutputFx *ofx        = dynamic_cast<TOutputFx *>(fx);

  return (!lcFx && !pfx && !xfx && !ofx);
}

}  // namespace

//******************************************************************
//    FxsData  implementation
//******************************************************************

FxsData::FxsData() : m_connected(false) {}

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

void FxsData::setFxs(const QList<TFxP> &selectedFxs,
                     const QList<Link> &selectedLinks,
                     const QList<int> &columnIndexes, TXsheet *xsh) {
  // fx->clonedFx
  QMap<TFx *, TFx *> clonedFxs;
  for (int i = 0; i < selectedFxs.size(); i++) {
    TFx *fx = selectedFxs[i].getPointer();
    if (!canCopyFx(fx)) continue;
    TZeraryColumnFx *zerayFx = dynamic_cast<TZeraryColumnFx *>(fx);
    if (zerayFx) fx          = zerayFx->getZeraryFx();
    TFx *clonedFx            = fx->clone(false);
    TPointD pos;
    if (zerayFx)
      pos = zerayFx->getAttributes()->getDagNodePos();
    else
      pos = fx->getAttributes()->getDagNodePos();
    clonedFx->getAttributes()->setDagNodePos(pos);
    m_fxs.append(clonedFx);
    if (zerayFx)
      m_zeraryFxColumnSize[clonedFx] = zerayFx->getColumn()->getRowCount();
    m_visitedFxs[clonedFx]           = false;
    clonedFxs[fx]                    = clonedFx;

    TFx *linkedFx = fx->getLinkedFx();
    if (linkedFx && clonedFxs.contains(linkedFx))
      clonedFx->linkParams(clonedFxs[linkedFx]);
  }

  QList<int>::const_iterator it;
  for (it = columnIndexes.begin(); it != columnIndexes.end(); it++) {
    TXshColumn *col    = xsh->getColumn(*it);
    TXshColumn *newCol = col->clone();
    newCol->getFx()->getAttributes()->setDagNodePos(
        col->getFx()->getAttributes()->getDagNodePos());
    m_columns.append(newCol);
    clonedFxs[col->getFx()] = newCol->getFx();
  }

  linkFxs(clonedFxs, selectedLinks);
  checkConnectivity();
}

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

void FxsData::getFxs(QList<TFxP> &fxs, QMap<TFx *, int> &zeraryFxColumnSize,
                     QList<TXshColumnP> &columns) const {
  QMap<TFx *, TFx *> clonedFxs;
  for (int i = 0; i < m_fxs.size(); i++) {
    TFx *clonedFx = m_fxs[i]->clone(false);
    TPointD pos   = m_fxs[i]->getAttributes()->getDagNodePos();
    clonedFx->getAttributes()->setDagNodePos(pos);
    clonedFx->getAttributes()->removeFromAllGroup();
    fxs.append(clonedFx);
    if (m_fxs[i]->isZerary())
      zeraryFxColumnSize[clonedFx] =
          m_zeraryFxColumnSize[m_fxs[i].getPointer()];
    clonedFxs[m_fxs[i].getPointer()] = clonedFx;

    TFx *linkedFx = m_fxs[i]->getLinkedFx();
    if (linkedFx && clonedFxs.contains(linkedFx))
      clonedFx->linkParams(clonedFxs[linkedFx]);
  }

  QList<TXshColumnP>::const_iterator it;
  for (it = m_columns.begin(); it != m_columns.end(); it++) {
    TXshColumn *col    = it->getPointer();
    TXshColumn *newCol = col->clone();
    newCol->getFx()->getAttributes()->setDagNodePos(
        col->getFx()->getAttributes()->getDagNodePos());
    columns.append(newCol);
    clonedFxs[col->getFx()] = newCol->getFx();
  }

  linkFxs(clonedFxs);
}

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

FxsData *FxsData::clone() const {
  FxsData *data = new FxsData;
  getFxs(data->m_fxs, data->m_zeraryFxColumnSize, data->m_columns);

  return data;
}

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

void FxsData::checkConnectivity() {
  if (m_fxs.isEmpty()) return;
  visitFx(m_fxs.at(0).getPointer());
  m_connected = true;
  QMap<TFx *, bool>::const_iterator it;
  for (it = m_visitedFxs.begin(); it != m_visitedFxs.end(); it++)
    m_connected = m_connected && it.value();
}

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

void FxsData::visitFx(TFx *fx) {
  if (m_visitedFxs.value(fx)) return;
  m_visitedFxs[fx] = true;
  int i;
  for (i = 0; i < fx->getInputPortCount(); i++) {
    TFx *inputFx = fx->getInputPort(i)->getFx();
    if (m_visitedFxs.contains(inputFx) && areLinked(fx, inputFx))
      visitFx(inputFx);
  }
  for (i = 0; i < fx->getOutputConnectionCount(); i++) {
    TFx *outputFx = fx->getOutputConnection(i)->getOwnerFx();
    if (m_visitedFxs.contains(outputFx) && areLinked(outputFx, fx))
      visitFx(outputFx);
  }
}

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

bool FxsData::areLinked(TFx *outFx, TFx *inFx) {
  for (int i = 0; i < outFx->getInputPortCount(); i++) {
    TFx *inputFx = outFx->getInputPort(i)->getFx();
    if (inFx == inputFx) return true;
  }
  return false;
}