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

#include <QApplication>

#include <QMenu>

#include <QGraphicsSceneMouseEvent>

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

//    Local namespace

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

namespace

{

bool isAInnerMacroFx(TFx *fx, TXsheet *xsh)

{

	if (!fx)

		return false;

	TColumnFx *cfx = dynamic_cast<TColumnFx *>(fx);

	TXsheetFx *xfx = dynamic_cast<TXsheetFx *>(fx);

	TOutputFx *ofx = dynamic_cast<TOutputFx *>(fx);

	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 vector<TFxPort *> &ports)

{

	vector<TFxPort *>::const_iterator it = 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());

	if (lcfx) {

		int index = lcfx->getColumnIndex();

		QString id = QString("Col");

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

		FxSchematicScene *fxScene = dynamic_cast<FxSchematicScene *>(scene());

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

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

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

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

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

	if (lcfx) {

		int index = lcfx->getColumnIndex();

		QString id = QString("Col");

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

		FxSchematicScene *fxScene = dynamic_cast<FxSchematicScene *>(scene());

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

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

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

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

	}

		CASE eZeraryFx:

		{

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

			if (zfx) {

				TFx *zeraryFx = zfx->getZeraryFx();

				if (zeraryFx) {

					m_label = QString::fromStdWString(TStringTable::translate(zeraryFx->getFxType()));

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

				}

			}

		}

		CASE eGroupedFx:

		{

			m_label = QString("Group ") + QString::number(parent->getFx()->getAttributes()->getGroupId());

			setToolTip(m_label);

		}

	}

}

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

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

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

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

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

	QAction *unlinkFx = new QAction(tr("&Unlink"), &menu);

	connect(unlinkFx, SIGNAL(triggered()), fxScene, SLOT(onUnlinkFx()));

	QAction *macroFx = new QAction(tr("&Make Macro FX"), &menu);

	connect(macroFx, SIGNAL(triggered()), fxScene, SLOT(onMacroFx()));

	QAction *explodeMacroFx = new QAction(tr("&Explode Macro FX"), &menu);

	connect(explodeMacroFx, SIGNAL(triggered()), fxScene, SLOT(onExplodeMacroFx()));

	QAction *openMacroFx = new QAction(tr("&Open Macro FX"), &menu);

	connect(openMacroFx, SIGNAL(triggered()), fxScene, SLOT(onOpenMacroFx()));

	QAction *savePresetFx = new QAction(tr("&Save As Preset..."), &menu);

	connect(savePresetFx, SIGNAL(triggered()), fxScene, SLOT(onSavePresetFx()));

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

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

	bool cacheEnabled = m_parent->isCached();