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

}

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

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

      return animated ? isOpen() ? folderAnimOpen : 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));

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

    }

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

      return isAnimated ? isOpen() ? folderAnimOpen : 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));

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

}

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

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

    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

    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;

  }

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

    }

    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,     TStageObject::T_Path,   TStageObject::T_Angle,

      TStageObject::T_ScaleX, TStageObject::T_ScaleY, TStageObject::T_Scale,

      TStageObject::T_ShearX, TStageObject::T_ShearY};  // Explicitly ordered

                                                        // channels

  // Retrieve all (not-empty) root stage objects, and add them in the tree model

  QList<treemodel::item *=""> newItems;</treemodel::item>

  TStageObjectTree *ptree = xsh->getStageObjectTree();

  int i, iCount = ptree->getStageObjectCount();

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

    TStageObject *pegbar = ptree->getStageObject(i);

    TStageObjectId id    = pegbar->getId();

    if (id.isColumn() && xsh->isColumnEmpty(id.getIndex())) continue;

    newItems.push_back(new StageObjectChannelGroup(pegbar));

  }

  /*--- newItemsの中で、これまでのChildrenに無いものだけ

  m_stageObjectsの子に追加。既に有るものはnewChildrenから除外---*/

  m_stageObjects->setChildren(newItems);

  // Add channels to the NEW stage entries (see the above call to setChildren())

  iCount = newItems.size();

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

    StageObjectChannelGroup *pegbarItem =

        dynamic_cast<stageobjectchannelgroup *="">(newItems[i]);</stageobjectchannelgroup>

    TStageObject *stageObject = pegbarItem->getStageObject();

    // Add the standard stage object channels

    int j, jCount = TStageObject::T_ChannelCount;

    // making each channel of pegbar

    for (j = 0; j < jCount; ++j) {

      TDoubleParam *param =

          stageObject->getParam((TStageObject::Channel)channelIds[j]);

      Channel *channel = new Channel(this, param);

      pegbarItem->appendChild(channel);

      channel->setChannelGroup(pegbarItem);

    }

    pegbarItem->applyShowFilter();

  }