// TnzCore includes

#include "tofflinegl.h"

#include "tstroke.h"

#include "tconvert.h"

#include "tvectorimage.h"

#include "tundo.h"

#include "tconst.h"

// TnzLib includes

#include "toonz/tstageobjectid.h"

#include "toonz/tstageobject.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/txsheet.h"

#include "toonz/txshcell.h"

#include "toonz/txshcolumn.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/tstageobjectcmd.h"

#include "toonz/fxcommand.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/tcolumnfx.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/tframehandle.h"

#include "toonz/txshchildlevel.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshleveltypes.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/hook.h"

#include "toonz/preferences.h"

#include "toonz/txshsimplelevel.h"

// TnzQt includes

#include "toonzqt/gutil.h"

#include "toonzqt/icongenerator.h"

#include "toonzqt/stageschematicscene.h"

#include "toonzqt/menubarcommand.h"

// Qt includes

#include <qpixmap></qpixmap>

#include <qregexpvalidator></qregexpvalidator>

#include <qgraphicsscenemouseevent></qgraphicsscenemouseevent>

#include <qfocusevent></qfocusevent>

#include <qtimer></qtimer>

#include <qmenu></qmenu>

#include <qtextcursor></qtextcursor>

#include <qset></qset>

#include "toonzqt/stageschematicnode.h"

namespace {

void drawCamera(QPainter *painter, const QColor &color, const QPen &pen,

                double width, double height) {

  QPointF points[3];

  points[0] = QPointF(width, height);

  points[1] = QPointF(width, height * 0.5);

  points[2] = QPointF(width - (height * 2 / 3), height * 0.75);

  painter->setBrush(color);

  painter->drawPolygon(points, 3);

  painter->drawRect(

      QRectF(width * 0.25, height * 0.5, width * 0.5, height * 0.5));

  QRectF rect(0, 0, height * 0.49, height * 0.49);

  rect.moveCenter(QPointF(width * 0.20, height * 0.4));

  painter->drawEllipse(rect);

  rect.moveCenter(QPointF((width * 3 / 5) + 1, height * 0.25));

  painter->drawEllipse(rect);

  painter->drawLine(0, height * 0.75, width * 0.25, height * 0.75);

  painter->drawLine(width, height * 0.75, width + 5, height * 0.75);

  painter->setBrush(QColor(235, 235, 235, 255));

  painter->drawRect(0, -14, width, 14);

}

}  // namespace

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

//

// ColumnPainter

//

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

ColumnPainter::ColumnPainter(StageSchematicColumnNode *parent, double width,

                             double height, const QString &name)

    : QGraphicsItem(parent)

    , m_parent(parent)

    , m_width(width)

    , m_height(height)

    , m_name(name) {

  setFlag(QGraphicsItem::ItemIsMovable, false);

  setFlag(QGraphicsItem::ItemIsSelectable, false);

  setFlag(QGraphicsItem::ItemIsFocusable, false);

  assert(parent->getStageObject()->getId().isColumn());

  connect(IconGenerator::instance(), SIGNAL(iconGenerated()), this,

          SLOT(onIconGenerated()));

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  if (!stageScene) return;

  TXsheet *xsh = stageScene->getXsheet();

  int r0, r1, index = parent->getStageObject()->getId().getIndex();

  xsh->getCellRange(index, r0, r1);

  if (r0 > r1) return;

  TXshCell firstCell = xsh->getCell(r0, index);

  if (!firstCell.isEmpty())

    m_type = firstCell.m_level->getType();

  else

    m_type = NO_XSHLEVEL;

}

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

ColumnPainter::~ColumnPainter() {}

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

QRectF ColumnPainter::boundingRect() const {

  // iwasawa

  if (m_parent->isOpened())

    return QRectF(-5, -54, m_width + 10, m_height + 59);

  else

    return QRectF(-5, -5, m_width + 10, m_height + 10);

}

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

void ColumnPainter::paint(QPainter *painter,

                          const QStyleOptionGraphicsItem *option,

                          QWidget *widget) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  if (!stageScene) return;

  // obtain level name and type

  int levelType;

  QString levelName;

  m_parent->getLevelTypeAndName(levelType, levelName);

  QColor nodeColor;

  SchematicViewer *viewer = stageScene->getSchematicViewer();

  viewer->getNodeColor(levelType, nodeColor);

  if (m_isReference && levelType != PLT_XSHLEVEL) {

    painter->setBrush(viewer->getReferenceColumnColor());

    painter->setPen(nodeColor);

  } else {

    painter->setBrush(nodeColor);

    painter->setPen(Qt::NoPen);

  }

  if (levelType == PLT_XSHLEVEL)

    painter->drawRoundRect(0, 0, m_width, m_height, 32, 99);

  else

    painter->drawRect(0, 0, m_width, m_height);

  // draw palette icon for palette node

  if (levelType == PLT_XSHLEVEL) {

    QPixmap palettePm = QPixmap(":Resources/schematic_palette.png");

    QRect paletteRect(-3, -1, 20, 16);

    painter->drawPixmap(paletteRect, palettePm);

  }

  if (m_parent->isOpened()) {

    // Draw the pixmap

    painter->setBrush(Qt::NoBrush);

    painter->setPen(QColor(0, 0, 0, 255));

    QPixmap pixmap = scalePixmapKeepingAspectRatio(

        m_parent->getPixmap(), QSize(m_width, 49), Qt::transparent);

    if (!pixmap.isNull()) {

      painter->drawPixmap(QPointF(0, -pixmap.height()), pixmap);

    } else {

      painter->setBrush(QColor(255, 255, 255, 255));

      painter->drawRect(0, -pixmap.height(), m_width, pixmap.height());

    }

  }

  painter->setPen(viewer->getTextColor());

  painter->setBrush(Qt::NoBrush);

  //! draw the name only if it is not editing

  if (!m_parent->isNameEditing()) {

    StageSchematicScene *stageScene =

        dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

    if (!stageScene) return;

    // if this is current object

    if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())

      painter->setPen(viewer->getSelectedNodeTextColor());

    QRectF columnNameRect(18, 2, 54, 14);

    QString elidedName =

        elideText(m_name, painter->font(), columnNameRect.width());

    painter->drawText(columnNameRect, Qt::AlignLeft | Qt::AlignVCenter,

                      elidedName);

  }

  // level names

  QRectF levelNameRect(18, 16, 54, 14);

  QString elidedName =

      elideText(levelName, painter->font(), levelNameRect.width());

  painter->drawText(levelNameRect, Qt::AlignLeft | Qt::AlignVCenter,

                    elidedName);

}

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

void ColumnPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  QMenu menu(stageScene->views()[0]);

  QAction *resetCenter = new QAction(tr("&Reset Center"), &menu);

  connect(resetCenter, SIGNAL(triggered()), stageScene, SLOT(onResetCenter()));

  QAction *collapse   = CommandManager::instance()->getAction("MI_Collapse");

  QAction *openSubxsh = CommandManager::instance()->getAction("MI_OpenChild");

  QAction *explodeChild =

      CommandManager::instance()->getAction("MI_ExplodeChild");

  QAction *group = CommandManager::instance()->getAction("MI_Group");

  QAction *clear = CommandManager::instance()->getAction("MI_Clear");

  QAction *copy  = CommandManager::instance()->getAction("MI_Copy");

  QAction *cut   = CommandManager::instance()->getAction("MI_Cut");

  QAction *paste = CommandManager::instance()->getAction("MI_Paste");

  menu.addAction(resetCenter);

  menu.addSeparator();

  menu.addAction(collapse);

  TFrameHandle *frameHandle = stageScene->getFrameHandle();

  if (frameHandle->getFrameType() == TFrameHandle::SceneFrame) {

    int col       = m_parent->getStageObject()->getId().getIndex();

    int fr        = frameHandle->getFrame();

    TXsheet *xsh  = stageScene->getXsheet();

    TXshCell cell = xsh->getCell(fr, col);

    if (dynamic_cast<txshchildlevel *="">(cell.m_level.getPointer())) {</txshchildlevel>

      menu.addAction(openSubxsh);

      menu.addAction(explodeChild);

    }

  }

  menu.addSeparator();

  menu.addAction(clear);

  menu.addAction(copy);

  menu.addAction(cut);

  menu.addAction(paste);

  menu.addSeparator();

  menu.addAction(group);

  menu.exec(cme->screenPos());

}

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

void ColumnPainter::onIconGenerated() {

  if (m_type != OVL_XSHLEVEL) return;

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  if (!stageScene) return;

  TXsheet *xsh = stageScene->getXsheet();

  int r0, r1, index = m_parent->getStageObject()->getId().getIndex();

  xsh->getCellRange(index, r0, r1);

  if (r0 > r1) return;

  TXshCell firstCell = xsh->getCell(r0, index);

  int type           = firstCell.m_level->getType();

  if (m_type != type) {

    m_type = type;

    update();

  }

}

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

//

// GroupPainter

//

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

GroupPainter::GroupPainter(StageSchematicGroupNode *parent, double width,

                           double height, const QString &name)

    : QGraphicsItem(parent)

    , m_parent(parent)

    , m_width(width)

    , m_height(height)

    , m_name(name) {

  setFlag(QGraphicsItem::ItemIsMovable, false);

  setFlag(QGraphicsItem::ItemIsSelectable, false);

  setFlag(QGraphicsItem::ItemIsFocusable, false);

}

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

GroupPainter::~GroupPainter() {}

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

QRectF GroupPainter::boundingRect() const {

  return QRectF(-5, -5, m_width + 10, m_height + 10);

}

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

void GroupPainter::paint(QPainter *painter,

                         const QStyleOptionGraphicsItem *option,

                         QWidget *widget) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  if (!stageScene) return;

  SchematicViewer *viewer = stageScene->getSchematicViewer();

  painter->save();

  QPen pen;

  if (m_parent->isSelected()) {

    painter->setBrush(QColor(0, 0, 0, 0));

    pen.setColor(QColor(255, 255, 255, 255));

    pen.setWidth(4.0);

    pen.setJoinStyle(Qt::RoundJoin);

    painter->setPen(pen);

    painter->drawRect(-2, -2, m_width + 4, m_height + 4);

  }

  painter->restore();

  {

    painter->setBrush(viewer->getGroupColor());

    painter->setPen(Qt::NoPen);

    painter->drawRect(QRectF(0, 0, m_width, m_height));

  }

  //! draw the name only if it is not editing

  if (!m_parent->isNameEditing()) {

    QFont font("Verdana", 8);

    painter->setFont(font);

    if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())

      painter->setPen(viewer->getSelectedNodeTextColor());

    else

      painter->setPen(viewer->getTextColor());

    QRectF rect(18, 0, 54, 18);

    QString elidedName = elideText(m_name, painter->font(), rect.width());

    painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, elidedName);

  }

}

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

void GroupPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  QMenu menu(stageScene->views()[0]);

  QAction *group   = CommandManager::instance()->getAction("MI_Group");

  QAction *ungroup = CommandManager::instance()->getAction("MI_Ungroup");

  QAction *editGroup = new QAction(tr("&Open Group"), &menu);

  connect(editGroup, SIGNAL(triggered()), stageScene, SLOT(onEditGroup()));

  menu.addAction(group);

  menu.addAction(ungroup);

  menu.addAction(editGroup);

  menu.exec(cme->screenPos());

}

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

//

// PegbarPainter

//

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

PegbarPainter::PegbarPainter(StageSchematicPegbarNode *parent, double width,

                             double height, const QString &name)

    : QGraphicsItem(parent)

    , m_width(width)

    , m_height(height)

    , m_parent(parent)

    , m_name(name) {}

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

PegbarPainter::~PegbarPainter() {}

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

QRectF PegbarPainter::boundingRect() const {

  return QRectF(-5, -5, m_width + 10, m_height + 10);

}

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

void PegbarPainter::paint(QPainter *painter,

                          const QStyleOptionGraphicsItem *option,

                          QWidget *widget) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  if (!stageScene) return;

  SchematicViewer *viewer = stageScene->getSchematicViewer();

  painter->setBrush(viewer->getPegColor());

  painter->setPen(Qt::NoPen);

  painter->drawRect(QRectF(0, 0, m_width, m_height));

  if (!m_parent->isNameEditing()) {

    if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())

      painter->setPen(viewer->getSelectedNodeTextColor());

    else

      painter->setPen(viewer->getTextColor());

    // Draw the name

    QRectF rect(18, 0, 54, 18);

    QString elidedName = elideText(m_name, painter->font(), rect.width());

    painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, elidedName);

  }

}

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

void PegbarPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  QMenu menu(stageScene->views()[0]);

  QAction *resetCenter = new QAction(tr("&Reset Center"), &menu);

  connect(resetCenter, SIGNAL(triggered()), stageScene, SLOT(onResetCenter()));

  QAction *group = CommandManager::instance()->getAction("MI_Group");

  QAction *clear = CommandManager::instance()->getAction("MI_Clear");

  QAction *copy  = CommandManager::instance()->getAction("MI_Copy");

  QAction *cut   = CommandManager::instance()->getAction("MI_Cut");

  QAction *paste = CommandManager::instance()->getAction("MI_Paste");

  menu.addAction(resetCenter);

  menu.addSeparator();

  menu.addAction(clear);

  menu.addAction(copy);

  menu.addAction(cut);

  menu.addAction(paste);

  menu.addSeparator();

  menu.addAction(group);

  menu.exec(cme->screenPos());

}

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

//

// CameraPainter

//

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

CameraPainter::CameraPainter(StageSchematicCameraNode *parent, double width,

                             double height, const QString &name)

    : QGraphicsItem(parent)

    , m_width(width)

    , m_height(height)

    , m_parent(parent)

    , m_name(name) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  TXsheet *xsh = stageScene->getXsheet();

  m_isActive   = xsh->getStageObjectTree()->getCurrentCameraId() ==

               parent->getStageObject()->getId();

}

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

CameraPainter::~CameraPainter() {}

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

QRectF CameraPainter::boundingRect() const {

  return QRectF(-5, -5, m_width + 10, m_height + 10);

}

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

void CameraPainter::paint(QPainter *painter,

                          const QStyleOptionGraphicsItem *option,

                          QWidget *widget) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  if (!stageScene) return;

  SchematicViewer *viewer = stageScene->getSchematicViewer();

  QColor cameraColor      = m_isActive ? viewer->getActiveCameraColor()

                                       : viewer->getOtherCameraColor();

  painter->setBrush(cameraColor);

  painter->setPen(Qt::NoPen);

  painter->drawRect(QRectF(0, 0, m_width, m_height));

  if (!m_parent->isNameEditing()) {

    if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())

      painter->setPen(viewer->getSelectedNodeTextColor());

    else

      painter->setPen(viewer->getTextColor());

    // Draw the name

    QRectF rect(18, 0, 54, 18);

    QString elidedName = elideText(m_name, painter->font(), rect.width());

    painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, elidedName);

  }

}

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

void CameraPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  QMenu menu(stageScene->views()[0]);

  QAction *cameraSettings =

      CommandManager::instance()->getAction("MI_CameraStage");

  QAction *resetCenter = new QAction(tr("&Reset Center"), &menu);

  connect(resetCenter, SIGNAL(triggered()), stageScene, SLOT(onResetCenter()));

  QAction *activate = new QAction(tr("&Activate"), &menu);

  connect(activate, SIGNAL(triggered()), stageScene, SLOT(onCameraActivate()));

  QAction *clear = CommandManager::instance()->getAction("MI_Clear");

  QAction *copy  = CommandManager::instance()->getAction("MI_Copy");

  QAction *cut   = CommandManager::instance()->getAction("MI_Cut");

  QAction *paste = CommandManager::instance()->getAction("MI_Paste");

  bool isDeactivated =

      m_parent->getStageObject()->getId() !=

      stageScene->getXsheet()->getStageObjectTree()->getCurrentCameraId();

  if (isDeactivated)

    menu.addAction(activate);

  else

    menu.addAction(cameraSettings);

  menu.addAction(resetCenter);

  menu.addSeparator();

  if (isDeactivated) menu.addAction(clear);

  menu.addAction(copy);

  if (isDeactivated) menu.addAction(cut);

  menu.addAction(paste);

  menu.exec(cme->screenPos());

}

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

//

// TablePainter

//

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

TablePainter::TablePainter(StageSchematicTableNode *parent, double width,

                           double height)

    : QGraphicsItem(parent)

    , m_width(width)

    , m_height(height)

    , m_parent(parent) {}

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

TablePainter::~TablePainter() {}

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

QRectF TablePainter::boundingRect() const {

  return QRectF(-5, -5, m_width + 10, m_height + 10);

}

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

void TablePainter::paint(QPainter *painter,

                         const QStyleOptionGraphicsItem *option,

                         QWidget *widget) {

  QPixmap tablePm = QPixmap(":Resources/schematic_tablenode.png");

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  if (!stageScene) return;

  SchematicViewer *viewer = stageScene->getSchematicViewer();

  painter->setBrush(viewer->getTableColor());

  painter->setPen(Qt::NoPen);

  painter->drawRect(QRectF(0, 0, m_width, m_height));

  QRect imgRect(3, -3, 24, 24);

  painter->drawPixmap(imgRect, tablePm);

  if (stageScene->getCurrentObject() == m_parent->getStageObject()->getId())

    painter->setPen(viewer->getSelectedNodeTextColor());

  else

    painter->setPen(viewer->getTextColor());

  // Draw the name

  QRectF rect(30, 0, 42, 18);

  painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter,

                    QString(tr("Table")));

}

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

void TablePainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  QMenu menu(stageScene->views()[0]);

  QAction *resetCenter = new QAction(tr("&Reset Center"), &menu);

  connect(resetCenter, SIGNAL(triggered()), stageScene, SLOT(onResetCenter()));

  menu.addAction(resetCenter);

  menu.exec(cme->screenPos());

}

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

//

// SplinePainter

//

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

SplinePainter::SplinePainter(StageSchematicSplineNode *parent, double width,

                             double height, const QString &name)

    : QGraphicsItem(parent)

    , m_parent(parent)

    , m_width(width)

    , m_height(height)

    , m_name(name) {}

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

SplinePainter::~SplinePainter() {}

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

QRectF SplinePainter::boundingRect() const {

  if (m_parent->isOpened())

    return QRectF(-5, -5, m_width + 10, m_height + 59);

  else

    return QRectF(-5, -5, m_width + 10, m_height + 10);

}

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

void SplinePainter::paint(QPainter *painter,

                          const QStyleOptionGraphicsItem *option,

                          QWidget *widget) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  if (!stageScene) return;

  SchematicViewer *viewer = stageScene->getSchematicViewer();

  painter->setBrush(viewer->getSplineColor());

  painter->setPen(Qt::NoPen);

  painter->drawRoundRect(QRectF(0, 0, m_width, m_height), 20, 99);

  if (m_parent->isOpened()) {

    // Draw the pixmap

    painter->setBrush(Qt::NoBrush);

    painter->setPen(QColor(0, 0, 0, 255));

    QPixmap pixmap = scalePixmapKeepingAspectRatio(

        m_parent->getPixmap(), QSize(m_width, 49), Qt::transparent);

    if (!pixmap.isNull()) {

      painter->drawPixmap(QPointF(0, 18), pixmap);

    } else {

      painter->setBrush(QColor(255, 255, 255, 255));

      painter->drawRect(0, 18, m_width, 49);

    }

  }

  //! draw the name only if it is not editing

  if (!m_parent->isNameEditing()) {

    /* There is no current spline

              TStageObjectId currObj = stageScene->getCurrentObject();

        if(currObj.getCode() == m_parent->getSpline()->getId())

          painter->setPen(viewer->getSelectedNodeTextColor());

        else

    */

    painter->setPen(viewer->getTextColor());

    QRectF rect(18, 0, 72, 18);

    QString elidedName = elideText(m_name, painter->font(), rect.width());

    painter->drawText(rect, Qt::AlignLeft | Qt::AlignVCenter, elidedName);

  }

}

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

void SplinePainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  QMenu menu(stageScene->views()[0]);

  QAction *removeSpline = new QAction(tr("&Delete"), &menu);

  connect(removeSpline, SIGNAL(triggered()), stageScene,

          SLOT(onRemoveSpline()));

  QAction *saveSpline = new QAction(tr("&Save Motion Path..."), &menu);

  connect(saveSpline, SIGNAL(triggered()), stageScene, SLOT(onSaveSpline()));

  QAction *loadSpline = new QAction(tr("&Load Motion Path..."), &menu);

  connect(loadSpline, SIGNAL(triggered()), stageScene, SLOT(onLoadSpline()));

  QAction *copy  = CommandManager::instance()->getAction("MI_Copy");

  QAction *cut   = CommandManager::instance()->getAction("MI_Cut");

  QAction *paste = CommandManager::instance()->getAction("MI_Paste");

  menu.addAction(saveSpline);

  menu.addAction(loadSpline);

  menu.addSeparator();

  menu.addAction(removeSpline);

  menu.addAction(copy);

  menu.addAction(cut);

  menu.addAction(paste);

  menu.exec(cme->screenPos());

}

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

//

// StageSchematicNodePort

//

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

StageSchematicNodePort::StageSchematicNodePort(StageSchematicNodeDock *parent,

                                               int type)

    : SchematicPort(parent, parent->getNode(), type), m_handle("") {

  QRectF rect = boundingRect();

  if (parent->isParentPort())

    m_hook = QPointF(rect.left(), (rect.top() + rect.bottom()) * 0.5);

  else

    m_hook = QPointF(rect.right(), (rect.top() + rect.bottom()) * 0.5);

}

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

StageSchematicNodePort::~StageSchematicNodePort() {}

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

QRectF StageSchematicNodePort::boundingRect() const {

  return QRectF(0, 0, 18, 18);

}

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

void StageSchematicNodePort::paint(QPainter *painter,

                                   const QStyleOptionGraphicsItem *option,

                                   QWidget *widget) {

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

  StageSchematicScene *scene =

      dynamic_cast<stageschematicscene *="">(this->scene());</stageschematicscene>

  if (scene && scene->isShowLetterOnPortFlagEnabled()) {

    painter->setBrush(QColor(255, 255, 255, 255));

    painter->setPen(QColor(180, 180, 180, 255));

    painter->drawRect(boundingRect());

    if (m_type == 103 || m_type == 104 || m_type == 105) return;

    painter->setPen(QColor(0, 0, 0, 255));

    QFont font("Verdana", 8);

    painter->setFont(font);

    QTextOption textOption(Qt::AlignCenter);

    QString text = m_handle;

    if (text.size() > 1 && text.at(0) == 'H') text.remove("H");

    painter->drawText(boundingRect(), text, textOption);

  } else {

    QRect imgRect(2, 2, 14, 14);

    QRect sourceRect = scene->views()[0]->matrix().mapRect(imgRect);

    QPixmap pixmap;

    if (getType() == eStageParentPort || getType() == eStageParentGroupPort) {

      if (isHighlighted())

        pixmap = QIcon(":Resources/port_blue_highlight.svg")

                     .pixmap(sourceRect.size());

      else

        pixmap = QIcon(":Resources/port_blue.svg").pixmap(sourceRect.size());

    } else {

      if (isHighlighted())

        pixmap = QIcon(":Resources/port_red_highlight.svg")

                     .pixmap(sourceRect.size());

      else

        pixmap = QIcon(":Resources/port_red.svg").pixmap(sourceRect.size());

    }

    painter->drawPixmap(imgRect, pixmap);

  }

}

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

bool StageSchematicNodePort::linkTo(SchematicPort *port, bool checkOnly) {

  StageSchematicScene *stageScene =

      dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

  if (!port) return false;

  StageSchematicNode *srcNode = dynamic_cast<stageschematicnode *="">(getNode());</stageschematicnode>

  if (this == port && !srcNode->getStageObject()->isGrouped()) {

    if (!checkOnly)

      TStageObjectCmd::setParent(srcNode->getStageObject()->getId(),

                                 TStageObjectId::NoneId, "",

                                 stageScene->getXsheetHandle());

    return true;

  }

  StageSchematicNode *dstNode =

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

  if (!dstNode) return false;

  if (srcNode == dstNode) return false;

  TStageObject *pegbar = 0, *parentPegbar = 0;

  SchematicPort *childPort, *parentPort;

  if (getType() == eStageParentPort && port->getType() == eStageChildPort) {

    pegbar       = srcNode->getStageObject();

    parentPegbar = dstNode->getStageObject();

    childPort    = this;

    parentPort   = port;

  } else if (getType() == eStageChildPort &&

             port->getType() == eStageParentPort) {

    pegbar       = dstNode->getStageObject();

    parentPegbar = srcNode->getStageObject();

    childPort    = port;

    parentPort   = this;

  } else

    return false;

  if (pegbar->getId().isTable()) return false;

  if (pegbar->getId().isPegbar() && !parentPegbar->getId().isTable() &&

      !parentPegbar->getId().isPegbar() && !parentPegbar->getId().isCamera())

    return false;

  if (parentPegbar == pegbar || parentPegbar->isAncestor(pegbar)) return false;

  if (parentPegbar->isGrouped() || pegbar->isGrouped()) return false;

  if (checkOnly) return true;

  StageSchematicNodePort *dstPort =

      dynamic_cast<stageschematicnodeport *="">(parentPort);</stageschematicnodeport>

  if (!dstPort) return false;

  TStageObjectCmd::setParent(pegbar->getId(), parentPegbar->getId(),

                             dstPort->getHandle().toStdString(),

                             stageScene->getXsheetHandle());

  return true;

}

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

SchematicPort *StageSchematicNodePort::searchPort(const QPointF &scenePos) {

  QList<qgraphicsitem *=""> items = scene()->items(scenePos);</qgraphicsitem>

  int i;

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

    StageSchematicNodePort *linkingTo =

        dynamic_cast<stageschematicnodeport *="">(items[i]);</stageschematicnodeport>

    if (linkingTo) {

      StageSchematicNode *node =

          dynamic_cast<stageschematicnode *="">(linkingTo->getNode());</stageschematicnode>

      if (!node->getStageObject()->isGrouped()) return linkingTo;

    }

  }

  return 0;

}

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

void StageSchematicNodePort::hideSnappedLinks(SchematicPort *linkingPort) {

  if (!linkingPort) return;

  if (getType() == eStageChildPort &&

      linkingPort->getType() == eStageParentPort &&

      linkingPort->getLinkCount() == 1)

    linkingPort->getLink(0)->hide();

  if (getType() == eStageParentPort &&

      linkingPort->getType() == eStageChildPort && getLinkCount() == 1)

    getLink(0)->hide();

}

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

void StageSchematicNodePort::showSnappedLinks(SchematicPort *linkingPort) {

  if (!linkingPort) return;

  if (getType() == eStageChildPort &&

      linkingPort->getType() == eStageParentPort &&

      linkingPort->getLinkCount() == 1) {

    linkingPort->getLink(0)->show();

    linkingPort->highLight(true);

    linkingPort->update();

  }

  if (getType() == eStageParentPort &&

      linkingPort->getType() == eStageChildPort && getLinkCount() == 1) {

    getLink(0)->show();

    linkingPort->highLight(true);

    linkingPort->update();

  }

}

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

//

// StageSchematicSplinePort

//

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

StageSchematicSplinePort::StageSchematicSplinePort(