// TnzCore includes

#include "tsystem.h"

#include "tstream.h"

#include "tfilepath_io.h"

#include "tfunctorinvoker.h"

// TnzBase includes

#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 final : public FunctionTreeModel::ParamWrapper,

                                public FunctionTreeModel::ChannelGroup {

public:

  ParamChannelGroup(TParam *param, const std::wstring &fxId,

                    std::string ¶mName);

  void refresh() override;

  void *getInternalPointer() const override;

};

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

class SkVDChannelGroup final : 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 override {

    return m_stageObjectGroup->getShortName();

  }

  QString getLongName() const override { return *m_vxName; }

  void *getInternalPointer() const override { 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 override;

};

}  // 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()) return true;</item>

  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()) return true;</item>

  return false;

}

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

bool FunctionTreeModel::ChannelGroup::isIgnored() const {

  // Same for the ignored ones, show warning icon if any of its children is.

  int c, childCount = getChildCount();

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

    if (static_cast<item *="">(getChild(c))->isIgnored()) return true;</item>

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

    bool ignored  = (animated) ? isIgnored() : false;

    if (active) {

      static QIcon folderAnimOpen(createQIcon("folder_anim_on", true));

      static QIcon folderAnimClose(createQIcon("folder_anim", true));

      static QIcon folderOpen(createQIcon("folder_on", true));

      static QIcon folderClose(createQIcon("folder", true));

      static QIcon ignoredOn(":Resources/paramignored_on.svg");

      return animated ? (isOpen() ? folderAnimOpen

                                  : (ignored ? ignoredOn : folderAnimClose))

                      : (isOpen() ? folderOpen : folderClose);

    } else {

      static QIcon folderAnimOpen(createQIcon("folder_anim_inactive_on", true));

      static QIcon folderAnimClose(createQIcon("folder_anim_inactive", true));

      static QIcon folderOpen(createQIcon("folder_inactive_on", true));

      static QIcon folderClose(createQIcon("folder_inactive", true));

      static QIcon ignoredOff(":Resources/paramignored_off.svg");

      return animated ? (isOpen() ? folderAnimOpen

                                  : (ignored ? ignoredOff : 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->getId().isTable())

                           ? FunctionTreeView::tr("Table").toStdString()

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

    }

    bool ignored = (isAnimated) ? isIgnored() : false;

    if (isOneChildActive) {

      static QIcon folderAnimOpen(createQIcon("folder_anim_on", true));

      static QIcon folderAnimClose(createQIcon("folder_anim", true));

      static QIcon folderOpen(createQIcon("folder_on", true));

      static QIcon folderClose(createQIcon("folder", true));

      static QIcon ignoredOn(":Resources/paramignored_on.svg");

      return isAnimated ? (isOpen() ? folderAnimOpen

                                    : (ignored ? ignoredOn : folderAnimClose))

                        : (isOpen() ? folderOpen : folderClose);

    } else {

      static QIcon folderAnimOpen(createQIcon("folder_anim_inactive_on", true));

      static QIcon folderAnimClose(createQIcon("folder_anim_inactive", true));

      static QIcon folderOpen(createQIcon("folder_inactive_on", true));

      static QIcon folderClose(createQIcon("folder_inactive", true));

      static QIcon ignoredOff(":Resources/paramignored_off.svg");

      return isAnimated ? (isOpen() ? folderAnimOpen

                                    : (ignored ? ignoredOff : 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->getViewer()->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 selection color

    // if this group refers to current vertex

    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

    if (PlasticVertexSelection *vxSel =

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

      if (TStageObject *obj = model->getCurrentStageObject())

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

              return view->getViewer()->getCurrentTextColor();

          }

    return view->getTextColor();

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

}

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

bool FunctionTreeModel::Channel::isIgnored() const {

  if (!isAnimated()) return false;

  TDoubleParam *dp = dynamic_cast<tdoubleparam *="">(m_param.getPointer());</tdoubleparam>

  if (!dp) return false;

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

  if (!view) return false;

  return view->getXsheetHandle()->getXsheet()->isReferenceManagementIgnored(dp);

}

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

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

  if (role == Qt::DecorationRole) {

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

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

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

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

    static QIcon paramIgnoredOn(":Resources/paramignored_on.svg");

    static QIcon paramIgnoredOff(":Resources/paramignored_off.svg");

    if (isIgnored()) return isActive() ? paramIgnoredOn : paramIgnoredOff;

    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->getViewer()->getCurrentTextColor()

                         : view->getTextColor();

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

    if (m_param->hasKeyframes()) {

      TDoubleParam *dp = dynamic_cast<tdoubleparam *="">(m_param.getPointer());</tdoubleparam>

      FunctionTreeView *view =

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

      if (dp && view &&

          view->getXsheetHandle()->getXsheet()->isReferenceManagementIgnored(

              dp))

        return tr(

            "Some key(s) in this parameter loses original reference in "

            "expression.\nManually changing any keyframe will clear the "

            "warning.");

    }

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

  } 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;

  if (m_param->hasUILabel())

    tmpName = QString::fromStdString(m_param->getUILabel());

  else

    tmpName = 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 == "Y")

      tmpName = "y";

    else if (tmpName == "X")

      tmpName = "x";

    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;

  }

  // expression for fx parameters

  // see txsheetexpr.cpp for generation of actual tokens

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

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

  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(tr("Stage")));

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

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

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

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

      }

    }

    if (xsh) {

      refreshStageObjects(xsh);

      refreshFxs(xsh);

    }