#include "toonzqt/fxsettings.h"

#include "toonzqt/gutil.h"

#include "toonzqt/keyframenavigator.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/fxhistogramrender.h"

#include "toonzqt/histogram.h"

#include "tmacrofx.h"

#include "tstream.h"

#include "tparamcontainer.h"

#include "tspectrumparam.h"

#include "tfxattributes.h"

#include "toutputproperties.h"

#include "pluginhost.h"

#include "tenv.h"

#include "tsystem.h"

#include "docklayout.h"

#include "toonz/tcamera.h"

#include "toonz/toonzfolders.h"

#include "toonz/tcolumnfx.h"

#include "toonz/tscenehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/scenefx.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/preferences.h"

#include "tw/stringtable.h"

#include <qvboxlayout></qvboxlayout>

#include <qtoolbar></qtoolbar>

#include <qicon></qicon>

#include <qaction></qaction>

#include <qstackedwidget></qstackedwidget>

#include <qlabel></qlabel>

#include <qmap></qmap>

#include <qpainter></qpainter>

#include <qcheckbox></qcheckbox>

#include <qpushbutton></qpushbutton>

#include <qdesktopservices></qdesktopservices>

#include <qurl></qurl>

using namespace DVGui;

namespace {

TFxP getCurrentFx(const TFxP ¤tFx, std::wstring actualId) {

  if (currentFx->getFxId() == actualId) return currentFx;

  int i;

  for (i = 0; i < currentFx->getInputPortCount(); i++) {

    TFxP fx = getCurrentFx(currentFx->getInputPort(i)->getFx(), actualId);

    if (fx.getPointer()) return fx;

  }

  return 0;

}

bool hasEmptyInputPort(const TFxP ¤tFx) {

  if (!currentFx.getPointer()) return true;

  if (currentFx->getInputPortCount() == 0) return false;

  return hasEmptyInputPort(currentFx->getInputPort(0)->getFx());

}

/*

TFxP cloneInputPort(const TFxP ¤tFx)

{

        int i;

  for (i=0; i

  {

                TFx *inputFx = sceneFx->getInputPort(i)->getFx();

                if(inputFx)

                {

                        if(TLevelColumnFx* affFx = dynamic_cast

>(inputFx))

                                currentFx->getInputPort(i)->setFx(inputFx);

                        else

                                currentFx->getInputPort(i)->setFx(cloneInputPort());

                }

                TFxPort *port = getInputPort(i);

                if (port->getFx())

                        fx->connect(getInputPortName(i),

cloneInputPort(port->getFx()));

}

void setLevelFxInputPort(const TFxP ¤tFx, const TFxP &sceneFx)

{

        for (int i=0; i<scenefx->getInputPortCount(); ++i)</scenefx->

        {

                TFx *inputFx = sceneFx->getInputPort(i)->getFx();

                if(inputFx)

                {

                        if(TLevelColumnFx* affFx = dynamic_cast

>(inputFx))

                                currentFx->getInputPort(i)->setFx(inputFx);

                        else

                                setLevelFxInputPort(currentFx->getInputPort(i)->getFx(),

inputFx);

                }

        }

}

*/

}  // namespace

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

// ParamViewer

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

ParamsPage::ParamsPage(QWidget *parent, ParamViewer *paramViewer)

    : QFrame(parent)

    , m_paramViewer(paramViewer)

    , m_horizontalLayout(NULL)

    , m_groupLayout(NULL) {

  m_fxHistogramRender = new FxHistogramRender();

  setFrameStyle(QFrame::StyledPanel);

  m_mainLayout = new QGridLayout(this);

  m_mainLayout->setMargin(12);

  m_mainLayout->setVerticalSpacing(10);

  m_mainLayout->setHorizontalSpacing(5);

  m_mainLayout->setColumnStretch(0, 0);

  m_mainLayout->setColumnStretch(1, 1);

  setLayout(m_mainLayout);

}

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

ParamsPage::~ParamsPage() {}

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

void ParamsPage::setPageField(TIStream &is, const TFxP &fx, bool isVertical) {

  // m_horizontalLayout dovrebbe essere stato inizializzato prima di entrare nel

  // metodo, per sicurezza verifico.

  if (isVertical == false && !m_horizontalLayout) {

    m_horizontalLayout = new QHBoxLayout();

    m_horizontalLayout->setMargin(0);

    m_horizontalLayout->setSpacing(5);

  }

  /*--

   * HBoxLayoutを挿入するとき、最初のパラメータ名はGridlayoutのColumn0に入れるため

   * --*/

  bool isFirstParamInRow = true;

  while (!is.matchEndTag()) {

    std::string tagName;

    if (!is.matchTag(tagName)) throw TException("expected tag");

    if (tagName == "control") {

      /*--- 設定ファイルからインタフェースの桁数を決める (PairSliderのみ実装。)

       * ---*/

      int decimals            = 0;

      std::string decimalsStr = is.getTagAttribute("decimals");

      if (decimalsStr != "") {

        decimals = QString::fromStdString(decimalsStr).toInt();

      }

      std::string name;

      is >> name;

      is.matchEndTag();

      /*-- Layout設定名とFxParameterの名前が一致するものを取得 --*/

      TParamP param = fx->getParams()->getParam(name);

      if (param) {

        std::string paramName = fx->getFxType() + "." + name;

        QString str =

            QString::fromStdWString(TStringTable::translate(paramName));

        ParamField *field = ParamField::create(this, str, param);

        if (field) {

          if (decimals) field->setPrecision(decimals);

          m_fields.push_back(field);

          /*-- hboxタグに挟まれているとき --*/

          if (isVertical == false) {

            assert(m_horizontalLayout);

            QLabel *label = new QLabel(str, this);

            label->setObjectName("FxSettingsLabel");

            if (isFirstParamInRow) {

              int currentRow = m_mainLayout->rowCount();

              m_mainLayout->addWidget(label, currentRow, 0,

                                      Qt::AlignRight | Qt::AlignVCenter);

              isFirstParamInRow = false;

            } else

              m_horizontalLayout->addWidget(label, 0,

                                            Qt::AlignRight | Qt::AlignVCenter);

            m_horizontalLayout->addWidget(field);

            m_horizontalLayout->addSpacing(10);

          } else {

            int currentRow = m_mainLayout->rowCount();

            QLabel *label  = new QLabel(str, this);

            label->setObjectName("FxSettingsLabel");

            m_mainLayout->addWidget(label, currentRow, 0,

                                    Qt::AlignRight | Qt::AlignVCenter);

            m_mainLayout->addWidget(field, currentRow, 1);

          }

          connect(field, SIGNAL(currentParamChanged()), m_paramViewer,

                  SIGNAL(currentFxParamChanged()));

          connect(field, SIGNAL(actualParamChanged()), m_paramViewer,

                  SIGNAL(actualFxParamChanged()));

          connect(field, SIGNAL(paramKeyToggle()), m_paramViewer,

                  SIGNAL(paramKeyChanged()));

        }

      }

    } else if (tagName == "label") {

      std::string name;

      is >> name;

      is.matchEndTag();

      QString str;

      if (isVertical == false) {

        assert(m_horizontalLayout);

        m_horizontalLayout->addWidget(new QLabel(str.fromStdString(name)));

      } else {

        int currentRow = m_mainLayout->rowCount();

        m_mainLayout->addWidget(new QLabel(str.fromStdString(name)), currentRow,

                                0, 1, 2);

      }

    } else if (tagName == "separator") {

      // <separator> o <separator label="xxx"></separator></separator>

      std::string label = is.getTagAttribute("label");

      QString str;

      Separator *sep = new Separator(str.fromStdString(label), this);

      int currentRow = m_mainLayout->rowCount();

      m_mainLayout->addWidget(sep, currentRow, 0, 1, 2);

      m_mainLayout->setRowStretch(currentRow, 0);

    } else if (tagName == "histogram") {

      Histogram *histogram = new Histogram();

      m_fxHistogramRender->setHistograms(histogram->getHistograms());

      if (isVertical == false) {

        assert(m_horizontalLayout);

        m_horizontalLayout->addWidget(histogram);

      } else {

        int currentRow = m_mainLayout->rowCount();

        m_mainLayout->addWidget(histogram, currentRow, 0, 1, 2);

      }

    } else if (tagName == "test") {

      // <test></test>

      // box->add(new WidgetBox(new TestSeparator(page)));

    } else if (tagName == "hbox") {

      int currentRow     = m_mainLayout->rowCount();

      m_horizontalLayout = new QHBoxLayout();

      m_horizontalLayout->setMargin(0);

      m_horizontalLayout->setSpacing(5);

      setPageField(is, fx, false);

      m_mainLayout->addLayout(m_horizontalLayout, currentRow, 1, 1, 2);

    } else if (tagName == "vbox") {

      int shrink                   = 0;

      std::string shrinkStr        = is.getTagAttribute("shrink");

      std::string modeSensitiveStr = is.getTagAttribute("modeSensitive");

      if (shrinkStr != "" || modeSensitiveStr != "") {

        QWidget *tmpWidget;

        if (shrinkStr != "") {

          tmpWidget           = new QWidget(this);

          shrink              = QString::fromStdString(shrinkStr).toInt();

          std::string label   = is.getTagAttribute("label");

          QCheckBox *checkBox = new QCheckBox(this);

          QHBoxLayout *sepLay = new QHBoxLayout();

          sepLay->setMargin(0);

          sepLay->setSpacing(5);

          sepLay->addWidget(checkBox, 0);

          sepLay->addWidget(new Separator(QString::fromStdString(label), this),

                            1);

          int currentRow = m_mainLayout->rowCount();

          m_mainLayout->addLayout(sepLay, currentRow, 0, 1, 2);

          m_mainLayout->setRowStretch(currentRow, 0);

          //--- signal-slot connection

          connect(checkBox, SIGNAL(toggled(bool)), tmpWidget,

                  SLOT(setVisible(bool)));

          checkBox->setChecked(shrink == 1);

          tmpWidget->setVisible(shrink == 1);

        } else {  // modeSensitiveStr != ""

          QList<int> modes;</int>

          QStringList modeListStr =

              QString::fromStdString(is.getTagAttribute("mode"))

                  .split(',', QString::SkipEmptyParts);

          for (QString modeNum : modeListStr) modes.push_back(modeNum.toInt());

          // find the mode combobox

          ModeChangerParamField *modeChanger = nullptr;

          for (int r = 0; r < m_mainLayout->rowCount(); r++) {

            QLayoutItem *li = m_mainLayout->itemAtPosition(r, 1);

            if (!li || !li->widget()) continue;

            ModeChangerParamField *field =

                dynamic_cast<modechangerparamfield *="">(li->widget());</modechangerparamfield>

            if (!field ||

                field->getParamName().toStdString() != modeSensitiveStr)

              continue;

            modeChanger = field;

            break;

          }

          assert(modeChanger);

          tmpWidget = new ModeSensitiveBox(this, modeChanger, modes);

        }

        int currentRow           = m_mainLayout->rowCount();

        QGridLayout *keepMainLay = m_mainLayout;

        // temporary switch the layout

        m_mainLayout = new QGridLayout();

        m_mainLayout->setMargin(0);

        m_mainLayout->setVerticalSpacing(10);

        m_mainLayout->setHorizontalSpacing(5);

        m_mainLayout->setColumnStretch(0, 0);

        m_mainLayout->setColumnStretch(1, 1);

        setPageField(is, fx, true);

        tmpWidget->setLayout(m_mainLayout);

        // turn back the layout

        m_mainLayout = keepMainLay;

        m_mainLayout->addWidget(tmpWidget, currentRow, 0, 1, 2);

      } else

        setPageField(is, fx, true);

    }

    /*-- PixelParamFieldが２つあるとき、一方のRGB値を他方にコピーするボタン --*/

    else if (tagName == "rgb_link_button") {

      /*-- リンクさせたいパラメータを２つ得る --*/

      std::string name1, name2;

      is >> name1;

      is >> name2;

      is.matchEndTag();

      /*-- 既に作ってあるGUIを探索し、対応する２つを得て格納 --*/

      PixelParamField *ppf1 = 0;

      PixelParamField *ppf2 = 0;

      for (int r = 0; r < m_mainLayout->rowCount(); r++) {

        QLayoutItem *li = m_mainLayout->itemAtPosition(r, 1);

        if (!li) continue;

        QWidget *w = li->widget();

        if (!w) continue;

        ParamField *pf = dynamic_cast<paramfield *="">(w);</paramfield>

        if (pf) {

          PixelParamField *ppf = dynamic_cast<pixelparamfield *="">(pf);</pixelparamfield>

          if (ppf) {

            if (ppf1 == 0 && ppf->getParamName().toStdString() == name1)

              ppf1 = ppf;

            if (ppf2 == 0 && ppf->getParamName().toStdString() == name2)

              ppf2 = ppf;

          }

        }

      }

      if (ppf1 == 0 || ppf2 == 0) continue;

      /*-- ボタンのラベルのため 翻訳する --*/

      std::string paramName1 = fx->getFxType() + "." + name1;

      std::string paramName2 = fx->getFxType() + "." + name2;

      QString str1 =

          QString::fromStdWString(TStringTable::translate(paramName1));

      QString str2 =

          QString::fromStdWString(TStringTable::translate(paramName2));

      RgbLinkButtons *linkBut =

          new RgbLinkButtons(str1, str2, this, ppf1, ppf2);

      int currentRow = m_mainLayout->rowCount();

      m_mainLayout->addWidget(linkBut, currentRow, 1,

                              Qt::AlignLeft | Qt::AlignVCenter);

    }

    /*-- チェックボックスによって他のインタフェースを表示/非表示させる ---*/

    else if (tagName == "visibleToggle") {

      BoolParamField *controller_bpf = 0;

      QList<qwidget *=""> on_items;</qwidget>

      QList<qwidget *=""> off_items;</qwidget>

      while (!is.matchEndTag()) {

        std::string tagName;

        if (!is.matchTag(tagName)) throw TException("expected tag");

        if (tagName ==

                "controller" || /*-- 表示をコントロールするチェックボックス --*/

            tagName == "on" || /*-- ONのとき表示されるインタフェース --*/

            tagName == "off") /*-- OFFのとき表示されるインタフェース --*/

        {

          std::string name;

          is >> name;

          is.matchEndTag();

          for (int r = 0; r < m_mainLayout->rowCount(); r++) {

            QLayoutItem *li = m_mainLayout->itemAtPosition(r, 1);

            if (!li) continue;

            QWidget *w = li->widget();

            if (!w) continue;

            ParamField *pf = dynamic_cast<paramfield *="">(w);</paramfield>

            if (pf) {

              if (pf->getParamName().toStdString() == name) {

                if (tagName == "controller")

                  controller_bpf = dynamic_cast<boolparamfield *="">(pf);</boolparamfield>

                else if (tagName == "on") {

                  on_items.push_back(w);

                  on_items.push_back(

                      m_mainLayout->itemAtPosition(r, 0)->widget());

                } else if (tagName == "off") {

                  off_items.push_back(w);

                  off_items.push_back(

                      m_mainLayout->itemAtPosition(r, 0)->widget());

                }

              }

            }

            /*-- 入れ子のLayoutも１段階探す --*/

            else {

              QGridLayout *gridLay = dynamic_cast<qgridlayout *="">(w->layout());</qgridlayout>

              if (!gridLay) continue;

              for (int r_s = 0; r_s < gridLay->rowCount(); r_s++) {

                QLayoutItem *li_s = gridLay->itemAtPosition(r_s, 1);

                if (!li_s) continue;

                ParamField *pf_s = dynamic_cast<paramfield *="">(li_s->widget());</paramfield>

                if (pf_s) {

                  if (pf_s->getParamName().toStdString() == name) {

                    if (tagName == "controller")

                      controller_bpf = dynamic_cast<boolparamfield *="">(pf_s);</boolparamfield>

                    else if (tagName == "on") {

                      on_items.push_back(pf_s);

                      on_items.push_back(

                          gridLay->itemAtPosition(r_s, 0)->widget());

                    } else if (tagName == "off") {

                      off_items.push_back(pf_s);

                      off_items.push_back(

                          gridLay->itemAtPosition(r_s, 0)->widget());

                    }

                  }

                }

              }

            }

          }

        } else

          throw TException("unexpected tag " + tagName);

      }

      /*-- 表示コントロールをconnect --*/

      if (controller_bpf) {

        /*-- ラベルとWidgetを両方表示/非表示 --*/

        for (int i = 0; i < on_items.size(); i++) {

          connect(controller_bpf, SIGNAL(toggled(bool)), on_items[i],

                  SLOT(setVisible(bool)));

          on_items[i]->hide();

        }

        for (int i = 0; i < off_items.size(); i++) {

          connect(controller_bpf, SIGNAL(toggled(bool)), off_items[i],

                  SLOT(setHidden(bool)));

          off_items[i]->show();

        }

      } else

        std::cout << "controller_bpf NOT found!" << std::endl;

    } else

      throw TException("unexpected tag " + tagName);

  }

  if (isVertical == false && m_horizontalLayout) {

    m_horizontalLayout->addStretch(1);

  }

}

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

void ParamsPage::setPageSpace() {

  if (m_fields.count() != 0) {

    QWidget *spaceWidget = new QWidget();

    int currentRow = m_mainLayout->rowCount();

    m_mainLayout->addWidget(spaceWidget, currentRow, 0, 1, 2);

    for (int i = 0; i < currentRow; i++) m_mainLayout->setRowStretch(i, 0);

    m_mainLayout->setRowStretch(currentRow, 1);

  }

}

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

void ParamsPage::beginGroup(const char *name) {

  m_groupLayout = new QGridLayout();

  QGroupBox *group = new QGroupBox(QString::fromUtf8(name), this);

  group->setLayout(m_groupLayout);

  m_mainLayout->addWidget(group, m_mainLayout->rowCount(), 0, 1, 2);

}

void ParamsPage::endGroup() { m_groupLayout = NULL; }

void ParamsPage::addWidget(QWidget *field, bool isVertical) {

  QLabel *label  = NULL;

  ParamField *pf = qobject_cast<paramfield *="">(field);</paramfield>

  if (pf) {

    label = new QLabel(pf->getUIName(), this);

    label->setObjectName("FxSettingsLabel");

    if (!pf->getDescription().isEmpty())

      label->setToolTip(pf->getDescription());

  }

  if (isVertical) {

    if (m_groupLayout) {

      int row = m_groupLayout->rowCount();

      if (label)

        m_groupLayout->addWidget(label, row, 0,

                                 Qt::AlignRight | Qt::AlignVCenter);

      m_groupLayout->addWidget(field, row, 1);

    } else {

      int row = m_mainLayout->rowCount();

      if (label)

        m_mainLayout->addWidget(label, row, 0,

                                Qt::AlignRight | Qt::AlignVCenter);

      m_mainLayout->addWidget(field, row, 1);

    }

  } else {

    if (!m_horizontalLayout) {

      m_horizontalLayout = new QHBoxLayout();

      m_horizontalLayout->setMargin(0);

      m_horizontalLayout->setSpacing(5);

    }

    m_horizontalLayout->addWidget(field);

  }

}

#define TOONZ_DEFINE_NEW_COMPONENT(NAME, MAKE)                                 \

  QWidget *ParamsPage::NAME(TFx *fx, const char *name) {                       \

    TParamP param = fx->getParams()->getParam(name);                           \

    if (!param) return NULL;                                                   \

    QString const paramName =                                                  \

        QString::fromStdString(fx->getFxType() + "." + name);                  \

    ParamField *field = MAKE(this, paramName, param);                          \

    if (!field) return NULL;                                                   \

    m_fields.push_back(field);                                                 \

    connect(field, SIGNAL(currentParamChanged()), m_paramViewer,               \

            SIGNAL(currentFxParamChanged()));                                  \

    connect(field, SIGNAL(actualParamChanged()), m_paramViewer,                \

            SIGNAL(actualFxParamChanged()));                                   \

    connect(field, SIGNAL(paramKeyToggle()), m_paramViewer,                    \

            SIGNAL(paramKeyChanged()));                                        \

    return field;                                                              \

  }

TOONZ_DEFINE_NEW_COMPONENT(newParamField, ParamField::create);

TOONZ_DEFINE_NEW_COMPONENT(newLineEdit, make_lineedit);

TOONZ_DEFINE_NEW_COMPONENT(newSlider, make_slider);

TOONZ_DEFINE_NEW_COMPONENT(newSpinBox, make_spinbox);

TOONZ_DEFINE_NEW_COMPONENT(newCheckBox, make_checkbox);

TOONZ_DEFINE_NEW_COMPONENT(newRadioButton, make_radiobutton);

TOONZ_DEFINE_NEW_COMPONENT(newComboBox, make_combobox);

#undef TOONZ_DEFINE_NEW_COMPONENT

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

void ParamsPage::setFx(const TFxP ¤tFx, const TFxP &actualFx, int frame) {

  assert(currentFx);

  assert(actualFx);

  for (int i = 0; i < (int)m_fields.size(); i++) {

    ParamField *field = m_fields[i];

    QString fieldName = field->getParamName();

    TFxP fx = getCurrentFx(currentFx, actualFx->getFxId());

    assert(fx.getPointer());

    TParamP currentParam =

        currentFx->getParams()->getParam(fieldName.toStdString());

    TParamP actualParam =

        actualFx->getParams()->getParam(fieldName.toStdString());

    assert(currentParam);

    assert(actualParam);

    field->setParam(currentParam, actualParam, frame);

  }

  if (actualFx->getInputPortCount() > 0)

    m_fxHistogramRender->computeHistogram(actualFx->getInputPort(0)->getFx(),

                                          frame);

}

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

void ParamsPage::setPointValue(int index, const TPointD &p) {

  if (0 <= index && index < (int)m_fields.size())

    m_fields[index]->setPointValue(p);

}

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

void ParamsPage::update(int frame) {

  int i;

  for (i = 0; i < (int)m_fields.size(); i++) {

    ParamField *field = m_fields[i];

    field->update(frame);

  }

}

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

namespace {

QSize getItemSize(QLayoutItem *item) {

  // layout case

  QHBoxLayout *hLay = dynamic_cast<qhboxlayout *="">(item->layout());</qhboxlayout>

  if (hLay) {

    int tmpWidth = 0, tmpHeight = 0;

    for (int c = 0; c < hLay->count(); c++) {

      QLayoutItem *subItem = hLay->itemAt(c);

      if (!subItem) continue;

      QSize subItemSize = getItemSize(subItem);

      tmpWidth += subItemSize.width();

      if (tmpHeight < subItemSize.height()) tmpHeight = subItemSize.height();

    }

    tmpWidth += (hLay->count() - 1) * 5;

    return QSize(tmpWidth, tmpHeight);

  }

  ParamField *pF = dynamic_cast<paramfield *="">(item->widget());</paramfield>

  if (pF) return pF->getPreferedSize();

  Separator *sep = dynamic_cast<separator *="">(item->widget());</separator>

  if (sep) return QSize(0, 16);

  Histogram *histo = dynamic_cast<histogram *="">(item->widget());</histogram>

  if (histo) return QSize(278, 162);

  RgbLinkButtons *linkBut = dynamic_cast<rgblinkbuttons *="">(item->widget());</rgblinkbuttons>

  if (linkBut) return QSize(0, 21);

  return QSize();

}

void updateMaximumPageSize(QGridLayout *layout, int &maxLabelWidth,

                           int &maxWidgetWidth, int &fieldsHeight) {

  /*-- Label側の横幅の最大値を得る --*/

  for (int r = 0; r < layout->rowCount(); r++) {

    /*-- アイテムが無ければ次の行へ --*/

    if (!layout->itemAtPosition(r, 0)) continue;

    /*-- ラベルの横幅を得て、最大値を更新していく --*/

    QLabel *label =

        dynamic_cast<qlabel *="">(layout->itemAtPosition(r, 0)->widget());</qlabel>

    QGroupBox *gBox =

        dynamic_cast<qgroupbox *="">(layout->itemAtPosition(r, 0)->widget());</qgroupbox>

    if (label) {

      int tmpWidth = label->fontMetrics().width(label->text());

      if (maxLabelWidth < tmpWidth) maxLabelWidth = tmpWidth;

    }

    /*-- PlugInFxのGroupパラメータのサイズ --*/

    else if (gBox) {

      QGridLayout *gridLay = dynamic_cast<qgridlayout *="">(gBox->layout());</qgridlayout>

      if (gridLay) {

        updateMaximumPageSize(gridLay, maxLabelWidth, maxWidgetWidth,

                              fieldsHeight);

        /*-- GroupBoxのマージン --*/

        maxLabelWidth += 10;

        maxWidgetWidth += 10;

        fieldsHeight += 20;

      }

    }

  }

  /*-- Widget側の最適な縦サイズおよび横幅の最大値を得る --*/

  QMap<int, int=""> heightsByMode;</int,>

  int maxModeHeight = 0;

  for (int r = 0; r < layout->rowCount(); r++) {

    /*-- Column1にある可能性のあるもの：ParamField, Histogram, Layout,

     * RgbLinkButtons --*/

    QLayoutItem *item = layout->itemAtPosition(r, 1);

    if (!item) continue;

    ModeSensitiveBox *box = dynamic_cast<modesensitivebox *="">(item->widget());</modesensitivebox>

    if (box) {

      // if (box->isHidden()) continue;

      QGridLayout *innerLay = dynamic_cast<qgridlayout *="">(box->layout());</qgridlayout>

      if (!innerLay) continue;

      int tmpHeight = 0;

      updateMaximumPageSize(innerLay, maxLabelWidth, maxWidgetWidth, tmpHeight);

      for (int mode : box->modes()) {

        heightsByMode[mode] += tmpHeight;

        maxModeHeight = std::max(maxModeHeight, heightsByMode[mode]);

      }

      // attempt to align the label column

      innerLay->setColumnMinimumWidth(0, maxLabelWidth);

      continue;

    }

    QSize itemSize = getItemSize(item);

    if (maxWidgetWidth < itemSize.width()) maxWidgetWidth = itemSize.width();

    fieldsHeight += itemSize.height();

  }

  if (maxModeHeight > 0) fieldsHeight += maxModeHeight;

  if (layout->rowCount() > 1) fieldsHeight += (layout->rowCount() - 1) * 10;

}

};  // namespace

QSize ParamsPage::getPreferredSize() {

  int maxLabelWidth  = 0;

  int maxWidgetWidth = 0;

  int fieldsHeight   = 0;

  updateMaximumPageSize(m_mainLayout, maxLabelWidth, maxWidgetWidth,

                        fieldsHeight);

  return QSize(maxLabelWidth + maxWidgetWidth +

                   m_mainLayout->horizontalSpacing() +

                   2 * m_mainLayout->margin(),

               fieldsHeight + 2 * m_mainLayout->margin() +

                   31 /* spacing for the swatch */);

}

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

// ParamsPageSet

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

#if QT_VERSION >= 0x050500

ParamsPageSet::ParamsPageSet(QWidget *parent, Qt::WindowFlags flags)

#else

ParamsPageSet::ParamsPageSet(QWidget *parent, Qt::WFlags flags)

#endif

    : QWidget(parent, flags)

    , m_preferredSize(0, 0)

    , m_helpFilePath("")

    , m_helpCommand("") {

  // TabBar

  m_tabBar = new TabBar(this);

  // This widget is used to set the background color of the tabBar

  // using the styleSheet and to draw the two lines on the bottom size.

  m_tabBarContainer = new TabBarContainter(this);

  m_pagesList       = new QStackedWidget(this);

  m_helpButton = new QPushButton(tr(""), this);

  m_helpButton->setIconSize(QSize(20, 20));

  m_helpButton->setIcon(createQIcon("help"));

  m_helpButton->setFixedWidth(28);

  m_helpButton->setToolTip(tr("View help page"));

  m_parent = dynamic_cast<paramviewer *="">(parent);</paramviewer>

  m_pageFxIndexTable.clear();

  m_tabBar->setDrawBase(false);

  m_tabBar->setObjectName("FxSettingsTabBar");

  m_helpButton->setFixedHeight(20);

  m_helpButton->setObjectName("FxSettingsHelpButton");

  m_helpButton->setFocusPolicy(Qt::NoFocus);

  //----layout

  QVBoxLayout *mainLayout = new QVBoxLayout();

  mainLayout->setMargin(0);

  mainLayout->setSpacing(0);

  {

    QHBoxLayout *hLayout = new QHBoxLayout();

    hLayout->setMargin(0);

    hLayout->addSpacing(0);

    {

      hLayout->addWidget(m_tabBar);

      hLayout->addStretch(1);

      hLayout->addWidget(m_helpButton);

    }

    m_tabBarContainer->setLayout(hLayout);

    mainLayout->addWidget(m_tabBarContainer);

    mainLayout->addWidget(m_pagesList);

    mainLayout->addWidget(new Separator("", this), 0);

  }

  setLayout(mainLayout);

  connect(m_tabBar, SIGNAL(currentChanged(int)), this, SLOT(setPage(int)));

  m_helpButton->hide();

}

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

ParamsPageSet::~ParamsPageSet() {}

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

void ParamsPageSet::setPage(int index) {

  if (m_tabBar->count() == 0 || m_pagesList->count() == 0) return;

  assert(index >= 0 && index < m_pagesList->count());

  m_pagesList->setCurrentIndex(index);

}

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

void ParamsPageSet::setFx(const TFxP ¤tFx, const TFxP &actualFx,

                          int frame) {

  TMacroFx *currentFxMacro = dynamic_cast<tmacrofx *="">(currentFx.getPointer());</tmacrofx>

  if (currentFxMacro) {

    TMacroFx *actualFxMacro = dynamic_cast<tmacrofx *="">(actualFx.getPointer());</tmacrofx>

    assert(actualFxMacro);

    const std::vector<tfxp> ¤tFxMacroFxs = currentFxMacro->getFxs();</tfxp>

    const std::vector<tfxp> &actualFxMacroFxs  = actualFxMacro->getFxs();</tfxp>

    assert(currentFxMacroFxs.size() == actualFxMacroFxs.size());

    for (int i = 0; i < m_pagesList->count(); i++) {

      ParamsPage *page = getParamsPage(i);

      if (!page || !m_pageFxIndexTable.contains(page)) continue;

      int index = m_pageFxIndexTable[page];

      page->setFx(currentFxMacroFxs[index], actualFxMacroFxs[index], frame);

    }

  } else {

    for (int i = 0; i < m_pagesList->count(); i++) {

      ParamsPage *page = getParamsPage(i);

      if (!page) continue;

      page->setFx(currentFx, actualFx, frame);

    }

  }

}

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

void ParamsPageSet::updatePage(int frame, bool onlyParam) {

  if (!m_pagesList) return;

  int i;

  for (i = 0; i < m_pagesList->count(); i++) {

    ParamsPage *page = getParamsPage(i);

    if (!page) continue;

    page->update(frame);

    if (!onlyParam) page->getFxHistogramRender()->invalidateFrame(frame);

  }

}

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

void ParamsPageSet::setScene(ToonzScene *scene) {

  if (!m_pagesList) return;

  int i;

  for (i = 0; i < m_pagesList->count(); i++) {

    ParamsPage *page = getParamsPage(i);

    if (!page) continue;

    page->getFxHistogramRender()->setScene(scene);

  }

}

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

void ParamsPageSet::setIsCameraViewMode(bool isCameraViewMode) {

  if (!m_pagesList) return;

  int i;

  for (i = 0; i < m_pagesList->count(); i++) {

    ParamsPage *page = getParamsPage(i);

    if (!page) continue;

    page->getFxHistogramRender()->setIsCameraViewMode(isCameraViewMode);

  }

}

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

ParamsPage *ParamsPageSet::createParamsPage() {

  return new ParamsPage(this, m_parent);

}

void ParamsPageSet::addParamsPage(ParamsPage *page, const char *name) {

  /*-- このFxで最大サイズのページに合わせてダイアログをリサイズ --*/

  QSize pagePreferredSize = page->getPreferredSize();

  m_preferredSize         = m_preferredSize.expandedTo(

      pagePreferredSize + QSize(m_tabBarContainer->height() + 2,

                                2)); /*-- 2は上下左右のマージン --*/

  QScrollArea *pane = new QScrollArea(this);

  pane->setWidgetResizable(true);

  pane->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

  pane->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);

  pane->setWidget(page);

  m_tabBar->addSimpleTab(QString::fromUtf8(name));

  m_pagesList->addWidget(pane);

}

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

void ParamsPageSet::createControls(const TFxP &fx, int index) {

  if (TMacroFx *macroFx = dynamic_cast<tmacrofx *="">(fx.getPointer())) {</tmacrofx>

    const std::vector<tfxp> &fxs = macroFx->getFxs();</tfxp>

    for (int i = 0; i < (int)fxs.size(); i++) createControls(fxs[i], i);

    return;

  }

  if (RasterFxPluginHost *plugin =

          dynamic_cast<rasterfxpluginhost *="">(fx.getPointer())) {</rasterfxpluginhost>

    plugin->build(this);

    std::string url = plugin->getUrl();

    if (!url.empty()) {

      connect(m_helpButton, SIGNAL(pressed()), this, SLOT(openHelpUrl()));

      m_helpButton->show();

      m_helpUrl = url;

    }

    return;

  }

  TFilePath fp = ToonzFolder::getProfileFolder() + "layouts" + "fxs" +

                 (fx->getFxType() + ".xml");

  TIStream is(fp);

  if (!is) return;

  if (fx->getParams()->getParamCount()) {

    try {

      std::string tagName;