#include "toonzqt/stageschematicscene.h"

// TnzQt includes

#include "toonzqt/stageschematicnode.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/gutil.h"

#include "toonzqt/schematicgroupeditor.h"

#include "stageobjectselection.h"

#include "toonzqt/icongenerator.h"

// TnzLib includes

#include "toonz/txsheet.h"

#include "toonz/txsheethandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/tframehandle.h"

#include "toonz/txshcolumn.h"

#include "toonz/toonzscene.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/tcamera.h"

#include "toonz/tstageobjectcmd.h"

#include "toonz/tproject.h"

#include "toonz/childstack.h"

// TnzCore includes

#include "tconst.h"

#include "tsystem.h"

#include "tstream.h"

#include "tstroke.h"

#include "tenv.h"

// Qt includes

#include <qmenu></qmenu>

#include <qgraphicsscenecontextmenuevent></qgraphicsscenecontextmenuevent>

#include <qgraphicsscenemouseevent></qgraphicsscenemouseevent>

#include <qfiledialog></qfiledialog>

TEnv::IntVar ShowLetterOnOutputPortOfStageNode(

    "ShowLetterOnOutputPortOfStageNode", 0);

namespace {

//! Define the method to sort a TreeStageNode container.

//! The sorting follows these rules:

//! \li TableNode < CameraNode < PegbarNode < ColumnNode

//! \li if two nodes are of the same type, they are odered using indexes

class CompareNodes {

public:

  bool operator()(TreeStageNode *node1, TreeStageNode *node2) {

    TStageObjectId id1 = node1->getNode()->getStageObject()->getId();

    TStageObjectId id2 = node2->getNode()->getStageObject()->getId();

    if (id1.isTable() ||

        (id1.isCamera() && !id2.isTable() && !id2.isCamera()) ||

        (id1.isPegbar() && !id2.isTable() && !id2.isCamera() &&

         !id2.isPegbar()))

      return true;

    if ((id1.isCamera() && id2.isCamera()) ||

        (id1.isTable() && id2.isTable()) ||

        (id1.isPegbar() && id2.isPegbar()) ||

        (id1.isColumn() && id2.isColumn()))

      return id1.getIndex() < id2.getIndex();

    return false;

  }

};

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

TStageObject *getRoot(const QList<tstageobject *=""> &objs,</tstageobject>

                      TStageObjectTree *pegTree) {

  int i;

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

    TStageObject *parent = pegTree->getStageObject(objs[i]->getParent(), false);

    if (objs.contains(parent))

      continue;

    else

      return objs[i];

  }

  return 0;

}

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

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++) {

      StageSchematicNode *node =

          dynamic_cast<stageschematicnode *="">(groupedNodes[i]);</stageschematicnode>

      if (!node) continue;

      TStageObject *obj = node->getStageObject();

      assert(obj);

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

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

        if (obj->isContainedInGroup(it2.key()) &&

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

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

      }

    }

  }

}

bool resizingNodes = false;

bool updatingScene = false;

}  // namespace

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

//

// TreeStageNode

//

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

void TreeStageNode::sortChildren(int startIndex, int lastIndex) {

  if (startIndex == lastIndex) return;

  std::vector<treestagenode *="">::iterator begin, end;</treestagenode>

  begin = m_cildren.begin() + startIndex;

  end   = m_cildren.begin() + lastIndex;

  std::sort(begin, end, CompareNodes());

}

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

//

// StageSchematicScene

//

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

StageSchematicScene::StageSchematicScene(QWidget *parent)

    : SchematicScene(parent)

    , m_nextNodePos(0, 0)

    , m_xshHandle(0)

    , m_objHandle(0)

    , m_colHandle(0)

    , m_sceneHandle(0)

    , m_frameHandle(0)

    , m_gridDimension(eSmall)

    , m_showLetterOnPortFlag(ShowLetterOnOutputPortOfStageNode != 0)

    , m_viewer() {

  m_viewer = (SchematicViewer *)parent;

  QPointF sceneCenter = sceneRect().center();

  m_firstPos          = TPointD(sceneCenter.x(), sceneCenter.y());

  m_selection = new StageObjectSelection();

  connect(m_selection, SIGNAL(doCollapse(QList<tstageobjectid>)), this,</tstageobjectid>

          SLOT(onCollapse(QList<tstageobjectid>)));</tstageobjectid>

  connect(m_selection, SIGNAL(doExplodeChild(QList<tstageobjectid>)), this,</tstageobjectid>

          SIGNAL(doExplodeChild(QList<tstageobjectid>)));</tstageobjectid>

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

  m_highlightedLinks.clear();

}

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

StageSchematicScene::~StageSchematicScene() {}

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

void StageSchematicScene::setXsheetHandle(TXsheetHandle *xshHandle) {

  m_xshHandle = xshHandle;

  m_selection->setXsheetHandle(xshHandle);

}

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

void StageSchematicScene::setObjectHandle(TObjectHandle *objHandle) {

  m_objHandle = objHandle;

  m_selection->setObjectHandle(objHandle);

}

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

void StageSchematicScene::setColumnHandle(TColumnHandle *colHandle) {

  m_colHandle = colHandle;

  m_selection->setColumnHandle(colHandle);

}

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

void StageSchematicScene::setFxHandle(TFxHandle *fxHandle) {

  m_selection->setFxHandle(fxHandle);

}

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

void StageSchematicScene::onSelectionSwitched(TSelection *oldSel,

                                              TSelection *newSel) {

  if (m_selection == oldSel && m_selection != newSel) clearSelection();

}

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

void StageSchematicScene::updateScene() {

  if (updatingScene) return;

  updatingScene = true;

  clearAllItems();

  QPointF firstPos = sceneRect().center();

  m_nextNodePos    = TPointD(firstPos.x(), firstPos.y());

  TStageObjectTree *pegTree = m_xshHandle->getXsheet()->getStageObjectTree();

  m_nodeTable.clear();

  m_GroupTable.clear();

  m_groupEditorTable.clear();

  m_gridDimension = pegTree->getDagGridDimension();

  QMap<int, *="" qlist<tstageobject="">> groupedObj;</int,>

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

  // in order to draw the position-specified nodes first

  QList<int> modifiedNodeIds;</int>

  for (int i = 0; i < pegTree->getStageObjectCount(); i++) {

    TStageObject *pegbar = pegTree->getStageObject(i);

    if (pegbar->getDagNodePos() == TConst::nowhere)

      modifiedNodeIds.push_back(i);

    else

      modifiedNodeIds.push_front(i);

  }

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

    TStageObject *pegbar = pegTree->getStageObject(modifiedNodeIds.at(i));

    if (pegbar->isGrouped() && !pegbar->isGroupEditing()) {

      groupedObj[pegbar->getGroupId()].push_back(pegbar);

      continue;

    }

    StageSchematicNode *node = addStageSchematicNode(pegbar);

    if (node != 0) {

      m_nodeTable[pegbar->getId()] = node;

      if (pegbar->isGrouped())

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

    }

  }

  // Motion Path

  m_splineTable.clear();

  for (int i = 0; i < pegTree->getSplineCount(); i++) {

    TStageObjectSpline *spline     = pegTree->getSpline(i);

    StageSchematicSplineNode *node = addSchematicSplineNode(spline);

    if (node != 0) {

      m_splineTable[spline] = node;

      connect(node, SIGNAL(currentObjectChanged(const TStageObjectId &, bool)),

              this, SLOT(onCurrentObjectChanged(const TStageObjectId &, bool)));

    }

  }

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

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

    StageSchematicGroupNode *node = addStageGroupNode(it.value());

    m_GroupTable[it.key()]        = node;

    int editingGroupId            = node->getStageObject()->getEditingGroupId();

    if (editingGroupId != -1) editedGroup[editingGroupId].append(node);

  }

  keepSubgroup(editedGroup);

  updateEditedGroups(editedGroup);

  // update stage links

  for (int i = 0; i < pegTree->getStageObjectCount(); i++)

  {

    TStageObject *pegbar    = pegTree->getStageObject(i);

    TStageObjectId parentId = pegbar->getParent();

    // update link; find StageSchematicNode representing pegbar

    QMap<tstageobjectid, *="" stageschematicnode="">::iterator it;</tstageobjectid,>

    if (!pegbar->isGrouped() || pegbar->isGroupEditing()) {

      it = m_nodeTable.find(pegbar->getId());

      //! note: not every stage object is represented in the scene (e.g. empty

      //! columns are not)

      if (it == m_nodeTable.end()) continue;

      StageSchematicNode *node = it.value();

      // get pegbar parent

      if (parentId != TStageObjectId::NoneId) {

        // find StageSchematicNode representing parentId

        it = m_nodeTable.find(parentId);

        if (it != m_nodeTable.end())  // at least we avoid crash

        {

          StageSchematicNode *parentNode = it.value();

          if (parentNode) {

            StageSchematicNodePort *port1 = parentNode->makeChildPort(

                QString::fromStdString(pegbar->getParentHandle()));

            StageSchematicNodePort *port2 = node->makeParentPort(

                QString::fromStdString(pegbar->getHandle()));

            port2->makeLink(port1);

          }

        }

        TStageObject *parent = pegTree->getStageObject(parentId, false);

        if (parent && parent->isGrouped()) {

          int groupId = parent->getGroupId();

          if (m_GroupTable.contains(groupId)) {

            StageSchematicGroupNode *groupeNode = m_GroupTable[groupId];

            StageSchematicNodePort *port1       = groupeNode->getChildPort(0);

            StageSchematicNodePort *port2       = node->makeParentPort(

                QString::fromStdString(pegbar->getHandle()));

            port2->makeLink(port1);

          }

        }

      }

      // link to motion path

      TStageObjectSpline *spline = pegbar->getSpline();

      if (spline) {

        QMap<tstageobjectspline *="" *,="" stageschematicsplinenode="">::iterator</tstageobjectspline>

            splineIt;

        splineIt = m_splineTable.find(spline);

        if (splineIt != m_splineTable.end()) {

          SchematicPort *port1 = splineIt.value()->getPort(-1);

          SchematicPort *port2 = node->getPort(-1);

          port2->makeLink(port1);

        }

      }

    } else {

      int groupId                         = pegbar->getGroupId();

      StageSchematicGroupNode *groupeNode = m_GroupTable[groupId];

      TStageObject *parent = pegTree->getStageObject(parentId, false);

      if (parent && (!parent->isGrouped() || parent->isGroupEditing())) {

        it = m_nodeTable.find(parentId);

        if (it == m_nodeTable.end()) continue;

        StageSchematicNode *parentNode = it.value();

        if (parentNode) {

          StageSchematicNodePort *port1 = parentNode->makeChildPort(

              QString::fromStdString(pegbar->getParentHandle()));

          StageSchematicNodePort *port2 = groupeNode->getParentPort();

          port2->makeLink(port1);

        }

      }

      if (parent && parent->isGrouped()) {

        int parentGroupId = parent->getGroupId();

        if (m_GroupTable.contains(parentGroupId)) {

          StageSchematicGroupNode *groupeParentNode =

              m_GroupTable[parentGroupId];

          StageSchematicNodePort *port1 = groupeParentNode->getChildPort(0);

          StageSchematicNodePort *port2 = groupeNode->getParentPort();

          if (!port1->isLinkedTo(port2) && groupeParentNode != groupeNode)

            port2->makeLink(port1);

        }

      }

      TStageObjectSpline *spline = pegbar->getSpline();

      if (spline) {

        QMap<tstageobjectspline *="" *,="" stageschematicsplinenode="">::iterator</tstageobjectspline>

            splineIt;

        splineIt = m_splineTable.find(spline);

        if (splineIt != m_splineTable.end()) {

          SchematicPort *port1 = splineIt.value()->getPort(-1);

          SchematicPort *port2 = groupeNode->getPort(-1);

          port2->makeLink(port1);

        }

      }

    }

  }

  m_nodesToPlace.clear();

  updatingScene = false;

}

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

StageSchematicNode *StageSchematicScene::addStageSchematicNode(

    TStageObject *pegbar) {

  // create the node according to the type of StageObject

  StageSchematicNode *node = createStageSchematicNode(this, pegbar);

  if (!node) return 0;

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

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

  connect(node, SIGNAL(currentObjectChanged(const TStageObjectId &, bool)),

          this, SLOT(onCurrentObjectChanged(const TStageObjectId &, bool)));

  connect(node, SIGNAL(currentColumnChanged(int)), this,

          SLOT(onCurrentColumnChanged(int)));

  connect(node, SIGNAL(editObject()), this, SIGNAL(editObject()));

  connect(node, SIGNAL(nodeChangedSize()), this, SLOT(onNodeChangedSize()));

  // specify the node position

  if (pegbar->getDagNodePos() == TConst::nowhere) {

    if (pegbar->getId().isColumn()) {

      StageSchematicColumnNode *cNode =

          dynamic_cast<stageschematiccolumnnode *="">(node);</stageschematiccolumnnode>

      assert(node);

      cNode->resize(m_gridDimension == 0);

    }

    placeNode(node);

  } else

    updatePosition(node, pegbar->getDagNodePos());

  return node;

}

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

StageSchematicGroupNode *StageSchematicScene::addStageGroupNode(

    QList<tstageobject *=""> objs) {</tstageobject>

  if (objs.isEmpty()) return 0;

  TStageObjectTree *objTree = m_xshHandle->getXsheet()->getStageObjectTree();

  TStageObject *root        = getRoot(objs, objTree);

  StageSchematicGroupNode *node = new StageSchematicGroupNode(this, root, objs);

  if (!node) return 0;

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

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

  connect(node, SIGNAL(currentObjectChanged(const TStageObjectId &, bool)),

          this, SLOT(onCurrentObjectChanged(const TStageObjectId &, bool)));

  connect(node, SIGNAL(currentColumnChanged(int)), this,

          SLOT(onCurrentColumnChanged(int)));

  connect(node, SIGNAL(editObject()), this, SIGNAL(editObject()));

  if (root->getDagNodePos() == TConst::nowhere) {

    placeNode(node);

  } else

    updatePosition(node, root->getDagNodePos());

  return node;

}

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

StageSchematicGroupEditor *

StageSchematicScene::addEditedGroupedStageSchematicNode(

    int groupId, const QList<schematicnode *=""> &groupedObjs) {</schematicnode>

  StageSchematicGroupEditor *editorGroup =

      new StageSchematicGroupEditor(groupId, groupedObjs, this);

  m_groupEditorTable[groupId] = editorGroup;

  return editorGroup;

}

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

void StageSchematicScene::updatePosition(StageSchematicNode *node,

                                         const TPointD &pos) {

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

  node->getStageObject()->setDagNodePos(pos);

  // this operation may abort

  /*

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

TPointD offset(15,15);

int i;

for(i=0; i

{

StageSchematicNode *placedNode =

dynamic_cast<stageschematicnode*>(placedNodes[i]);</stageschematicnode*>

assert(placedNode);

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

updatePosition(placedNode,newPos);

}

*/

}

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

void StageSchematicScene::highlightLinks(StageSchematicNode *node, bool value) {

  int i, portCount = node->getChildCount();

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

    StageSchematicNodePort *port = node->getChildPort(i);

    int j, linkCount = port->getLinkCount();

    for (j = 0; j < linkCount; j++) {

      SchematicLink *link = port->getLink(j);

      if (!link) continue;

      link->setHighlighted(value);

      link->update();

      m_highlightedLinks.push_back(link);

    }

  }

  StageSchematicNodePort *port = node->getParentPort();

  if (port) {

    int linkCount = port->getLinkCount();

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

      SchematicLink *link = port->getLink(i);

      if (link) {

        link->setHighlighted(value);

        link->update();

        m_highlightedLinks.push_back(link);

      }

    }

  }

}

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

void StageSchematicScene::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()) {

      StageSchematicNode *placedObj =

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

      StageSchematicNode *obj =

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

      if (!placedObj || !obj) {

        it2++;

        continue;

      }

      int placedGroupedId = placedObj->getStageObject()->getEditingGroupId();

      if (obj->getStageObject()->isContainedInGroup(placedGroupedId) &&

          obj->getStageObject()->getEditingGroupId() != it2.key())

        zValue += 2;

      it2++;

    }

    StageSchematicGroupEditor *node =

        addEditedGroupedStageSchematicNode(it.key(), it.value());

    node->setZValue(zValue);

    node->setGroupedNodeZValue(zValue + 1);

  }

}

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

void StageSchematicScene::updateNestedGroupEditors(StageSchematicNode *node,

                                                   const QPointF &newPos) {

  if (!node) return;

  QStack<int> groupIdStack = node->getStageObject()->getGroupIdStack();</int>

  if (groupIdStack.isEmpty()) return;

  int i;

  QRectF rect;

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

    if (m_groupEditorTable.contains(groupIdStack[i])) {

      QRectF app = m_groupEditorTable[groupIdStack[i]]->sceneBoundingRect();

      if (rect.isEmpty())

        rect = app;

      else

        rect = rect.united(app);

    }

  }

  node->setPos(newPos);

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

    if (!m_groupEditorTable.contains(groupIdStack[i])) continue;

    rect =

        rect.united(m_groupEditorTable[groupIdStack[i]]->sceneBoundingRect());

    QRectF app = m_groupEditorTable[groupIdStack[i]]->boundingSceneRect();

    if (m_groupEditorTable[groupIdStack[i]]->scenePos() != app.topLeft())

      m_groupEditorTable[groupIdStack[i]]->setPos(app.topLeft());

  }

  update(rect);

}

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

void StageSchematicScene::resizeNodes(bool maximizedNode) {

  resizingNodes             = true;

  m_gridDimension           = maximizedNode ? eLarge : eSmall;

  TStageObjectTree *pegTree = m_xshHandle->getXsheet()->getStageObjectTree();

  pegTree->setDagGridDimension(m_gridDimension);

  int i, objCount = pegTree->getStageObjectCount();

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

    TStageObject *obj = pegTree->getStageObject(i);

    if (obj && obj->getId().isColumn()) {

      if (!m_nodeTable.contains(obj->getId())) continue;

      StageSchematicColumnNode *node =

          dynamic_cast<stageschematiccolumnnode *="">(m_nodeTable[obj->getId()]);</stageschematiccolumnnode>

      assert(node);

      node->resize(maximizedNode);

    }

    if (obj && !obj->getId().isCamera())

      updatePositionOnResize(obj, maximizedNode);

  }

  int splineCount = pegTree->getSplineCount();

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

    TStageObjectSpline *spl = pegTree->getSpline(i);

    if (spl) {

      if (!m_splineTable.contains(spl)) continue;

      StageSchematicSplineNode *node =

          dynamic_cast<stageschematicsplinenode *="">(m_splineTable[spl]);</stageschematicsplinenode>

      assert(node);

      node->resize(maximizedNode);

      updateSplinePositionOnResize(spl, maximizedNode);

    }

  }

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

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

    it.value()->resize(maximizedNode);

    QList<tstageobject *=""> groupedObjs = it.value()->getGroupedObjects();</tstageobject>

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

      updatePositionOnResize(groupedObjs[i], maximizedNode);

  }

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

  for (it2 = m_groupEditorTable.begin(); it2 != m_groupEditorTable.end(); it2++)

    it2.value()->resizeNodes(maximizedNode);

  updateScene();

  resizingNodes = false;

}

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

void StageSchematicScene::updatePositionOnResize(TStageObject *obj,

                                                 bool maximizedNode) {

  TPointD oldPos = obj->getDagNodePos();

  if (oldPos == TConst::nowhere) return;

  double oldPosY = oldPos.y - 25500;

  double newPosY = maximizedNode ? oldPosY * 2 : oldPosY * 0.5;

  obj->setDagNodePos(TPointD(oldPos.x, newPosY + 25500));

}

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

void StageSchematicScene::updateSplinePositionOnResize(TStageObjectSpline *spl,

                                                       bool maximizedNode) {

  TPointD oldPos = spl->getDagNodePos();

  if (oldPos == TConst::nowhere) return;

  double oldPosY = oldPos.y - 25500;

  double newPosY = maximizedNode ? oldPosY * 2 : oldPosY * 0.5;

  spl->setDagNodePos(TPointD(oldPos.x, newPosY + 25500));

}

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

StageSchematicSplineNode *StageSchematicScene::addSchematicSplineNode(

    TStageObjectSpline *spline) {

  StageSchematicSplineNode *node = new StageSchematicSplineNode(this, spline);

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

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

  if (!node) return 0;

  if (spline->getDagNodePos() == TConst::nowhere) {

    node->resize(m_gridDimension == 0);

    placeSplineNode(node);

  } else

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

  return node;

}

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

/*! create node according to the type of StageObject

 */

StageSchematicNode *StageSchematicScene::createStageSchematicNode(

    StageSchematicScene *scene, TStageObject *pegbar) {

  TStageObjectId id = pegbar->getId();

  if (id.isColumn()) {

    int columnIndex = id.getIndex();

    if (m_xshHandle->getXsheet()->isColumnEmpty(columnIndex)) {

      return 0;

    } else {

      TXshColumn *column = m_xshHandle->getXsheet()->getColumn(columnIndex);

      if (!column || column->getSoundColumn() || column->getSoundTextColumn())

        return 0;

    }

  }

  if (!pegbar || !scene) return 0;

  if (id.isTable())

    return new StageSchematicTableNode(scene, pegbar);

  else if (id.isCamera())

    return new StageSchematicCameraNode(scene, pegbar);

  else if (id.isPegbar())

    return new StageSchematicPegbarNode(scene, pegbar);

  else if (id.isColumn())

    return new StageSchematicColumnNode(scene, pegbar);

  else

    return 0;

}

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

QGraphicsItem *StageSchematicScene::getCurrentNode() {

  QList<qgraphicsitem *=""> allItems = items();</qgraphicsitem>

  for (auto const item : allItems) {

    StageSchematicNode *node = dynamic_cast<stageschematicnode *="">(item);</stageschematicnode>

    if (node && node->getStageObject()->getId() == m_objHandle->getObjectId())

      return node;

  }

  return 0;

}

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

void StageSchematicScene::reorderScene() { placeNodes(); }

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

void StageSchematicScene::placeNodes() {

  // search all possible roots

  std::vector<treestagenode *=""> roots;</treestagenode>

  findRoots(roots);

  // sorts the roots container. Sortijg rules are specified by CompareNodes

  // class

  std::sort(roots.begin(), roots.end(), CompareNodes());

  double xFirstPos = m_firstPos.x - 500;

  double yFirstPos = m_firstPos.y + 500;

  double xPos      = xFirstPos;

  double yPos      = yFirstPos;

  double maxXPos;

  double maxYPos = yFirstPos;

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

  // places the first roots and its children. The first root is always a table!

  assert(roots[0]->getNode()->getStageObject()->getId().isTable());

  roots[0]->getNode()->getStageObject()->setDagNodePos(

      TPointD(xFirstPos, yFirstPos));

  placeChildren(roots[0], xPos, yPos);

  maxXPos = xPos;

  int i;

  // places other roots and root's children.

  for (i = 1; i < (int)roots.size(); i++) {

    TStageObject *pegbar = roots[i]->getNode()->getStageObject();

    xPos                 = xFirstPos;

    yPos                 = maxYPos + (pegbar->getId().isCamera() ? 100 : step);

    pegbar->setDagNodePos(TPointD(xPos, yPos));

    placeChildren(roots[i], xPos, yPos);

    maxXPos = std::max(xPos, maxXPos);

    maxYPos = std::max(yPos, maxYPos);

  }

  // places all spline nodes.

  TStageObjectTree *pegTree = m_xshHandle->getXsheet()->getStageObjectTree();

  for (i = 0; i < pegTree->getSplineCount(); i++) {

    TStageObjectSpline *spline = pegTree->getSpline(i);

    spline->setDagNodePos(TPointD(maxXPos, yFirstPos + step));

    maxXPos += (m_showLetterOnPortFlag) ? 150 : 120;

  }

  // delete the tree

  for (i = 0; i < (int)roots.size(); i++) delete roots[i];

  roots.clear();

  updateScene();

}

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

void StageSchematicScene::findRoots(std::vector<treestagenode *=""> &roots) {</treestagenode>

  TStageObjectTree *pegTree = m_xshHandle->getXsheet()->getStageObjectTree();

  int i;

  for (i = 0; i < pegTree->getStageObjectCount(); i++) {

    TStageObject *pegbar = pegTree->getStageObject(i);

    // only cameras and pegbars can be roots

    // check if the id is contained in the table in case the object is grouped

    if ((pegbar->getId().isCamera() || pegbar->getId().isTable()) &&

        m_nodeTable.contains(pegbar->getId())) {

      StageSchematicNode *node = m_nodeTable[pegbar->getId()];

      TreeStageNode *treeNode  = new TreeStageNode(node);

      roots.push_back(treeNode);

      // when a root is found, the tree is build.

      makeTree(treeNode);

    }

  }

}

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

void StageSchematicScene::makeTree(TreeStageNode *treeNode) {

  int i, portCount = treeNode->getNode()->getChildCount();

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

    StageSchematicNodePort *port = treeNode->getNode()->getChildPort(i);

    int firstChild               = treeNode->getChildrenCount();

    int j, linkCount = port->getLinkCount();

    for (j = 0; j < linkCount; j++) {

      // the linked node is taken and the method is iterated for this node

      StageSchematicNode *schematicNode =

          dynamic_cast<stageschematicnode *="">(port->getLinkedNode(j));</stageschematicnode>

      TreeStageNode *treeChild = new TreeStageNode(schematicNode);

      treeNode->addChild(treeChild);

      makeTree(treeChild);

    }

    int lastChild = treeNode->getChildrenCount();

    treeNode->sortChildren(firstChild, lastChild);

  }

}

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

void StageSchematicScene::placeChildren(TreeStageNode *treeNode, double &xPos,

                                        double &yPos, bool isCameraTree) {

  int i;

  xPos += (m_showLetterOnPortFlag) ? 150 : 120;

  double xChildPos = xPos;

  double xRefPos   = xPos;

  bool firstChild  = true;

  bool startFromCamera =

      isCameraTree || treeNode->getNode()->getStageObject()->getId().isCamera();

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

  double yOffset = startFromCamera ? step : -step;

  if (startFromCamera) treeNode->reverseChildren();

  for (i = 0; i < treeNode->getChildrenCount(); i++) {

    TreeStageNode *childNode  = treeNode->getChildTreeNode(i);

    TStageObject *childPegbar = childNode->getNode()->getStageObject();

    if (childPegbar->getId().isCamera()) continue;

    xChildPos = xRefPos;

    // first child must have same yPos of father.

    yPos += firstChild ? 0 : yOffset;

    firstChild = false;

    childPegbar->setDagNodePos(TPointD(xChildPos, yPos));

    placeChildren(childNode, xChildPos, yPos, startFromCamera);

    xPos = std::max(xPos, xChildPos);

  }

}

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

/*! define the position of nodes which is not specified manually

 */

void StageSchematicScene::placeNode(StageSchematicNode *node) {

  double xFirstPos = m_firstPos.x - 500;

  double yFirstPos = m_firstPos.y + 500;

  double xPos      = xFirstPos;

  double yPos      = yFirstPos;

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

  int hStep        = (m_showLetterOnPortFlag) ? 150 : 120;

  TStageObjectTree *pegTree = m_xshHandle->getXsheet()->getStageObjectTree();

  QRectF nodeRect           = node->boundingRect();

  TStageObject *pegbar      = node->getStageObject();

  TStageObjectId parentObjId = pegbar->getParent();

  TStageObject *parentObj    = pegTree->getStageObject(parentObjId, false);

  if (pegbar->getId().isCamera())

    yPos = yFirstPos + step;

  else if (pegbar->getId().isPegbar()) {

    if (parentObj) {

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

        TPointD pos = parentObj->getDagNodePos();

        yPos        = pos.y;

        xPos        = pos.x + hStep;

      } else {

        m_nodesToPlace[parentObjId].append(node);

        return;

      }

    } else {

      yPos = yFirstPos;

      xPos = xFirstPos + hStep;

    }

  } else if (pegbar->getId().isColumn()) {

    if (parentObj) {

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

        TPointD pos = parentObj->getDagNodePos();

        yPos        = pos.y;

        xPos        = pos.x + hStep;

      } else {

        m_nodesToPlace[parentObjId].append(node);

        return;

      }

    } else {

      yPos = yFirstPos;

      xPos = xFirstPos + (hStep * 2);

    }

  }

  QPointF initPos(xPos, yPos);

  nodeRect.moveTopLeft(initPos);

  bool found = false;

  // try to place inside of the visible area

  if (!views().isEmpty() && pegbar->getId().isPegbar()) {

    QGraphicsView *view = views().at(0);

    QRectF visibleRect =

        view->mapToScene(0, 0, view->width(), view->height()).boundingRect();

    while (visibleRect.left() > nodeRect.left()) {

      nodeRect.translate(hStep, 0);

      xPos += hStep;

    }

    while (visibleRect.bottom() < nodeRect.bottom()) {

      nodeRect.translate(0, -step);

      yPos -= step;

    }

    QPointF tmpPos(xPos, yPos);

    while (visibleRect.right() > nodeRect.right()) {

      while (!isAnEmptyZone(nodeRect)) {

        nodeRect.translate(0, -step);

        yPos -= step;

      }

      // if failed to place this column, then move the candidate position to

      // right

      if (visibleRect.contains(nodeRect)) {

        found = true;

        break;

      } else {

        xPos += hStep;

        yPos = tmpPos.y();

        nodeRect.moveTopLeft(QPointF(xPos, yPos));

      }

    }

  }

  // place the node outside of the visible area

  if (!found) {

    nodeRect.moveTopLeft(initPos);

    xPos = initPos.x();

    yPos = initPos.y();