// TnzCore includes

#include "tsystem.h"

#include "tstream.h"

#include "tfilepath_io.h"

#include "tfunctorinvoker.h"

// TnzBase incudes

#include "tunit.h"

#include "tparamcontainer.h"

#include "tparamset.h"

#include "tmacrofx.h"

#include "tparamchange.h"

// TnzExt includes

#include "ext/plasticskeleton.h"

// TnzLib includes

#include "toonz/tstageobjecttree.h"

#include "toonz/txsheet.h"

#include "toonz/txsheethandle.h"

#include "toonz/fxdag.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/tcolumnfx.h"

#include "toonz/tfxhandle.h"

#include "toonz/tobjecthandle.h"

// TnzQt includes

#include "toonzqt/functionviewer.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/gutil.h"

#include "toonzqt/plasticvertexselection.h"

#include "tw/stringtable.h"

// Qt includes

#include <qmenu></qmenu>

#include <qaction></qaction>

#include <qfiledialog></qfiledialog>

#include <qmouseevent></qmouseevent>

#include <qmetaobject></qmetaobject>

#include <qcolor></qcolor>

#include <qapplication> // for drag&drop</qapplication>

#include <qdrag></qdrag>

#include <qmimedata></qmimedata>

#include "toonzqt/functiontreeviewer.h"

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

//    ChannelGroup specialization  definition

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

namespace

{

class ParamChannelGroup : public FunctionTreeModel::ParamWrapper, public FunctionTreeModel::ChannelGroup

{

public:

	ParamChannelGroup(TParam *param, const std::wstring &fxId, std::string ¶mName);

	void refresh();

	void *getInternalPointer() const;

};

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

class StageObjectChannelGroup : public FunctionTreeModel::ChannelGroup

{

public:

	TStageObject *m_stageObject;					 //!< (not owned) Referenced stage object

	FunctionTreeModel::ChannelGroup *m_plasticGroup; //!< (not owned) Eventual plastic channels group

public:

	StageObjectChannelGroup(TStageObject *pegbar);

	~StageObjectChannelGroup();

	QString getShortName() const;

	QString getLongName() const;

	QString getIdName() const;

	void *getInternalPointer() const { return static_cast<void *="">(m_stageObject); }</void>

	TStageObject *getStageObject() const { return m_stageObject; }

	QVariant data(int role) const;

};

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

class SkVDChannelGroup : public FunctionTreeModel::ChannelGroup

{

public:

	StageObjectChannelGroup *m_stageObjectGroup; //!< Parent stage object group

	const QString *m_vxName;					 //!< The associated vertex name

public:

	SkVDChannelGroup(const QString *vxName, StageObjectChannelGroup *stageGroup)

		: ChannelGroup(*vxName), m_stageObjectGroup(stageGroup), m_vxName(vxName) {}

	QString getShortName() const { return m_stageObjectGroup->getShortName(); }

	QString getLongName() const { return *m_vxName; }

	void *getInternalPointer() const { return (void *)m_vxName; }

	static inline bool compareStr(const TreeModel::Item *item, const QString &str)

	{

		const QString &thisStr = static_cast<const *="" skvdchannelgroup="">(item)->getLongName();</const>

		return (QString::localeAwareCompare(thisStr, str) < 0);

	}

	QVariant data(int role) const;

};

} // namespace

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

//

// ChannelGroup

//

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

FunctionTreeModel::ChannelGroup::ChannelGroup(const QString &name)

	: m_name(name), m_showFilter(ShowAllChannels)

{

}

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

FunctionTreeModel::ChannelGroup::~ChannelGroup()

{

}

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

bool FunctionTreeModel::ChannelGroup::isActive() const

{

	// Analyze children. If one is active, this is active too.

	int c, childCount = getChildCount();

	for (c = 0; c != childCount; ++c)

		if (static_cast<item *="">(getChild(c))->isActive())</item>

			return true;

	return false;

}

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

bool FunctionTreeModel::ChannelGroup::isAnimated() const

{

	// Same for the animated feature, this is animate if any of its children is.

	int c, childCount = getChildCount();

	for (c = 0; c != childCount; ++c)

		if (static_cast<item *="">(getChild(c))->isAnimated())</item>

			return true;

	return false;

}

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

QVariant FunctionTreeModel::ChannelGroup::data(int role) const

{

	if (role == Qt::DisplayRole)

		return getLongName();

	else if (role == Qt::DecorationRole) {

		bool animated = isAnimated();

		bool active = isActive();

		if (active) {

			static QIcon folderAnimOpen(":Resources/folderanim_open.png");

			static QIcon folderAnimClose(":Resources/folderanim_close.png");

			static QIcon folderOpen(":Resources/folder_open.png");

			static QIcon folderClose(":Resources/folder_close.png");

			return animated ? isOpen() ? folderAnimOpen : folderAnimClose : isOpen() ? folderOpen : folderClose;

		} else {

			static QIcon folderAnimOpen(":Resources/folderanim_open_off.png");

			static QIcon folderAnimClose(":Resources/folderanim_close_off.png");

			static QIcon folderOpen(":Resources/folder_open_off.png");

			static QIcon folderClose(":Resources/folder_close_off.png");

			return animated ? isOpen() ? folderAnimOpen : folderAnimClose : isOpen() ? folderOpen : folderClose;

		}

	} else

		return Item::data(role);

}

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

//! \todo     This is \a not recursive - I guess it should be...?

void FunctionTreeModel::ChannelGroup::applyShowFilter()

{

	int i, itemCount = getChildCount();

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

		FunctionTreeModel::Channel *channel = dynamic_cast<functiontreemodel::channel *="">(getChild(i));</functiontreemodel::channel>

		/*--- ChannelGroupの内部も同じフィルタで更新する ---*/

		if (!channel) {

			FunctionTreeModel::ChannelGroup *channelGroup =

				dynamic_cast<functiontreemodel::channelgroup *="">(getChild(i));</functiontreemodel::channelgroup>

			if (!channelGroup)

				continue;

			channelGroup->setShowFilter(m_showFilter);

			continue;

		}

		bool showItem =

			(m_showFilter == ShowAllChannels) || channel->getParam()->hasKeyframes();

		QModelIndex modelIndex = createIndex();

		getModel()->setRowHidden(i, modelIndex, !showItem);

		if (!showItem)

			channel->setIsActive(false);

	}

}

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

void FunctionTreeModel::ChannelGroup::setShowFilter(ShowFilter showFilter)

{

	m_showFilter = showFilter;

	applyShowFilter();

}

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

QString FunctionTreeModel::ChannelGroup::getIdName() const

{

	QString tmpName = QString(m_name);

	tmpName.remove(QChar(' '), Qt::CaseInsensitive);

	tmpName = tmpName.toLower();

	FunctionTreeModel::ChannelGroup *parentGroup =

		dynamic_cast<functiontreemodel::channelgroup *="">(getParent());</functiontreemodel::channelgroup>

	if (parentGroup) {

		return parentGroup->getIdName() + QString(".") + tmpName;

	}

	return tmpName;

}

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

void FunctionTreeModel::ChannelGroup::setChildrenAllActive(bool active)

{

	for (int i = 0; i < getChildCount(); i++) {

		//for Channel

		FunctionTreeModel::Channel *channel = dynamic_cast<functiontreemodel::channel *="">(getChild(i));</functiontreemodel::channel>

		if (channel) {

			channel->setIsActive(active);

			continue;

		}

		//for ChannelGroup

		else {

			FunctionTreeModel::ChannelGroup *channelGroup = dynamic_cast<functiontreemodel::channelgroup *="">(getChild(i));</functiontreemodel::channelgroup>

			if (channelGroup) {

				channelGroup->setChildrenAllActive(active);

				continue;

			}

		}

	}

}

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

//

// StageObjectChannelGroup

//

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

StageObjectChannelGroup::StageObjectChannelGroup(TStageObject *stageObject)

	: m_stageObject(stageObject), m_plasticGroup()

{

	m_stageObject->addRef();

}

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

StageObjectChannelGroup::~StageObjectChannelGroup()

{

	m_stageObject->release();

}

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

QVariant StageObjectChannelGroup::data(int role) const

{

	if (role == Qt::DisplayRole) {

		std::string name = m_stageObject->getName();

		std::string id = m_stageObject->getId().toString();

		return (name == id) ? QString::fromStdString(name) : QString::fromStdString(id + " (" + name + ")");

	} else if (role == Qt::ForegroundRole) {

		FunctionTreeModel *model = dynamic_cast<functiontreemodel *="">(getModel());</functiontreemodel>

		if (!model)

#if QT_VERSION >= 0x050000

			return QColor(Qt::black);

#else

			return Qt::black;

#endif

		FunctionTreeView *view = dynamic_cast<functiontreeview *="">(model->getView());</functiontreeview>

		if (!view || !model->getCurrentStageObject())

#if QT_VERSION >= 0x050000

			return QColor(Qt::black);

#else

			return Qt::black;

#endif

		TStageObjectId currentId = model->getCurrentStageObject()->getId();

		return m_stageObject->getId() == currentId ? view->getCurrentTextColor() : view->getTextColor();

	} else

		return ChannelGroup::data(role);

}

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

QString StageObjectChannelGroup::getShortName() const

{

	return QString::fromStdString(m_stageObject->getName());

}

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

QString StageObjectChannelGroup::getLongName() const

{

	return QString::fromStdString(m_stageObject->getFullName());

}

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

QString StageObjectChannelGroup::getIdName() const

{

	return QString::fromStdString(m_stageObject->getId().toString()).toLower();

}

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

//

// FxChannelGroup

//

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

FxChannelGroup::FxChannelGroup(TFx *fx)

	: m_fx(fx)

{

	if (m_fx)

		m_fx->addRef();

}

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

FxChannelGroup::~FxChannelGroup()

{

	if (m_fx)

		m_fx->release();

	m_fx = 0;

}

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

QString FxChannelGroup::getShortName() const

{

	return QString::fromStdWString(m_fx->getFxId());

}

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

QString FxChannelGroup::getLongName() const

{

	return QString::fromStdWString(m_fx->getFxId());

}

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

QVariant FxChannelGroup::data(int role) const

{

	if (role == Qt::DecorationRole) {

		bool isAnimated = false;

		TParamContainer *paramContainer = m_fx->getParams();

		int i;

		for (i = 0; i < paramContainer->getParamCount(); i++) {

			if (!paramContainer->getParam(i)->hasKeyframes())

				continue;

			isAnimated = true;

			break;

		}

		bool isOneChildActive = false;

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

			FunctionTreeModel::Channel *channel = dynamic_cast<functiontreemodel::channel *="">(getChild(i));</functiontreemodel::channel>

			if (!channel || !channel->isActive())

				continue;

			isOneChildActive = true;

			break;

		}

		if (isOneChildActive) {

			static QIcon folderAnimOpen(":Resources/folderanim_open.png");

			static QIcon folderAnimClose(":Resources/folderanim_close.png");

			static QIcon folderOpen(":Resources/folder_open.png");

			static QIcon folderClose(":Resources/folder_close.png");

			return isAnimated ? isOpen() ? folderAnimOpen : folderAnimClose : isOpen() ? folderOpen : folderClose;

		} else {

			static QIcon folderAnimOpen(":Resources/folderanim_open_off.png");

			static QIcon folderAnimClose(":Resources/folderanim_close_off.png");

			static QIcon folderOpen(":Resources/folder_open_off.png");

			static QIcon folderClose(":Resources/folder_close_off.png");

			return isAnimated ? isOpen() ? folderAnimOpen : folderAnimClose : isOpen() ? folderOpen : folderClose;

		}

	} else if (role == Qt::DisplayRole) {

		std::wstring name = m_fx->getName();

		std::wstring id = m_fx->getFxId();

		if (name == id)

			return QString::fromStdWString(name);

		else

			return QString::fromStdWString(id + L" (" + name + L")");

	} else if (role == Qt::ForegroundRole) {

		FunctionTreeModel *model = dynamic_cast<functiontreemodel *="">(getModel());</functiontreemodel>

		if (!model)

#if QT_VERSION >= 0x050000

			return QColor(Qt::black);

#else

			return Qt::black;

#endif

		FunctionTreeView *view = dynamic_cast<functiontreeview *="">(model->getView());</functiontreeview>

		if (!view)

#if QT_VERSION >= 0x050000

			return QColor(Qt::black);

#else

			return Qt::black;

#endif

		TFx *currentFx = model->getCurrentFx();

		return m_fx == currentFx ? view->getCurrentTextColor() : view->getTextColor();

	} else

		return Item::data(role);

}

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

QString FxChannelGroup::getIdName() const

{

	return QString::fromStdWString(m_fx->getFxId()).toLower();

}

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

void FxChannelGroup::refresh()

{

	TMacroFx *macroFx = dynamic_cast<tmacrofx *="">(m_fx);</tmacrofx>

	int i, childrenCount = getChildCount();

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

		FunctionTreeModel::ParamWrapper *wrap =

			dynamic_cast<functiontreemodel::paramwrapper *="">(getChild(i));</functiontreemodel::paramwrapper>

		assert(wrap);

		TParam *param = 0;

		{

			TParamContainer *paramContainer = 0;

			if (macroFx) {

				const std::wstring &fxId = wrap->getFxId();

				TFx *subFx = macroFx->getFxById(fxId);

				if (!subFx)

					continue;

				paramContainer = subFx->getParams();

			} else

				paramContainer = m_fx->getParams();

			param = paramContainer->getParam(wrap->getParam()->getName());

		}

		assert(param);

		wrap->setParam(param);

		ParamChannelGroup *paramGroup = dynamic_cast<paramchannelgroup *="">(wrap);</paramchannelgroup>

		if (paramGroup)

			paramGroup->refresh();

	}

}

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

//

// ParamChannelGroup

//

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

ParamChannelGroup::ParamChannelGroup(TParam *param, const std::wstring &fxId, std::string ¶mName)

	: ParamWrapper(param, fxId), ChannelGroup(param->hasUILabel() ? QString::fromStdString(param->getUILabel()) : QString::fromStdWString(TStringTable::translate(paramName)))

{

}

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

void *ParamChannelGroup::getInternalPointer() const

{

	return this->m_param.getPointer();

}

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

void ParamChannelGroup::refresh()

{

	TParamSet *paramSet = dynamic_cast<tparamset *="">(m_param.getPointer());</tparamset>

	if (!paramSet)

		return;

	int c, childrenCount = getChildCount();

	for (c = 0; c < childrenCount; ++c) {

		FunctionTreeModel::ParamWrapper *wrap =

			dynamic_cast<functiontreemodel::paramwrapper *="">(getChild(c));</functiontreemodel::paramwrapper>

		assert(wrap);

		TParamP currentParam = wrap->getParam();

		assert(currentParam);

		int p = paramSet->getParamIdx(wrap->getParam()->getName());

		assert(p < paramSet->getParamCount());

		TParamP param = paramSet->getParam(p);

		wrap->setParam(param);

	}

}

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

//

// SkVDChannelGroup

//

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

QVariant SkVDChannelGroup::data(int role) const

{

	if (role == Qt::ForegroundRole) {

		// Check whether current selection is a PlasticVertex one - in case, paint it red

		// if this group refers to current vertex

		if (PlasticVertexSelection *vxSel = dynamic_cast<plasticvertexselection *="">(TSelection::getCurrent()))</plasticvertexselection>

			if (TStageObject *obj = static_cast<functiontreemodel *="">(getModel())->getCurrentStageObject())</functiontreemodel>

				if (obj == m_stageObjectGroup->m_stageObject)

					if (const SkDP &sd = obj->getPlasticSkeletonDeformation()) {

						int vIdx = *vxSel;

						if (vIdx >= 0 && sd->skeleton(vxSel->skeletonId())->vertex(vIdx).name() == getLongName())

#if QT_VERSION >= 0x050000

							return QColor(Qt::red);

#else

							return Qt::red;

#endif

					}

#if QT_VERSION >= 0x050000

		return QColor(Qt::black);

#else

		return Qt::black;

#endif

	} else

		return ChannelGroup::data(role);

}

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

//

// Channel

//

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

FunctionTreeModel::Channel::Channel(FunctionTreeModel *model, TDoubleParam *param,

									std::string paramNamePref, std::wstring fxId)

	: ParamWrapper(param, fxId), m_model(model), m_group(0), m_isActive(false), m_paramNamePref(paramNamePref)

{

}

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

FunctionTreeModel::Channel::~Channel()

{

	m_model->onChannelDestroyed(this);

	if (m_isActive)

		getParam()->removeObserver(this);

}

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

void *FunctionTreeModel::Channel::getInternalPointer() const

{

	return this->m_param.getPointer();

}

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

bool FunctionTreeModel::Channel::isAnimated() const

{

	return m_param->hasKeyframes();

}

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

QVariant FunctionTreeModel::Channel::data(int role) const

{

	if (role == Qt::DecorationRole) {

		static QIcon paramAnimOn(":Resources/paramanim_on.png");

		static QIcon paramAnimOff(":Resources/paramanim_off.png");

		static QIcon paramOn(":Resources/param_on.png");

		static QIcon paramOff(":Resources/param_off.png");

		return m_param->hasKeyframes() ? isActive() ? paramAnimOn : paramAnimOff : isActive() ? paramOn : paramOff;

	} else if (role == Qt::DisplayRole) {

		if (m_param->hasUILabel()) {

			return QString::fromStdString(m_param->getUILabel());

		}

		std::string name = m_paramNamePref + m_param->getName();

		std::wstring translatedName = TStringTable::translate(name);

		if (m_fxId.size() > 0)

			return QString::fromStdWString(translatedName + L" (" + m_fxId + L")");

		return QString::fromStdWString(translatedName);

	} else if (role == Qt::ForegroundRole) {

		//130221 iwasawa

		FunctionTreeView *view = dynamic_cast<functiontreeview *="">(m_model->m_view);</functiontreeview>

		if (!view)

#if QT_VERSION >= 0x050000

			return QColor(Qt::black);

#else

			return Qt::black;

#endif

		return (isCurrent()) ? view->getCurrentTextColor() : view->getTextColor();

	} else

		return TreeModel::Item::data(role);

}

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

QString FunctionTreeModel::Channel::getShortName() const

{

	if (m_param->hasUILabel()) {

		return QString::fromStdString(m_param->getUILabel());

	}

	std::string name = m_paramNamePref + m_param->getName();

	std::wstring translatedName = TStringTable::translate(name);

	return QString::fromStdWString(translatedName);

}

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

QString FunctionTreeModel::Channel::getLongName() const

{

	QString name = getShortName();

	if (getChannelGroup())

		name = getChannelGroup()->getLongName() + " " + name;

	return name;

}

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

void FunctionTreeModel::Channel::setParam(const TParamP ¶m)

{

	if (param.getPointer() == m_param.getPointer())

		return;

	TParamP oldParam = m_param;

	m_param = param;

	if (m_isActive) {

		oldParam->removeObserver(this);

		param->addObserver(this);

	}

}

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

/*! in order to show the expression name in the tooltip

*/

QString FunctionTreeModel::Channel::getExprRefName() const

{

	QString tmpName =

		QString(QString::fromStdWString(

			TStringTable::translate(m_paramNamePref + m_param->getName())));

	/*--- stage objectパラメータの場合、TableにあわせてtmpNameを代表的なExpression名にする---*/

	StageObjectChannelGroup *stageGroup =

		dynamic_cast<stageobjectchannelgroup *="">(m_group);</stageobjectchannelgroup>

	if (stageGroup) {

		if (tmpName == "N/S")

			tmpName = "ns";

		else if (tmpName == "E/W")

			tmpName = "ew";

		else if (tmpName == "Z")

			tmpName = "z";

		else if (tmpName == "Rotation")

			tmpName = "rot";

		else if (tmpName == "Scale H")

			tmpName = "sx";

		else if (tmpName == "Scale V")

			tmpName = "sy";

		else if (tmpName == "Shear H")

			tmpName = "shx";

		else if (tmpName == "Shear V")

			tmpName = "shy";

		else if (tmpName == "posPath")

			tmpName = "path";

		else if (tmpName == "Scale")

			tmpName = "sc";

		else

			tmpName = tmpName.toLower();

		return stageGroup->getIdName() + QString(".") + tmpName;

	}

	/*--- Fxパラメータの場合 ---*/

	tmpName.remove(QChar(' '), Qt::CaseInsensitive);

	tmpName.remove(QChar('/'));

	tmpName = tmpName.toLower();

	FunctionTreeModel::ChannelGroup *parentGroup =

		dynamic_cast<functiontreemodel::channelgroup *="">(getParent());</functiontreemodel::channelgroup>

	if (parentGroup) {

		return QString("fx.") + parentGroup->getIdName() + QString(".") + tmpName;

	} else

		return "";

}

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

void FunctionTreeModel::Channel::setIsActive(bool active)

{

	if (active == m_isActive)

		return;

	m_isActive = active;

	m_model->refreshActiveChannels();

	if (m_isActive) {

		getParam()->addObserver(this);

		/*--- これが最初にVisibleにしたChannelの場合 ---*/

		if (!m_model->m_currentChannel) {

			setIsCurrent(true);

			m_model->emitCurveSelected(getParam());

		}

	} else {

		getParam()->removeObserver(this);

		if (isCurrent()) {

			setIsCurrent(false);

			m_model->emitCurveSelected(0);

		}

	}

	m_model->emitDataChanged(this);

}

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

bool FunctionTreeModel::Channel::isCurrent() const

{

	return m_model->m_currentChannel == this;

}

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

void FunctionTreeModel::Channel::setIsCurrent(bool current)

{

	Channel *oldCurrent = m_model->m_currentChannel;

	if (current) {

		// this channel must become the current

		if (oldCurrent == this)

			return; // already it is: nothing to do

		m_model->m_currentChannel = this;

		//change the current fx if the FxChannelGroup is clicked

		FxChannelGroup *fxGroup = dynamic_cast<fxchannelgroup *="">(m_group);</fxchannelgroup>

		if (fxGroup && m_model->getFxHandle()) {

			m_model->getFxHandle()->setFx(fxGroup->getFx());

		}

		//or, change the current object if the stageObjectChannelGroup is clicked

		else {

			StageObjectChannelGroup *stageObjectGroup = dynamic_cast<stageobjectchannelgroup *="">(m_group);</stageobjectchannelgroup>

			if (stageObjectGroup && m_model->getObjectHandle()) {

				m_model->getObjectHandle()->setObjectId(stageObjectGroup->getStageObject()->getId());

			}

		}

		// the current channel must be active

		if (!m_isActive) {

			m_isActive = true;

			m_model->refreshActiveChannels();

			getParam()->addObserver(this);

		}

		// refresh the old current (if !=0) and the new one

		if (oldCurrent)

			m_model->emitDataChanged(oldCurrent);

		m_model->emitDataChanged(this);

		m_model->emitCurveSelected(getParam());

		//scroll the column to ensure visible the current channel

		m_model->emitCurrentChannelChanged(this);

	} else {

		// this channel is not the current anymore

		if (oldCurrent != this)

			return; // it was not: nothing to do

		m_model->m_currentChannel = 0;

		// refresh the channel

		m_model->emitDataChanged(this);

	}

}

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

bool FunctionTreeModel::Channel::isHidden() const

{

	return getChannelGroup()->getShowFilter() == ChannelGroup::ShowAnimatedChannels &&

		   !getParam()->hasKeyframes();

}

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

void FunctionTreeModel::Channel::onChange(const TParamChange &ch)

{

	m_model->onChange(ch);

}

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

//

// FunctionTreeModel

//

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

FunctionTreeModel::FunctionTreeModel(FunctionTreeView *parent)

	: TreeModel(parent), m_currentChannel(0), m_stageObjects(0), m_fxs(0), m_currentStageObject(0), m_currentFx(0), m_paramsChanged(false)

{

}

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

FunctionTreeModel::~FunctionTreeModel()

{

	// I must delete items here (not in TreeModel::~TreeModel()).

	// Channel::~Channel() refers to the model, which should be alive.

	setRootItem(0);

	if (m_currentFx)

		m_currentFx->release();

}

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

void FunctionTreeModel::refreshData(TXsheet *xsh)

{

	m_activeChannels.clear();

	Channel *currentChannel = m_currentChannel;

	beginRefresh();

	{

		if (!getRootItem()) {

			setRootItem(new ChannelGroup("Root"));

			if (xsh) {

				getRootItem()->appendChild(m_stageObjects = new ChannelGroup("Stage"));

				getRootItem()->appendChild(m_fxs = new ChannelGroup("FX"));

				assert(getRootItem()->getChildCount() == 2);

				assert(getRootItem()->getChild(0) == m_stageObjects);

				assert(getRootItem()->getChild(1) == m_fxs);

			}

		}

		if (xsh) {

			refreshStageObjects(xsh);

			refreshFxs(xsh);

		}

		refreshActiveChannels();

	}

	endRefresh();

	if (m_currentChannel != currentChannel)

		emit curveSelected(0);

}

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

void FunctionTreeModel::refreshStageObjects(TXsheet *xsh)

{

	static const int channelIds[TStageObject::T_ChannelCount] = {

		TStageObject::T_X,

		TStageObject::T_Y,

		TStageObject::T_Z,

		TStageObject::T_SO,