#include "toonzqt/fxschematicnode.h"

// TnzQt includes

#include "toonzqt/fxschematicscene.h"

#include "toonzqt/icongenerator.h"

#include "toonzqt/gutil.h"

#include "toonzqt/fxselection.h"

#include "toonzqt/menubarcommand.h"

#include "toonzqt/fxiconmanager.h"

// TnzLib includes

#include "toonz/tcolumnfx.h"

#include "toonz/tcolumnfxset.h"

#include "toonz/txshchildlevel.h"

#include "toonz/txsheet.h"

#include "toonz/fxdag.h"

#include "toonz/tstageobjectid.h"

#include "toonz/tstageobject.h"

#include "toonz/txshcell.h"

#include "toonz/txsheethandle.h"

#include "toonz/tframehandle.h"

#include "toonz/fxcommand.h"

#include "toonz/tstageobjectcmd.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/txshcolumn.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshleveltypes.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/preferences.h"

#include "tw/stringtable.h"

// TnzBase includes

#include "tfx.h"

#include "tfxattributes.h"

#include "tmacrofx.h"

#include "trasterfx.h"

#include "tpassivecachemanager.h"

// TnzCore includes

#include "tconst.h"

// Qt includes

#include <qaction></qaction>

#include <qapplication></qapplication>

#include <qmenu></qmenu>

#include <qgraphicsscenemouseevent></qgraphicsscenemouseevent>

//********************************************************************************

//    Local namespace

//********************************************************************************

namespace {

bool isAInnerMacroFx(TFx *fx, TXsheet *xsh) {

  if (!fx) return false;

  TColumnFx *cfx      = dynamic_cast<tcolumnfx *="">(fx);</tcolumnfx>

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

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

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

  return !cfx && !xfx && !ofx && !internalFxs->containsFx(fx);

}

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

void drawCachedFxFlap(QPainter *painter, const QPointF &pos) {

  painter->save();

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

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

  QPainterPath path(pos);

  path.lineTo(pos.x(), pos.y() - 10.0);

  path.lineTo(pos.x() - 10.0, pos.y());

  path.lineTo(pos);

  painter->drawPath(path);

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

  QPointF newPos = pos + QPointF(-10.0, -10.0);

  path           = QPainterPath(newPos);

  path.lineTo(newPos.x(), newPos.y() + 10.0);

  path.lineTo(newPos.x() + 10.0, newPos.y());

  path.lineTo(newPos);

  painter->drawPath(path);

  painter->restore();

}

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

int getIndex(TFxPort *port, const std::vector<tfxport *=""> &ports) {</tfxport>

  std::vector<tfxport *="">::const_iterator it =</tfxport>

      std::find(ports.begin(), ports.end(), port);

  if (it == ports.end()) return -1;

  return std::distance(ports.begin(), it);

}

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

int getInputPortIndex(TFxPort *port, TFx *fx) {

  int count = fx->getInputPortCount();

  int i;

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

    if (port == fx->getInputPort(i)) return i;

  }

  return -1;

}

}  // namespace

//*****************************************************

//

// FxColumnPainter

//

//*****************************************************

FxColumnPainter::FxColumnPainter(FxSchematicColumnNode *parent, double width,

                                 double height, const QString &name)

    : QGraphicsItem(parent)

    , m_parent(parent)

    , m_name(name)

    , m_width(width)

    , m_height(height) {

  setFlag(QGraphicsItem::ItemIsMovable, false);

  setFlag(QGraphicsItem::ItemIsSelectable, false);

  setFlag(QGraphicsItem::ItemIsFocusable, false);

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

          SLOT(onIconGenerated()));

  TLevelColumnFx *lcfx = dynamic_cast<tlevelcolumnfx *="">(parent->getFx());</tlevelcolumnfx>

  if (lcfx) {

    int index  = lcfx->getColumnIndex();

    QString id = QString("Col");

    setToolTip(id + QString::number(index + 1));

    FxSchematicScene *fxScene = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

    if (!fxScene) return;

    TXsheet *xsh = fxScene->getXsheet();

    int r0, r1;

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

    if (r0 > r1) return;

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

    m_type             = firstCell.m_level->getType();

  }

}

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

FxColumnPainter::~FxColumnPainter() {}

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

QRectF FxColumnPainter::boundingRect() const {

  if (m_parent->isOpened() && m_parent->isLargeScaled())

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

  else

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

}

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

void FxColumnPainter::paint(QPainter *painter,

                            const QStyleOptionGraphicsItem *option,

                            QWidget *widget) {

  int levelType;

  QString levelName;

  m_parent->getLevelTypeAndName(levelType, levelName);

  QLinearGradient linearGrad = getGradientByLevelType(levelType);

  if (!m_parent->isLargeScaled()) linearGrad.setFinalStop(0, 50);

  painter->setBrush(QBrush(linearGrad));

  painter->setPen(Qt::NoPen);

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

  if (m_parent->isOpened() && m_parent->isLargeScaled()) {

    // 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(Qt::white);

  painter->setBrush(Qt::NoBrush);

  QRectF columnNameRect;

  QRectF levelNameRect;

  if (m_parent->isLargeScaled()) {

    columnNameRect = QRect(18, 2, 54, 14);

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

  } else {

    columnNameRect = QRect(4, 2, 78, 22);

    levelNameRect  = QRectF(4, 26, 78, 22);

    QFont fnt = painter->font();

    fnt.setPixelSize(fnt.pixelSize() * 2);

    painter->setFont(fnt);

  }

  // column name

  if (!m_parent->isNameEditing()) {

    FxSchematicScene *sceneFx = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

    if (!sceneFx) return;

    // if this is a current object

    if (sceneFx->getCurrentFx() == m_parent->getFx())

      painter->setPen(Qt::yellow);

    QString elidedName =

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

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

                      elidedName);

  }

  // level name

  QString elidedName =

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

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

                    elidedName);

}

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

QLinearGradient FxColumnPainter::getGradientByLevelType(int type) {

  QColor col1, col2, col3, col4, col5;

  int alpha = 200;

  switch (type) {

  case TZI_XSHLEVEL:

  case OVL_XSHLEVEL:

    col1 = QColor(209, 232, 234, alpha);

    col2 = QColor(121, 171, 181, alpha);

    col3 = QColor(98, 143, 165, alpha);

    col4 = QColor(33, 90, 118, alpha);

    col5 = QColor(122, 172, 173, alpha);

    break;

  case PLI_XSHLEVEL:

    col1 = QColor(236, 226, 182, alpha);

    col2 = QColor(199, 187, 95, alpha);

    col3 = QColor(180, 180, 67, alpha);

    col4 = QColor(130, 125, 15, alpha);

    col5 = QColor(147, 150, 28, alpha);

    break;

  case TZP_XSHLEVEL:

    col1 = QColor(196, 245, 196, alpha);

    col2 = QColor(111, 192, 105, alpha);

    col3 = QColor(63, 146, 99, alpha);

    col4 = QColor(32, 113, 86, alpha);

    col5 = QColor(117, 187, 166, alpha);

    break;

  case ZERARYFX_XSHLEVEL:

    col1 = QColor(232, 245, 196, alpha);

    col2 = QColor(130, 129, 93, alpha);

    col3 = QColor(113, 115, 81, alpha);

    col4 = QColor(55, 59, 25, alpha);

    col5 = QColor(144, 154, 111, alpha);

    break;

  case CHILD_XSHLEVEL:

    col1 = QColor(247, 208, 241, alpha);

    col2 = QColor(214, 154, 219, alpha);

    col3 = QColor(170, 123, 169, alpha);

    col4 = QColor(92, 52, 98, alpha);

    col5 = QColor(132, 111, 154, alpha);

    break;

  case MESH_XSHLEVEL:

    col1 = QColor(210, 140, 255, alpha);

    col2 = QColor(200, 130, 255, alpha);

    col3 = QColor(150, 80, 180, alpha);

    col4 = QColor(150, 80, 180, alpha);

    col5 = QColor(180, 120, 220, alpha);

    break;

  case UNKNOWN_XSHLEVEL:

  case NO_XSHLEVEL:

  default:

    col1 = QColor(227, 227, 227, alpha);

    col2 = QColor(174, 174, 174, alpha);

    col3 = QColor(123, 123, 123, alpha);

    col4 = QColor(61, 61, 61, alpha);

    col5 = QColor(127, 138, 137, alpha);

  }

  QLinearGradient linearGrad(QPointF(0, 0), QPointF(0, 32));

  linearGrad.setColorAt(0, col1);

  linearGrad.setColorAt(0.08, col2);

  linearGrad.setColorAt(0.20, col3);

  linearGrad.setColorAt(0.23, col4);

  linearGrad.setColorAt(0.9, col4);

  linearGrad.setColorAt(1, col5);

  return linearGrad;

}

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

void FxColumnPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {

  FxSchematicScene *fxScene = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

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

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

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

  bool enebleInsertAction =

      !m_parent->getFx()->getAttributes()->isGrouped() ||

      m_parent->getFx()->getAttributes()->isGroupEditing();

  if (enebleInsertAction) {

    // repeat the latest action

    if (cme->modifiers() & Qt::ControlModifier) {

      menu.addAction(fxScene->getAgainAction(AddFxContextMenu::Add |

                                             AddFxContextMenu::Insert));

      if (!menu.actions().isEmpty()) {

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

        return;

      }

    }

  }

  QMenu *insertMenu = fxScene->getInsertFxMenu();

  fxScene->initCursorScenePos();

  QMenu *addMenu = fxScene->getAddFxMenu();

  QAction *disconnectFromXSheet =

      new QAction(tr("&Disconnect from Xsheet"), &menu);

  connect(disconnectFromXSheet, SIGNAL(triggered()), fxScene,

          SLOT(onDisconnectFromXSheet()));

  QAction *connectToXSheet = new QAction(tr("&Connect to Xsheet"), &menu);

  connect(connectToXSheet, SIGNAL(triggered()), fxScene,

          SLOT(onConnectToXSheet()));

  QAction *addOutputFx =

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

  QIcon addOutputFxIcon = createQIconOnOffPNG("output", false);

  if (addOutputFx) addOutputFx->setIcon(addOutputFxIcon);

  QAction *addPaste = new QAction(tr("&Paste Add"), &menu);

  connect(addPaste, SIGNAL(triggered()), fxScene, SLOT(onAddPaste()));

  QAction *preview = new QAction(tr("&Preview"), &menu);

  connect(preview, SIGNAL(triggered()), fxScene, SLOT(onPreview()));

  bool cacheEnabled =

      TPassiveCacheManager::instance()->cacheEnabled(m_parent->getFx());

  QAction *cacheFx =

      new QAction(cacheEnabled ? tr("&Uncache Fx") : tr("&Cache FX"), &menu);

  if (cacheEnabled)

    connect(cacheFx, SIGNAL(triggered()), fxScene, SLOT(onUncacheFx()));

  else

    connect(cacheFx, SIGNAL(triggered()), fxScene, SLOT(onCacheFx()));

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

  QAction *openSubxsh = new QAction(tr("&Open Subxsheet"), &menu);

  connect(openSubxsh, SIGNAL(triggered()), fxScene, SLOT(onOpenSubxsheet()));

  QAction *explodeChild =

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

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

  menu.addMenu(insertMenu);

  menu.addMenu(addMenu);

  menu.addSeparator();

  if (!m_parent->getFx()->getAttributes()->isGrouped()) {

    menu.addAction(copy);

    menu.addAction(cut);

    menu.addAction(addPaste);

  }

  menu.addSeparator();

  if (fxScene->getXsheet()->getFxDag()->getTerminalFxs()->containsFx(

          m_parent->getFx()))

    menu.addAction(disconnectFromXSheet);

  else

    menu.addAction(connectToXSheet);

  if (!m_parent->getFx()->getAttributes()->isGrouped())

    menu.addAction(addOutputFx);

  menu.addAction(preview);

  menu.addAction(cacheFx);

  menu.addSeparator();

  if (enebleInsertAction) {

    menu.addAction(collapse);

  }

  TFrameHandle *frameHandle = fxScene->getFrameHandle();

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

    TLevelColumnFx *colFx = dynamic_cast<tlevelcolumnfx *="">(m_parent->getFx());</tlevelcolumnfx>

    assert(colFx);

    int col       = colFx->getColumnIndex();

    int fr        = frameHandle->getFrame();

    TXsheet *xsh  = fxScene->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(group);

  if (m_type == OVL_XSHLEVEL || m_type == TZP_XSHLEVEL ||

      m_type == PLI_XSHLEVEL) {

    QAction *viewFileCommand =

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

    menu.addSeparator();

    menu.addAction(viewFileCommand);

    QAction *levelSettings =

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

    menu.addAction(levelSettings);

  }

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

}

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

void FxColumnPainter::onIconGenerated() {

  if (m_type != OVL_XSHLEVEL) return;

  TLevelColumnFx *lcfx = dynamic_cast<tlevelcolumnfx *="">(m_parent->getFx());</tlevelcolumnfx>

  if (lcfx) {

    int index  = lcfx->getColumnIndex();

    QString id = QString("Col");

    setToolTip(id + QString::number(index + 1));

    FxSchematicScene *fxScene = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

    if (!fxScene) return;

    TXsheet *xsh = fxScene->getXsheet();

    int r0, r1;

    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();

    }

  }

}

//*****************************************************

//

// FxPalettePainter

//

//*****************************************************

FxPalettePainter::FxPalettePainter(FxSchematicPaletteNode *parent, double width,

                                   double height, const QString &name)

    : QGraphicsItem(parent)

    , m_parent(parent)

    , m_name(name)

    , m_width(width)

    , m_height(height) {

  setFlag(QGraphicsItem::ItemIsMovable, false);

  setFlag(QGraphicsItem::ItemIsSelectable, false);

  setFlag(QGraphicsItem::ItemIsFocusable, false);

  TLevelColumnFx *lcfx = dynamic_cast<tlevelcolumnfx *="">(parent->getFx());</tlevelcolumnfx>

  if (lcfx) {

    int index  = lcfx->getColumnIndex() + 1;

    QString id = QString("Col");

    setToolTip(id + QString::number(index));

  }

}

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

FxPalettePainter::~FxPalettePainter() {}

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

QRectF FxPalettePainter::boundingRect() const {

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

}

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

void FxPalettePainter::paint(QPainter *painter,

                             const QStyleOptionGraphicsItem *option,

                             QWidget *widget) {

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

  int alpha = 200;

  QLinearGradient paletteLinearGrad(

      QPointF(0, 0), QPointF(0, (m_parent->isLargeScaled()) ? 32 : 50));

  paletteLinearGrad.setColorAt(0, QColor(42, 171, 154, alpha));

  paletteLinearGrad.setColorAt(0.2, QColor(15, 62, 56, alpha));

  paletteLinearGrad.setColorAt(0.9, QColor(15, 62, 56, alpha));

  paletteLinearGrad.setColorAt(1, QColor(33, 95, 90, alpha));

  painter->setBrush(QBrush(paletteLinearGrad));

  painter->setPen(Qt::NoPen);

  if (m_parent->isLargeScaled())

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

  else

    painter->drawRoundRect(QRectF(0, 0, m_width, m_height), 10, 30);

  // draw icon

  QRect paletteRect;

  QRectF idRect;

  QRectF palNameRect;

  if (m_parent->isLargeScaled()) {

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

    idRect      = QRectF(18, 2, 54, 14);

    palNameRect = QRectF(18, 16, 54, 14);

  } else {

    paletteRect = QRect(4, -6, 35, 28);

    idRect      = QRectF(25, 2, 49, 22);

    palNameRect = QRectF(4, 26, 78, 22);

    QFont fnt = painter->font();

    fnt.setPixelSize(fnt.pixelSize() * 2);

    painter->setFont(fnt);

  }

  painter->drawPixmap(paletteRect, palettePm);

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

  painter->setPen(Qt::white);

  if (!m_parent->isNameEditing()) {

    FxSchematicScene *sceneFx = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

    if (!sceneFx) return;

    if (sceneFx->getCurrentFx() == m_parent->getFx())

      painter->setPen(Qt::yellow);

    int w = idRect.width();

    if (m_parent->isLargeScaled()) {

      QString elidedName = elideText(m_name, painter->font(), w);

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

    } else

      painter->drawText(idRect, Qt::AlignRight | Qt::AlignVCenter,

                        QString::number(m_parent->getColumnIndex() + 1));

  }

  // level name

  QString paletteName = m_parent->getPaletteName();

  QString elidedName =

      elideText(paletteName, painter->font(), palNameRect.width());

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

}

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

void FxPalettePainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {

  FxSchematicScene *fxScene = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

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

  QAction *disconnectFromXSheet =

      new QAction(tr("&Disconnect from Xsheet"), &menu);

  connect(disconnectFromXSheet, SIGNAL(triggered()), fxScene,

          SLOT(onDisconnectFromXSheet()));

  QAction *connectToXSheet = new QAction(tr("&Connect to Xsheet"), &menu);

  connect(connectToXSheet, SIGNAL(triggered()), fxScene,

          SLOT(onConnectToXSheet()));

  QAction *preview = new QAction(tr("&Preview"), &menu);

  connect(preview, SIGNAL(triggered()), fxScene, SLOT(onPreview()));

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

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

  bool enebleInsertAction =

      !m_parent->getFx()->getAttributes()->isGrouped() ||

      m_parent->getFx()->getAttributes()->isGroupEditing();

  if (enebleInsertAction) {

    if (fxScene->getXsheet()->getFxDag()->getTerminalFxs()->containsFx(

            m_parent->getFx()))

      menu.addAction(disconnectFromXSheet);

    else

      menu.addAction(connectToXSheet);

    menu.addAction(preview);

    menu.addSeparator();

    menu.addAction(collapse);

    menu.addSeparator();

  }

  menu.addAction(group);

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

}

//*****************************************************

//

// FxPainter

//

//*****************************************************

FxPainter::FxPainter(FxSchematicNode *parent, double width, double height,

                     const QString &name, eFxType type, std::string fxType)

    : QGraphicsItem(parent)

    , m_parent(parent)

    , m_name(name)

    , m_width(width)

    , m_height(height)

    , m_type(type)

    , m_fxType(fxType) {

  setFlag(QGraphicsItem::ItemIsMovable, false);

  setFlag(QGraphicsItem::ItemIsSelectable, false);

  setFlag(QGraphicsItem::ItemIsFocusable, false);

  switch (m_type) {

  case eNormalFx:

  case eMacroFx:

  case eNormalLayerBlendingFx:

  case eNormalMatteFx:

  case eNormalImageAdjustFx:

    m_label = QString::fromStdWString(

        TStringTable::translate(parent->getFx()->getFxType()));

    setToolTip(QString::fromStdWString(parent->getFx()->getFxId()));

    break;

  case eZeraryFx: {

    TZeraryColumnFx *zfx = dynamic_cast<tzerarycolumnfx *="">(parent->getFx());</tzerarycolumnfx>

    if (zfx) {

      TFx *zeraryFx = zfx->getZeraryFx();

      if (zeraryFx) {

        m_label = QString::fromStdWString(

            TStringTable::translate(zeraryFx->getFxType()));

        setToolTip(QString::fromStdWString(zeraryFx->getFxId()));

      }

    }

    break;

  }

  case eGroupedFx:

    m_label = QString("Group ") +

              QString::number(parent->getFx()->getAttributes()->getGroupId());

    setToolTip(m_label);

    break;

  }

}

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

FxPainter::~FxPainter() {}

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

QRectF FxPainter::boundingRect() const {

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

}

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

void FxPainter::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,

                      QWidget *widget) {

  // if the scale is small, display with fx icons

  if (!m_parent->isLargeScaled()) {

    paint_small(painter);

    return;

  }

  if (m_type == eGroupedFx) {

    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();

  }

  // draw base rect

  QLinearGradient linearGrad = getGradientByLevelType(m_type);

  painter->setBrush(QBrush(linearGrad));

  painter->setPen(Qt::NoPen);

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

  // draw diagonal line for disabled fx

  bool is_enabled = m_parent->isEnabled();

  if (!is_enabled) {

    painter->save();

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

    painter->drawLine(QPointF(0, m_height), QPointF(m_width, 0));

    painter->drawLine(QPointF(0, 0), QPointF(m_width, m_height));

    painter->restore();

  }

  QFont columnFont(painter->font());

  columnFont.setPixelSize(columnFont.pixelSize() - 1);

  painter->setFont(columnFont);

  // draw fxId in the bottom part

  painter->setPen(Qt::white);

  if (m_type != eGroupedFx) {

    // for zerary fx

    QString label;

    if (m_type == eZeraryFx) {

      TZeraryColumnFx *zcFx =

          dynamic_cast<tzerarycolumnfx *="">(m_parent->getFx());</tzerarycolumnfx>

      if (!zcFx) return;

      label = QString::fromStdWString(zcFx->getZeraryFx()->getFxId());

    } else

      label = QString::fromStdWString(m_parent->getFx()->getFxId());

    label   = elideText(label, painter->font(), m_width - 21);

    painter->drawText(QRectF(3, 16, m_width - 21, 14),

                      Qt::AlignLeft | Qt::AlignVCenter, label);

  }

  // draw user-defined fx name in the upper part

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

  if (!m_parent->isNameEditing()) {

    FxSchematicScene *sceneFx = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

    if (!sceneFx) return;

    if (sceneFx->getCurrentFx() == m_parent->getFx())

      painter->setPen(Qt::yellow);

    QRectF rect(3, 2, m_width - 21, 14);

    int w              = rect.width();

    QString elidedName = elideText(m_name, painter->font(), w);

    painter->drawText(rect, elidedName);

  }

}

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

/*! return the gradient pattern according to the type of Fx

*/

QLinearGradient FxPainter::getGradientByLevelType(eFxType type) {

  QColor col1, col2, col3, col4, col5;

  int alpha = 200;

  switch (type) {

  case eNormalFx:

    col1 = QColor(129, 162, 188, alpha);

    col2 = QColor(109, 138, 166, alpha);

    col3 = QColor(94, 120, 150, alpha);

    col4 = QColor(94, 120, 150, alpha);

    col5 = QColor(52, 63, 104, alpha);

    break;

  case eZeraryFx:

    col1 = QColor(232, 245, 196, alpha);

    col2 = QColor(130, 129, 93, alpha);

    col3 = QColor(113, 115, 81, alpha);

    col4 = QColor(55, 59, 25, alpha);

    col5 = QColor(144, 154, 111, alpha);

    break;

  case eMacroFx:

    col1 = QColor(165, 117, 161, alpha);

    col2 = QColor(146, 99, 139, alpha);

    col3 = QColor(132, 86, 123, alpha);

    col4 = QColor(132, 86, 123, alpha);

    col5 = QColor(89, 46, 92, alpha);

    break;

  case eGroupedFx:

    col1 = QColor(104, 191, 211, alpha);

    col2 = QColor(91, 168, 192, alpha);

    col3 = QColor(76, 148, 177, alpha);

    col4 = QColor(76, 148, 177, alpha);

    col5 = QColor(43, 91, 139, alpha);

    break;

  case eNormalImageAdjustFx:

    col1 = QColor(97, 95, 143, alpha);

    col2 = QColor(95, 92, 140, alpha);

    col3 = QColor(88, 84, 131, alpha);

    col4 = QColor(88, 84, 131, alpha);

    col5 = QColor(69, 56, 100, alpha);

    break;

  case eNormalLayerBlendingFx:

    col1 = QColor(75, 127, 133, alpha);

    col2 = QColor(65, 112, 122, alpha);

    col3 = QColor(60, 108, 118, alpha);

    col4 = QColor(60, 108, 118, alpha);

    col5 = QColor(38, 71, 91, alpha);

    break;

  case eNormalMatteFx:

    col1 = QColor(195, 117, 116, alpha);

    col2 = QColor(188, 111, 109, alpha);

    col3 = QColor(181, 103, 103, alpha);

    col4 = QColor(181, 103, 103, alpha);

    col5 = QColor(161, 86, 84, alpha);

    break;

  default:

    break;

  }

  QLinearGradient linearGrad(QPointF(0, 0), QPointF(0, 32));

  linearGrad.setColorAt(0, col1);

  linearGrad.setColorAt(0.08, col2);

  linearGrad.setColorAt(0.20, col3);

  linearGrad.setColorAt(0.23, col4);

  linearGrad.setColorAt(0.9, col4);

  linearGrad.setColorAt(1, col5);

  if (type == eGroupedFx) {

    linearGrad.setColorAt(0.6, col4);

    linearGrad.setColorAt(0.699, col5);

    linearGrad.setColorAt(0.7, col4);

    linearGrad.setColorAt(0.799, col5);

    linearGrad.setColorAt(0.8, col4);

    linearGrad.setColorAt(0.899, col5);

  }

  return linearGrad;

}

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

void FxPainter::contextMenuEvent(QGraphicsSceneContextMenuEvent *cme) {

  FxSchematicScene *fxScene = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

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

  TFx *fx = m_parent->getFx();

  bool isInternalFx =

      fxScene->getXsheet()->getFxDag()->getInternalFxs()->containsFx(fx) ||

      m_type == eGroupedFx;

  bool enableGroupAction = m_parent->isA(eZeraryFx) || isInternalFx;

  bool enableInsertAction =

      enableGroupAction && (fx->getAttributes()->isGroupEditing() ||

                            !fx->getAttributes()->isGrouped());

  if (enableInsertAction) {

    // repeat the last command

    if (cme->modifiers() & Qt::ControlModifier) {

      int commands = (m_type != eGroupedFx)

                         ? AddFxContextMenu::Add | AddFxContextMenu::Insert |

                               AddFxContextMenu::Replace

                         : AddFxContextMenu::Add | AddFxContextMenu::Insert;

      menu.addAction(fxScene->getAgainAction(commands));

      if (!menu.actions().isEmpty()) {

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

        return;

      }

    }

  }

  QMenu *insertMenu    = fxScene->getInsertFxMenu();

  QMenu *replacefxMenu = fxScene->getReplaceFxMenu();

  fxScene->initCursorScenePos();

  QMenu *addMenu = fxScene->getAddFxMenu();

  QAction *fxEditorPopup =

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

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

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

  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()), fxScene, SLOT(onEditGroup()));

  QAction *replacePaste = new QAction(tr("&Paste Replace"), &menu);

  connect(replacePaste, SIGNAL(triggered()), fxScene, SLOT(onReplacePaste()));

  QAction *addPaste = new QAction(tr("&Paste Add"), &menu);

  connect(addPaste, SIGNAL(triggered()), fxScene, SLOT(onAddPaste()));

  QAction *addOutputFx =

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

  QIcon addOutputFxIcon = createQIconOnOffPNG("output", false);

  if (addOutputFx) addOutputFx->setIcon(addOutputFxIcon);

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

  connect(deleteFx, SIGNAL(triggered()), fxScene, SLOT(onDeleteFx()));

  QAction *disconnectFromXSheet =

      new QAction(tr("&Disconnect from Xsheet"), &menu);

  connect(disconnectFromXSheet, SIGNAL(triggered()), fxScene,

          SLOT(onDisconnectFromXSheet()));

  QAction *connectToXSheet = new QAction(tr("&Connect to Xsheet"), &menu);

  connect(connectToXSheet, SIGNAL(triggered()), fxScene,

          SLOT(onConnectToXSheet()));

  QAction *duplicateFx = new QAction(tr("&Create Linked FX"), &menu);

  connect(duplicateFx, SIGNAL(triggered()), fxScene, SLOT(onDuplicateFx()));