#ifndef FXSCHEMATICNODE_H

#define FXSCHEMATICNODE_H

// TnzQt includes

#include "schematicnode.h"

// Qt includes

#include <qgraphicsitem></qgraphicsitem>

#include <qlist></qlist>

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

//    Forward declarations

class TFx;

class TOutputFx;

class TXsheetFx;

class TZeraryColumnFx;

class TPaletteColumnFx;

class TLevelColumnFx;

class TStageObjectId;

class FxSchematicNode;

class FxSchematicScene;

class FxSchematicDock;

class FxSchematicColumnNode;

class FxSchematicPaletteNode;

class FxSchematicNormalFxNode;

class FxSchematicXSheetNode;

class FxSchematicOutputNode;

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

enum eFxSchematicPortType {

	eFxOutputPort = 200,

	eFxInputPort = 201,

	eFxLinkPort = 202,

	eFxGroupedInPort = 203,

	eFxGroupedOutPort = 204

};

enum eFxType {

	eNormalFx = 100,

	eZeraryFx = 101,

	eMacroFx = 102,

	eColumnFx = 103,

	eOutpuFx = 104,

	eXSheetFx = 106,

	eGroupedFx = 107,

	eNormalImageAdjustFx = 108,

	eNormalLayerBlendingFx = 109,

	eNormalMatteFx = 110

};

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

//    FxColumnPainter

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

class FxColumnPainter : public QObject, public QGraphicsItem

{

	Q_OBJECT

	Q_INTERFACES(QGraphicsItem)

	FxSchematicColumnNode *m_parent;

	double m_width, m_height;

	QString m_name;

	int m_type;

public:

	FxColumnPainter(FxSchematicColumnNode *parent, double width, double height, const QString &name);

	virtual ~FxColumnPainter();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	void setName(const QString &name) { m_name = name; }

	QLinearGradient getGradientByLevelType(int type);

public slots:

	void onIconGenerated();

protected:

	void contextMenuEvent(QGraphicsSceneContextMenuEvent *cme);

};

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

//    FxPalettePainter

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

class FxPalettePainter : public QGraphicsItem, public QObject

{

	FxSchematicPaletteNode *m_parent;

	double m_width, m_height;

	QString m_name;

public:

	FxPalettePainter(FxSchematicPaletteNode *parent, double width, double height, const QString &name);

	~FxPalettePainter();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	void setName(const QString &name) { m_name = name; }

protected:

	void contextMenuEvent(QGraphicsSceneContextMenuEvent *cme);

};

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

//    FxPainter

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

class FxPainter : public QObject, public QGraphicsItem

{

	Q_OBJECT

	Q_INTERFACES(QGraphicsItem)

	FxSchematicNode *m_parent;

	double m_width, m_height;

	QString m_name, m_label;

	eFxType m_type;

	//to obtain the fx icons for zoom out view of the schematic

	std::string m_fxType;

	QLinearGradient getGradientByLevelType(eFxType);

	void paint_small(QPainter *painter);

public:

	FxPainter(FxSchematicNode *parent, double width, double height, const QString &name, eFxType type, std::string fxType);

	~FxPainter();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	void setName(const QString &name) { m_name = name; }

protected:

	void contextMenuEvent(QGraphicsSceneContextMenuEvent *cme);

};

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

//    FxXSheetPainter

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

class FxXSheetPainter : public QObject, public QGraphicsItem

{

	Q_OBJECT

	Q_INTERFACES(QGraphicsItem)

	double m_width, m_height;

	FxSchematicXSheetNode *m_parent;

public:

	FxXSheetPainter(FxSchematicXSheetNode *parent, double width, double height);

	~FxXSheetPainter();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

protected:

	void contextMenuEvent(QGraphicsSceneContextMenuEvent *cme);

};

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

//    FxOutputPainter

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

class FxOutputPainter : public QObject, public QGraphicsItem

{

	Q_OBJECT

	Q_INTERFACES(QGraphicsItem)

	double m_width, m_height;

	bool m_isActive;

	FxSchematicOutputNode *m_parent;

public:

	FxOutputPainter(FxSchematicOutputNode *parent, double width, double height);

	~FxOutputPainter();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

protected:

	void contextMenuEvent(QGraphicsSceneContextMenuEvent *cme);

};

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

//    FxSchematicLink

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

class FxSchematicLink : public SchematicLink

{

	Q_OBJECT

public:

	FxSchematicLink(QGraphicsItem *parent, QGraphicsScene *scene);

	~FxSchematicLink();

protected:

	void contextMenuEvent(QGraphicsSceneContextMenuEvent *cme);

};

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

//    FxSchematicPort

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

class FxSchematicPort : public SchematicPort

{

	TFx *m_ownerFx;

	FxSchematicPort *m_currentTargetPort;

	QList<schematiclink *=""> m_hiddenLinks;</schematiclink>

	QList<schematiclink *=""> m_ghostLinks;</schematiclink>

public:

	FxSchematicPort(FxSchematicDock *parent, int type);

	~FxSchematicPort();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	bool linkTo(SchematicPort *port, bool checkOnly = false);

	FxSchematicDock *getDock() const;

	SchematicLink *makeLink(SchematicPort *port);

protected:

	void contextMenuEvent(QGraphicsSceneContextMenuEvent *cme);

	void mouseMoveEvent(QGraphicsSceneMouseEvent *me);

	void mouseReleaseEvent(QGraphicsSceneMouseEvent *me);

	TFx *getOwnerFx() const;

private:

	void linkEffects(TFx *inputFx, TFx *fx, int inputId);

	SchematicPort *searchPort(const QPointF &scenePos);

	//!Handles hiding of existing link and showing of ghost links for snapping after creation link only for fx having

	//!dynamic ports.

	//!If \b secondIndex is -1 consider the last port in the groupedPorts of the node.

	void handleSnappedLinksOnDynamicPortFx(const std::vector<tfxport *=""> &groupedPorts, int targetIndex, int startIndex = -1);</tfxport>

	void resetSnappedLinksOnDynamicPortFx();

	void hideSnappedLinks();

	void showSnappedLinks();

};

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

//    FxSchematicDock

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

class FxSchematicDock : public QGraphicsItem, public QObject

{

	QString m_name;

	double m_width;

	FxSchematicPort *m_port;

public:

	FxSchematicDock(FxSchematicNode *parent, const QString &string, double width, eFxSchematicPortType type);

	~FxSchematicDock();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	FxSchematicNode *getNode();

	FxSchematicPort *getPort() { return m_port; }

};

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

//    FxSchematicNode

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

class FxSchematicNode : public SchematicNode

{

	Q_OBJECT

protected:

	enum eDropActionMode {

		eShift,

		eNone

	};

protected:

	QString m_name;  //!< Node's name (displayed on top, editable)

	TFxP m_fx;		 //!< The node's associated fx (could be a wrapper to the actual fx)

	TFxP m_actualFx; //!< The actual node's associated fx

	FxSchematicNode *m_linkedNode;

	QList<fxschematicdock *=""> m_inDocks;</fxschematicdock>

	FxSchematicDock *m_outDock;

	FxSchematicDock *m_linkDock;

	SchematicName *m_nameItem;

	eFxType m_type;

	bool m_isCurrentFxLinked;

	bool m_isLargeScaled;

protected:

	//! If the fx has dynamic port groups, ensures that each group always has at least one unlinked port

	//! that users can attach to, while keeping the number of unlinked ports to the minimum allowed by the

	//! group's specifics.

	virtual void checkDynamicInputPortSize() const;

	//! Adds a dynamic group port to the associated fx.

	void addDynamicInputPort(int groupIndex) const;

	//! Removes the port with specified name from the associated fx. Returns false (ie operation refused)

	//! if the specified port does not exists, is connected, or is not in a dynamic port group.

	bool removeDynamicInputPort(const std::string &name) const;

	//! Moves the port group links to the front ports.

	void shiftLinks() const;

	void updateOutputDockToolTips(const QString &name);

public:

	FxSchematicNode(FxSchematicScene *parent, TFx *fx, qreal width, qreal height, eFxType type);

	void setWidth(const qreal &width) { m_width = width; }

	void setHeight(const qreal &height) { m_height = height; }

	void setSchematicNodePos(const QPointF &pos) const;

	TFx *getFx() const { return m_fx.getPointer(); }

	bool isA(eFxType type) { return m_type == type; }

	int getInputPortCount() { return m_inDocks.size(); }

	int getInputDockId(FxSchematicDock *dock);

	FxSchematicPort *getInputPort(int i) { return m_inDocks[i] ? m_inDocks[i]->getPort() : 0; }

	FxSchematicPort *getOutputPort() { return m_outDock ? m_outDock->getPort() : 0; }

	FxSchematicPort *getLinkPort() { return m_linkDock ? m_linkDock->getPort() : 0; }

	bool isNameEditing() { return m_nameItem->isVisible(); }

	void onClicked();

	bool isCurrentFxLinked(SchematicNode *comingNode) { return m_isCurrentFxLinked; }

	void setIsCurrentFxLinked(bool value, FxSchematicNode *comingNode);

	void setPosition(const QPointF &newPos);

	void updatePortsPosition();

	virtual bool isOpened() { return true; }

	virtual bool isEnabled() const;

	virtual bool isCached() const;

	virtual void resize(bool maximizeNode) {}

	bool isLargeScaled() { return m_isLargeScaled; }

signals:

	void switchCurrentFx(TFx *fx);

	void currentColumnChanged(int index);

	void fxNodeDoubleClicked();

};

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

//    FxSchematicOutputNode

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

class FxSchematicOutputNode : public FxSchematicNode

{

	FxOutputPainter *m_outputPainter;

public:

	FxSchematicOutputNode(FxSchematicScene *scene, TOutputFx *fx);

	~FxSchematicOutputNode();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

protected:

	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *me);

};

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

//    FxSchematicXSheetNode

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

class FxSchematicXSheetNode : public FxSchematicNode

{

	FxXSheetPainter *m_xsheetPainter;

public:

	FxSchematicXSheetNode(FxSchematicScene *scene, TXsheetFx *fx);

	~FxSchematicXSheetNode();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

protected:

	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *me);

};

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

//    FxSchematicNormalFxNode

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

class FxSchematicNormalFxNode : public FxSchematicNode

{

	Q_OBJECT

	FxPainter *m_painter;

	SchematicToggle *m_renderToggle;

public:

	FxSchematicNormalFxNode(FxSchematicScene *scene, TFx *fx);

	~FxSchematicNormalFxNode();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	void resize(bool maximizeNode);

protected:

	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *me);

protected slots:

	void onNameChanged();

	void onRenderToggleClicked(bool);

};

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

//    FxSchematicZeraryNode

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

class FxSchematicZeraryNode : public FxSchematicNode

{

	Q_OBJECT

	FxPainter *m_painter;

	int m_columnIndex;

	SchematicToggle *m_renderToggle, *m_cameraStandToggle;

public:

	FxSchematicZeraryNode(FxSchematicScene *scene, TZeraryColumnFx *fx);

	~FxSchematicZeraryNode();

	QRectF boundingRect() const;

	virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	void resize(bool maximizeNode);

	int getColumnIndex() { return m_columnIndex; }

	bool isCached() const;

protected:

	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *me);

protected slots:

	void onRenderToggleClicked(bool);

	void onNameChanged();

};

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

//    FxSchematicColumnNode

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

class FxSchematicColumnNode : public FxSchematicNode

{

	Q_OBJECT

	SchematicThumbnailToggle *m_resizeItem;

	SchematicToggle *m_renderToggle, *m_cameraStandToggle;

	FxColumnPainter *m_columnPainter;

	int m_columnIndex;

	bool m_isOpened;

public:

	FxSchematicColumnNode(FxSchematicScene *scene, TLevelColumnFx *fx);

	~FxSchematicColumnNode();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	QPixmap getPixmap();

	bool isOpened() { return m_isOpened; }

	void getLevelTypeAndName(int &, QString &);

	void resize(bool maximizeNode);

	int getColumnIndex() { return m_columnIndex; }

protected:

	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *me);

private:

	void renameObject(const TStageObjectId &id, std::string name);

protected slots:

	void onRenderToggleClicked(bool);

	void onCameraStandToggleClicked(int);

	void onChangedSize(bool);

	void onNameChanged();

};

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

//    FxSchematicPaletteNode

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

class FxSchematicPaletteNode : public FxSchematicNode

{

	Q_OBJECT

	SchematicToggle *m_renderToggle;

	FxPalettePainter *m_palettePainter;

	int m_columnIndex;

public:

	FxSchematicPaletteNode(FxSchematicScene *scene, TPaletteColumnFx *fx);

	~FxSchematicPaletteNode();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	QPixmap getPixmap();

	bool isOpened() { return false; }

	int getColumnIndex() { return m_columnIndex; }

	QString getPaletteName();

protected:

	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *me);

protected slots:

	void onRenderToggleClicked(bool);

	void onNameChanged();

private:

	void renameObject(const TStageObjectId &id, std::string name);

};

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

//    FxGroupNode

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

class FxGroupNode : public FxSchematicNode

{

	Q_OBJECT

	QList<tfxp> m_groupedFxs;</tfxp>

	QList<tfxp> m_roots;</tfxp>

	int m_groupId;

	FxPainter *m_painter;

	SchematicToggle *m_renderToggle;

	bool m_isOpened;

public:

	FxGroupNode(FxSchematicScene *scene, const QList<tfxp> &groupedFx, const QList<tfxp> &roots,</tfxp></tfxp>

				int groupId, const std::wstring &groupName);

	~FxGroupNode();

	QRectF boundingRect() const;

	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);

	FxSchematicPort *getOutputPort() const { return m_outDock ? m_outDock->getPort() : 0; }

	bool isNameEditing() const { return m_nameItem->isVisible(); }

	QList<tfxp> getRootFxs() const { return m_roots; }</tfxp>

	int getRootCount() { return m_roots.size(); }

	int getFxCount() const { return m_groupedFxs.size(); }

	TFx *getFx(int i) const { return 0 <= i && i < m_groupedFxs.size() ? m_groupedFxs[i].getPointer() : 0; }

	QList<tfxp> getGroupedFxs() const { return m_groupedFxs; }</tfxp>

	void updateFxsDagPosition(const TPointD &pos) const;

	bool isOpened() { return m_isOpened; }

	void resize(bool maximized);

	bool contains(TFxP fx);

	//returns the number of ports that take the group in input... it consider also the node xsheet

	int getOutputConnectionsCount() const;

	bool isEnabled() const;

	virtual bool isCached() const;

protected:

	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *me);

	QPointF computePos() const;

protected slots:

	void onNameChanged();

	void onRenderToggleClicked(bool);

};

#endif // FXSCHEMATICNODE_H