#include "levelsettingspopup.h"

// Tnz6 includes

#include "menubarcommandids.h"

#include "tapp.h"

#include "flipbook.h"

#include "fileviewerpopup.h"

#include "castselection.h"

#include "fileselection.h"

#include "columnselection.h"

#include "levelcommand.h"

// TnzQt includes

#include "toonzqt/menubarcommand.h"

#include "toonzqt/gutil.h"

#include "toonzqt/infoviewer.h"

#include "toonzqt/filefield.h"

#include "toonzqt/doublefield.h"

#include "toonzqt/intfield.h"

#include "toonzqt/checkbox.h"

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/icongenerator.h"

#include "toonzqt/fxselection.h"

// TnzLib includes

#include "toonz/tscenehandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/toonzscene.h"

#include "toonz/txshleveltypes.h"

#include "toonz/levelproperties.h"

#include "toonz/tcamera.h"

#include "toonz/levelset.h"

#include "toonz/tpalettehandle.h"

#include "toonz/preferences.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/palettecontroller.h"

#include "toonz/txshcell.h"

#include "toonz/txsheet.h"

#include "toonz/childstack.h"

#include "toonz/tcolumnfx.h"

#include "toonz/tframehandle.h"

// TnzCore includes

#include "tconvert.h"

#include "tsystem.h"

#include "tfiletype.h"

#include "tlevel.h"

#include "tstream.h"

#include "tundo.h"

// Qt includes

#include <qhboxlayout></qhboxlayout>

#include <qcombobox></qcombobox>

#include <qlabel></qlabel>

#include <qpushbutton></qpushbutton>

#include <qmainwindow></qmainwindow>

#include <qgroupbox></qgroupbox>

using namespace DVGui;

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

namespace {

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

QString dpiToString(const TPointD &dpi) {

  if (dpi.x == 0.0 || dpi.y == 0.0)

    return QString("none");

  else if (dpi.x < 0.0 || dpi.y < 0.0)

    return LevelSettingsPopup::tr("[Various]");

  else if (areAlmostEqual(dpi.x, dpi.y, 0.01))

    return QString::number(dpi.x);

  else

    return QString::number(dpi.x) + ", " + QString::number(dpi.y);

}

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

TPointD getCurrentCameraDpi() {

  TCamera *camera =

      TApp::instance()->getCurrentScene()->getScene()->getCurrentCamera();

  TDimensionD size = camera->getSize();

  TDimension res   = camera->getRes();

  return TPointD(res.lx / size.lx, res.ly / size.ly);

}

void uniteValue(QString &oldValue, QString &newValue, bool isFirst) {

  if (isFirst)

    oldValue = newValue;

  else if (oldValue != newValue &&

           oldValue != LevelSettingsPopup::tr("[Various]"))

    oldValue = LevelSettingsPopup::tr("[Various]");

}

void uniteValue(int &oldValue, int &newValue, bool isFirst) {

  if (isFirst)

    oldValue = newValue;

  else if (oldValue != -1 && oldValue != newValue)

    oldValue = -1;

}

void uniteValue(TPointD &oldValue, TPointD &newValue, bool isFirst) {

  if (isFirst)

    oldValue = newValue;

  else if (oldValue != TPointD(-1, -1) && oldValue != newValue)

    oldValue = TPointD(-1, -1);

}

void uniteValue(Qt::CheckState &oldValue, Qt::CheckState &newValue,

                bool isFirst) {

  if (isFirst)

    oldValue = newValue;

  else if (oldValue != Qt::PartiallyChecked && oldValue != newValue)

    oldValue = Qt::PartiallyChecked;

}

void uniteValue(double &oldValue, double &newValue, bool isFirst) {

  if (isFirst)

    oldValue = newValue;

  else if (oldValue != -1.0 && oldValue != newValue)

    oldValue = -1.0;

}

class LevelSettingsUndo final : public TUndo {

public:

  enum Type {

    Name,

    Path,

    ScanPath,

    DpiType,

    Dpi,

    DoPremulti,

    WhiteTransp,

    Softness,

    Subsampling,

    LevelType,

    ColorSpaceGamma

  };

private:

  TXshLevelP m_xl;

  const Type m_type;

  const QVariant m_before;

  const QVariant m_after;

  void setName(const QString name) const {

    TLevelSet *levelSet =

        TApp::instance()->getCurrentScene()->getScene()->getLevelSet();

    levelSet->renameLevel(m_xl.getPointer(), name.toStdWString());

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

    TApp::instance()->getCurrentScene()->notifyCastChange();

  }

  void setPath(const TFilePath path) const {

    TXshSoundLevelP sdl = m_xl->getSoundLevel();

    if (sdl) {

      sdl->setPath(path);

      sdl->loadSoundTrack();

      TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

      TApp::instance()->getCurrentXsheet()->notifyXsheetSoundChanged();

      return;

    }

    TXshSimpleLevelP sl  = m_xl->getSimpleLevel();

    TXshPaletteLevelP pl = m_xl->getPaletteLevel();

    if (!sl && !pl) return;

    if (sl) {

      sl->setPath(path);

      TApp::instance()

          ->getPaletteController()

          ->getCurrentLevelPalette()

          ->setPalette(sl->getPalette());

      sl->invalidateFrames();

      std::vector<tframeid> frames;</tframeid>

      sl->getFids(frames);

      for (auto const &fid : frames) {

        IconGenerator::instance()->invalidate(sl.getPointer(), fid);

      }

    } else if (pl) {

      pl->setPath(path);

      TApp::instance()

          ->getPaletteController()

          ->getCurrentLevelPalette()

          ->setPalette(pl->getPalette());

      pl->load();

    }

    TApp::instance()->getCurrentLevel()->notifyLevelChange();

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

  }

  void setScanPath(const TFilePath path) const {

    TXshSimpleLevelP sl = m_xl->getSimpleLevel();

    if (!sl || sl->getType() != TZP_XSHLEVEL) return;

    sl->setScannedPath(path);

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

  }

  void setDpiType(LevelProperties::DpiPolicy policy) const {

    TXshSimpleLevelP sl = m_xl->getSimpleLevel();

    if (!sl || sl->getType() == PLI_XSHLEVEL) return;

    sl->getProperties()->setDpiPolicy(policy);

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()->getCurrentLevel()->notifyLevelChange();

  }

  void setDpi(TPointD dpi) const {

    TXshSimpleLevelP sl = m_xl->getSimpleLevel();

    if (!sl || sl->getType() == PLI_XSHLEVEL) return;

    sl->getProperties()->setDpi(dpi);

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()->getCurrentLevel()->notifyLevelChange();

  }

  void setSubsampling(int subsampling) const {

    TXshSimpleLevelP sl = m_xl->getSimpleLevel();

    if (!sl || sl->getType() == PLI_XSHLEVEL) return;

    sl->getProperties()->setSubsampling(subsampling);

    sl->invalidateFrames();

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()

        ->getCurrentXsheet()

        ->getXsheet()

        ->getStageObjectTree()

        ->invalidateAll();

    TApp::instance()->getCurrentLevel()->notifyLevelChange();

  }

  void setDoPremulti(bool on) const {

    TXshSimpleLevelP sl = m_xl->getSimpleLevel();

    if (!sl || sl->getType() == PLI_XSHLEVEL) return;

    sl->getProperties()->setDoPremultiply(on);

    TApp::instance()->getCurrentLevel()->notifyLevelChange();

  }

  void setSoftness(int softness) const {

    TXshSimpleLevelP sl = m_xl->getSimpleLevel();

    if (!sl || sl->getType() == PLI_XSHLEVEL) return;

    sl->getProperties()->setDoAntialias(softness);

    TApp::instance()->getCurrentLevel()->notifyLevelChange();

  }

  void setWhiteTransp(bool on) const {

    TXshSimpleLevelP sl = m_xl->getSimpleLevel();

    if (!sl || sl->getType() == PLI_XSHLEVEL) return;

    sl->getProperties()->setWhiteTransp(on);

    TApp::instance()->getCurrentLevel()->notifyLevelChange();

  }

  void setColorSpaceGamma(double gamma) const {

    TXshSimpleLevelP sl = m_xl->getSimpleLevel();

    if (!sl || sl->getType() != OVL_XSHLEVEL) return;

    sl->getProperties()->setColorSpaceGamma(gamma);

    sl->invalidateFrames();

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()

        ->getCurrentXsheet()

        ->getXsheet()

        ->getStageObjectTree()

        ->invalidateAll();

    TApp::instance()->getCurrentLevel()->notifyLevelChange();

  }

  void setValue(const QVariant value) const {

    switch (m_type) {

    case Name:

      setName(value.toString());

      break;

    case Path:

      setPath(TFilePath(value.toString()));

      break;

    case ScanPath:

      setScanPath(TFilePath(value.toString()));

      break;

    case DpiType:

      setDpiType(LevelProperties::DpiPolicy(value.toInt()));

      break;

    case Dpi: {

      QPointF dpi = value.toPointF();

      setDpi(TPointD(dpi.x(), dpi.y()));

      break;

    }

    case Subsampling:

      setSubsampling(value.toInt());

      break;

    case DoPremulti:

      setDoPremulti(value.toBool());

      break;

    case Softness:

      setSoftness(value.toInt());

      break;

    case WhiteTransp:

      setWhiteTransp(value.toBool());

      break;

    case ColorSpaceGamma:

      setColorSpaceGamma(value.toDouble());

      break;

    default:

      break;

    }

    // This signal is for updating the level settings

    TApp::instance()->getCurrentScene()->notifySceneChanged();

  }

public:

  LevelSettingsUndo(TXshLevel *xl, Type type, const QVariant before,

                    const QVariant after)

      : m_xl(xl), m_type(type), m_before(before), m_after(after) {}

  void undo() const override { setValue(m_before); }

  void redo() const override { setValue(m_after); }

  int getSize() const override { return sizeof *this; }

  QString getHistoryString() override {

    return QObject::tr("Edit Level Settings : %1")

        .arg(QString::fromStdWString(m_xl->getName()));

  }

};

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

}  // anonymous namespace

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

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

/*! \class LevelSettingsPopup

   \brief The LevelSettingsPopup class provides a dialog to show

   and change current level settings.

   Inherits \b Dialog.

*/

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

LevelSettingsPopup::LevelSettingsPopup()

    : Dialog(TApp::instance()->getMainWindow(), false, false, "LevelSettings")

    , m_whiteTransp(0)

    , m_scanPathFld(0) {

  setWindowTitle(tr("Level Settings"));

  m_nameFld             = new LineEdit();

  m_pathFld             = new FileField();  // Path

  m_scanPathFld         = new FileField();  // ScanPath

  QLabel *scanPathLabel = new QLabel(tr("Scan Path:"), this);

  m_typeLabel           = new QLabel();  // Level Type

  // Type

  m_dpiTypeOm = new QComboBox();

  // DPI

  QLabel *dpiLabel = new QLabel(tr("DPI:"));

  m_dpiFld         = new DoubleLineEdit();

  m_squarePixCB    = new CheckBox(tr("Forced Squared Pixel"));

  QLabel *widthLabel  = new QLabel(tr("Width:"));

  m_widthFld          = new MeasuredDoubleLineEdit();

  QLabel *heightLabel = new QLabel(tr("Height:"));

  m_heightFld         = new MeasuredDoubleLineEdit();

  // Use Camera Dpi

  m_useCameraDpiBtn = new QPushButton(tr("Use Camera DPI"));

  m_cameraDpiLabel       = new QLabel(tr(""));

  m_imageDpiLabel        = new QLabel(tr(""));

  m_imageResLabel        = new QLabel(tr(""));

  QLabel *cameraDpiTitle = new QLabel(tr("Camera DPI:"));

  QLabel *imageDpiTitle  = new QLabel(tr("Image DPI:"));

  QLabel *imageResTitle  = new QLabel(tr("Resolution:"));

  // subsampling

  m_subsamplingLabel = new QLabel(tr("Subsampling:"));

  m_subsamplingFld   = new DVGui::IntLineEdit(this, 1, 1);

  m_doPremultiply = new CheckBox(tr("Premultiply"), this);

  m_whiteTransp = new CheckBox(tr("White As Transparent"), this);

  m_doAntialias       = new CheckBox(tr("Add Antialiasing"), this);

  m_softnessLabel     = new QLabel(tr("Antialias Softness:"), this);

  m_antialiasSoftness = new DVGui::IntLineEdit(0, 10, 0, 100);

  m_colorSpaceGammaLabel = new QLabel(tr("Color Space Gamma:"));

  m_colorSpaceGammaFld   = new DoubleLineEdit();

  m_colorSpaceGammaFld->setRange(0.1, 10.);

  //----

  m_pathFld->setFileMode(QFileDialog::AnyFile);

  m_scanPathFld->setFileMode(QFileDialog::AnyFile);

  m_dpiTypeOm->addItem(tr("Image DPI"), "Image DPI");

  m_dpiTypeOm->addItem(tr("Custom DPI"), "Custom DPI");

  m_squarePixCB->setCheckState(Qt::Checked);

  m_widthFld->setMeasure("camera.lx");

  m_heightFld->setMeasure("camera.ly");

  if (Preferences::instance()->getCameraUnits() == "pixel") {

    m_widthFld->setDecimals(0);

    m_heightFld->setDecimals(0);

  }

  m_doPremultiply->setTristate();

  m_doPremultiply->setCheckState(Qt::Unchecked);

  m_doAntialias->setTristate();

  m_doAntialias->setCheckState(Qt::Unchecked);

  m_antialiasSoftness->setEnabled(false);

  m_whiteTransp->setTristate();

  m_whiteTransp->setCheckState(Qt::Unchecked);

  // register activation flags

  m_activateFlags[m_nameFld]     = AllTypes;

  m_activateFlags[m_pathFld]     = SimpleLevel | Palette | Sound;

  m_activateFlags[m_scanPathFld] = ToonzRaster;

  m_activateFlags[scanPathLabel] = ToonzRaster | MultiSelection;

  // m_activateFlags[m_typeLabel]   = AllTypes | MultiSelection;

  unsigned int dpiWidgetsFlag  = HasDPILevel | HideOnPixelMode | MultiSelection;

  m_activateFlags[m_dpiTypeOm] = dpiWidgetsFlag;

  m_activateFlags[dpiLabel]    = dpiWidgetsFlag;

  m_activateFlags[m_dpiFld]    = dpiWidgetsFlag;

  m_activateFlags[m_squarePixCB] = dpiWidgetsFlag;

  unsigned int rasterWidgetsFlag     = ToonzRaster | Raster | MultiSelection;

  m_activateFlags[widthLabel]        = rasterWidgetsFlag;

  m_activateFlags[m_widthFld]        = rasterWidgetsFlag;

  m_activateFlags[heightLabel]       = rasterWidgetsFlag;

  m_activateFlags[m_heightFld]       = rasterWidgetsFlag;

  m_activateFlags[m_useCameraDpiBtn] = dpiWidgetsFlag;

  m_activateFlags[m_cameraDpiLabel] =

      AllTypes | HideOnPixelMode | MultiSelection;

  m_activateFlags[m_imageDpiLabel] = dpiWidgetsFlag;

  m_activateFlags[m_imageResLabel] = dpiWidgetsFlag;

  m_activateFlags[cameraDpiTitle] = AllTypes | HideOnPixelMode | MultiSelection;

  m_activateFlags[imageDpiTitle]  = dpiWidgetsFlag;

  m_activateFlags[imageResTitle]  = dpiWidgetsFlag;

  m_activateFlags[m_doPremultiply]     = Raster | MultiSelection;

  m_activateFlags[m_whiteTransp]       = Raster | MultiSelection;

  m_activateFlags[m_doAntialias]       = rasterWidgetsFlag;

  m_activateFlags[m_softnessLabel]     = rasterWidgetsFlag;

  m_activateFlags[m_antialiasSoftness] = rasterWidgetsFlag;

  m_activateFlags[m_subsamplingLabel]  = rasterWidgetsFlag;

  m_activateFlags[m_subsamplingFld]    = rasterWidgetsFlag;

  unsigned int linearFlag                 = LinearRaster | MultiSelection;

  m_activateFlags[m_colorSpaceGammaLabel] = linearFlag;

  m_activateFlags[m_colorSpaceGammaFld]   = linearFlag;

  //----layout

  m_topLayout->setMargin(5);

  m_topLayout->setSpacing(5);

  {

    //--Name&Path

    QGroupBox *nameBox      = new QGroupBox(tr("Name && Path"), this);

    QGridLayout *nameLayout = new QGridLayout();

    nameLayout->setMargin(5);

    nameLayout->setSpacing(5);

    {

      nameLayout->addWidget(new QLabel(tr("Name:"), this), 0, 0,

                            Qt::AlignRight | Qt::AlignVCenter);

      nameLayout->addWidget(m_nameFld, 0, 1);

      nameLayout->addWidget(new QLabel(tr("Path:"), this), 1, 0,

                            Qt::AlignRight | Qt::AlignVCenter);

      nameLayout->addWidget(m_pathFld, 1, 1);

      nameLayout->addWidget(scanPathLabel, 2, 0,

                            Qt::AlignRight | Qt::AlignVCenter);

      nameLayout->addWidget(m_scanPathFld, 2, 1);

      nameLayout->addWidget(m_typeLabel, 3, 1);

    }

    nameLayout->setColumnStretch(0, 0);

    nameLayout->setColumnStretch(1, 1);

    nameBox->setLayout(nameLayout);

    m_topLayout->addWidget(nameBox);

    //----DPI & Resolution

    QGroupBox *dpiBox;

    if (Preferences::instance()->getUnits() == "pixel")

      dpiBox = new QGroupBox(tr("Resolution"), this);

    else

      dpiBox = new QGroupBox(tr("DPI && Resolution"), this);

    QGridLayout *dpiLayout = new QGridLayout();

    dpiLayout->setMargin(5);

    dpiLayout->setSpacing(5);

    {

      dpiLayout->addWidget(m_dpiTypeOm, 0, 1, 1, 3);

      dpiLayout->addWidget(dpiLabel, 1, 0, Qt::AlignRight | Qt::AlignVCenter);

      dpiLayout->addWidget(m_dpiFld, 1, 1);

      dpiLayout->addWidget(m_squarePixCB, 1, 2, 1, 2,

                           Qt::AlignRight | Qt::AlignVCenter);

      dpiLayout->addWidget(widthLabel, 2, 0, Qt::AlignRight | Qt::AlignVCenter);

      dpiLayout->addWidget(m_widthFld, 2, 1);

      dpiLayout->addWidget(heightLabel, 2, 2,

                           Qt::AlignRight | Qt::AlignVCenter);

      dpiLayout->addWidget(m_heightFld, 2, 3);

      dpiLayout->addWidget(m_useCameraDpiBtn, 3, 1, 1, 3);

      dpiLayout->addWidget(cameraDpiTitle, 4, 0,

                           Qt::AlignRight | Qt::AlignVCenter);

      dpiLayout->addWidget(m_cameraDpiLabel, 4, 1, 1, 3);

      dpiLayout->addWidget(imageDpiTitle, 5, 0,

                           Qt::AlignRight | Qt::AlignVCenter);

      dpiLayout->addWidget(m_imageDpiLabel, 5, 1, 1, 3);

      dpiLayout->addWidget(imageResTitle, 6, 0,

                           Qt::AlignRight | Qt::AlignVCenter);

      dpiLayout->addWidget(m_imageResLabel, 6, 1, 1, 3);

    }

    dpiLayout->setColumnStretch(0, 0);

    dpiLayout->setColumnStretch(1, 1);

    dpiLayout->setColumnStretch(2, 0);

    dpiLayout->setColumnStretch(3, 1);

    dpiBox->setLayout(dpiLayout);

    m_topLayout->addWidget(dpiBox);

    m_topLayout->addWidget(m_doPremultiply);

    m_topLayout->addWidget(m_whiteTransp);

    m_topLayout->addWidget(m_doAntialias);

    //---subsampling

    QGridLayout *bottomLay = new QGridLayout();

    bottomLay->setMargin(3);

    bottomLay->setSpacing(3);

    {

      bottomLay->addWidget(m_softnessLabel, 0, 0);

      bottomLay->addWidget(m_antialiasSoftness, 0, 1);

      bottomLay->addWidget(m_subsamplingLabel, 1, 0);

      bottomLay->addWidget(m_subsamplingFld, 1, 1);

      bottomLay->addWidget(m_colorSpaceGammaLabel, 2, 0);

      bottomLay->addWidget(m_colorSpaceGammaFld, 2, 1);

    }

    bottomLay->setColumnStretch(0, 0);

    bottomLay->setColumnStretch(1, 0);

    bottomLay->setColumnStretch(2, 1);

    m_topLayout->addLayout(bottomLay);

    m_topLayout->addStretch();

  }

  //----signal/slot connections

  connect(m_nameFld, SIGNAL(editingFinished()), SLOT(onNameChanged()));

  connect(m_pathFld, SIGNAL(pathChanged()), SLOT(onPathChanged()));

  connect(m_dpiTypeOm, SIGNAL(activated(int)), SLOT(onDpiTypeChanged(int)));

  connect(m_dpiFld, SIGNAL(editingFinished()), SLOT(onDpiFieldChanged()));

  connect(m_squarePixCB, SIGNAL(stateChanged(int)),

          SLOT(onSquarePixelChanged(int)));

  connect(m_widthFld, SIGNAL(valueChanged()), SLOT(onWidthFieldChanged()));

  connect(m_heightFld, SIGNAL(valueChanged()), SLOT(onHeightFieldChanged()));

  connect(m_useCameraDpiBtn, SIGNAL(clicked()), SLOT(useCameraDpi()));

  connect(m_subsamplingFld, SIGNAL(editingFinished()),

          SLOT(onSubsamplingChanged()));

  /*--- ScanPathの入力に対応 ---*/

  connect(m_scanPathFld, SIGNAL(pathChanged()), SLOT(onScanPathChanged()));

  connect(m_doPremultiply, SIGNAL(clicked(bool)),

          SLOT(onDoPremultiplyClicked()));

  connect(m_doAntialias, SIGNAL(clicked(bool)), SLOT(onDoAntialiasClicked()));

  connect(m_antialiasSoftness, SIGNAL(editingFinished()),

          SLOT(onAntialiasSoftnessChanged()));

  connect(m_whiteTransp, SIGNAL(clicked(bool)), SLOT(onWhiteTranspClicked()));

  connect(m_colorSpaceGammaFld, SIGNAL(editingFinished()),

          SLOT(onColorSpaceGammaFieldChanged()));

  updateLevelSettings();

}

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

void LevelSettingsPopup::showEvent(QShowEvent *e) {

  bool ret =

      connect(TApp::instance()->getCurrentSelection(),

              SIGNAL(selectionSwitched(TSelection *, TSelection *)), this,

              SLOT(onSelectionSwitched(TSelection *, TSelection *)));

  ret = ret && connect(TApp::instance()->getCurrentSelection(),

                       SIGNAL(selectionChanged(TSelection *)),

                       SLOT(updateLevelSettings()));

  CastSelection *castSelection = dynamic_cast<castselection *="">(</castselection>

      TApp::instance()->getCurrentSelection()->getSelection());

  if (castSelection)

    ret = ret && connect(castSelection, SIGNAL(itemSelectionChanged()), this,

                         SLOT(onCastSelectionChanged()));

  // update level settings after cleanup by this connection

  ret = ret && connect(TApp::instance()->getCurrentScene(),

                       SIGNAL(sceneChanged()), SLOT(onSceneChanged()));

  ret = ret && connect(TApp::instance()->getCurrentScene(),

                       SIGNAL(preferenceChanged(const QString &)),

                       SLOT(onPreferenceChanged(const QString &)));

  assert(ret);

  updateLevelSettings();

  onPreferenceChanged("");

}

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

void LevelSettingsPopup::hideEvent(QHideEvent *e) {

  bool ret =

      disconnect(TApp::instance()->getCurrentSelection(),

                 SIGNAL(selectionSwitched(TSelection *, TSelection *)), this,

                 SLOT(onSelectionSwitched(TSelection *, TSelection *)));

  ret = ret && disconnect(TApp::instance()->getCurrentSelection(),

                          SIGNAL(selectionChanged(TSelection *)), this,

                          SLOT(updateLevelSettings()));

  CastSelection *castSelection = dynamic_cast<castselection *="">(</castselection>

      TApp::instance()->getCurrentSelection()->getSelection());

  if (castSelection)

    ret = ret && disconnect(castSelection, SIGNAL(itemSelectionChanged()), this,

                            SLOT(onCastSelectionChanged()));

  ret = ret && disconnect(TApp::instance()->getCurrentScene(),

                          SIGNAL(sceneChanged()), this, SLOT(onSceneChanged()));

  ret = ret && disconnect(TApp::instance()->getCurrentScene(),

                          SIGNAL(preferenceChanged(const QString &)), this,

                          SLOT(onPreferenceChanged(const QString &)));

  assert(ret);

  Dialog::hideEvent(e);

}

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

void LevelSettingsPopup::onSceneChanged() { updateLevelSettings(); }

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

void LevelSettingsPopup::onPreferenceChanged(const QString &propertyName) {

  if (!propertyName.isEmpty() && propertyName != "pixelsOnly") return;

  bool pixelsMode = Preferences::instance()->getBoolValue(pixelsOnly);

  QMap<qwidget *,="" int="" unsigned="">::iterator i = m_activateFlags.begin();</qwidget>

  while (i != m_activateFlags.end()) {

    if (i.value() & HideOnPixelMode) i.key()->setHidden(pixelsMode);

    ++i;

  }

  int decimals = (pixelsMode) ? 0 : 4;

  m_widthFld->setDecimals(decimals);

  m_heightFld->setDecimals(decimals);

  adjustSize();

}

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

void LevelSettingsPopup::onCastSelectionChanged() { updateLevelSettings(); }

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

void LevelSettingsPopup::onSelectionSwitched(TSelection *oldSelection,

                                             TSelection *newSelection) {

  CastSelection *castSelection = dynamic_cast<castselection *="">(newSelection);</castselection>

  if (!castSelection) {

    CastSelection *oldCastSelection =

        dynamic_cast<castselection *="">(oldSelection);</castselection>

    if (oldCastSelection)

      disconnect(oldCastSelection, SIGNAL(itemSelectionChanged()), this,

                 SLOT(onCastSelectionChanged()));

    return;

  }

  connect(castSelection, SIGNAL(itemSelectionChanged()), this,

          SLOT(onCastSelectionChanged()));

}

SelectedLevelType LevelSettingsPopup::getType(TXshLevelP level_p) {

  if (!level_p) return None;

  switch (level_p->getType()) {

  case TZP_XSHLEVEL:

    return ToonzRaster;

  case OVL_XSHLEVEL: {

    if (level_p->getPath().getType() == "exr")

      return LinearRaster;

    else

      return NonLinearRaster;

  }

  case MESH_XSHLEVEL:

    return Mesh;

  case PLI_XSHLEVEL:

    return ToonzVector;

  case PLT_XSHLEVEL:

    return Palette;

  case CHILD_XSHLEVEL:

    return SubXsheet;

  case SND_XSHLEVEL:

    return Sound;

  default:  // Other types are not supported

    return Others;

  }

}

LevelSettingsValues LevelSettingsPopup::getValues(TXshLevelP level) {

  LevelSettingsValues values;

  values.name = QString::fromStdWString(level->getName());

  TXshSimpleLevelP sl         = level->getSimpleLevel();

  TXshPaletteLevelP pl        = level->getPaletteLevel();

  TXshChildLevelP cl          = level->getChildLevel();

  TXshSoundLevelP sdl         = level->getSoundLevel();

  SelectedLevelType levelType = getType(level);

  // path

  if (sl) {

    values.path     = toQString(sl->getPath());

    values.scanPath = toQString(sl->getScannedPath());

  } else if (pl)

    values.path = toQString(pl->getPath());

  else if (sdl)

    values.path = toQString(sdl->getPath());

  // leveltype

  switch (levelType) {

  case ToonzRaster:

    values.typeStr = tr("Toonz Raster level");

    break;

  case NonLinearRaster:

  case LinearRaster:

    values.typeStr = tr("Raster level");

    break;

  case Mesh:

    values.typeStr = tr("Mesh level");

    break;

  case ToonzVector:

    values.typeStr = tr("Toonz Vector level");

    break;

  case Palette:

    values.typeStr = tr("Palette level");

    break;

  case SubXsheet:

    values.typeStr = tr("SubXsheet Level");

    break;

  case Sound:

    values.typeStr = tr("Sound Column");

    break;

  default:

    values.typeStr = tr("Another Level Type");

    break;

  }

  // dpi & res & resampling

  if (levelType & HasDPILevel) {

    LevelProperties::DpiPolicy dpiPolicy = sl->getProperties()->getDpiPolicy();

    assert(dpiPolicy == LevelProperties::DP_ImageDpi ||

           dpiPolicy == LevelProperties::DP_CustomDpi);

    values.dpiType = (dpiPolicy == LevelProperties::DP_ImageDpi) ? 0 : 1;

    // dpi field

    values.dpi = sl->getDpi();

    // image dpi

    values.imageDpi = dpiToString(sl->getImageDpi());

    if (levelType == ToonzRaster || levelType & Raster) {

      // size field

      TDimensionD size(0, 0);

      TDimension res = sl->getResolution();

      if (res.lx > 0 && res.ly > 0 && values.dpi.x > 0 && values.dpi.y > 0) {

        size.lx       = res.lx / values.dpi.x;

        size.ly       = res.ly / values.dpi.y;

        values.width  = tround(size.lx * 100.0) / 100.0;

        values.height = tround(size.ly * 100.0) / 100.0;

      } else {

        values.width  = -1.0;

        values.height = -1.0;

      }

      // image res

      TDimension imgRes = sl->getResolution();

      values.imageRes =

          QString::number(imgRes.lx) + "x" + QString::number(imgRes.ly);

      // subsampling

      values.subsampling = sl->getProperties()->getSubsampling();

      values.doPremulti =

          (sl->getProperties()->doPremultiply()) ? Qt::Checked : Qt::Unchecked;

      values.whiteTransp =

          (sl->getProperties()->whiteTransp()) ? Qt::Checked : Qt::Unchecked;

      values.doAntialias = (sl->getProperties()->antialiasSoftness() > 0)

                               ? Qt::Checked

                               : Qt::Unchecked;

      values.softness    = sl->getProperties()->antialiasSoftness();

      if (levelType == LinearRaster)

        values.colorSpaceGamma = sl->getProperties()->colorSpaceGamma();

    }

  }

  // gather dirty flags (subsampling is editable for only non-dirty levels)

  if (sl && sl->getProperties()->getDirtyFlag()) values.isDirty = Qt::Checked;

  return values;

}

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

/*! Update popup value.

                Take current level and act on level type set popup value.

*/

void LevelSettingsPopup::updateLevelSettings() {

  TApp *app = TApp::instance();

  m_selectedLevels.clear();

  CastSelection *castSelection =

      dynamic_cast<castselection *="">(app->getCurrentSelection()->getSelection());</castselection>

  TCellSelection *cellSelection = dynamic_cast<tcellselection *="">(</tcellselection>

      app->getCurrentSelection()->getSelection());

  TColumnSelection *columnSelection = dynamic_cast<tcolumnselection *="">(</tcolumnselection>

      app->getCurrentSelection()->getSelection());

  FxSelection *fxSelection =

      dynamic_cast<fxselection *="">(app->getCurrentSelection()->getSelection());</fxselection>

  // - - - Cell Selection

  if (cellSelection) {

    TXsheet *currentXsheet = app->getCurrentXsheet()->getXsheet();

    if (currentXsheet && !cellSelection->isEmpty()) {

      int r0, c0, r1, c1;

      cellSelection->getSelectedCells(r0, c0, r1, c1);

      for (int c = c0; c <= c1; c++)

        for (int r = r0; r <= r1; r++)

          if (TXshLevelP level = currentXsheet->getCell(r, c).m_level)

            m_selectedLevels.insert(level);

    } else

      m_selectedLevels.insert(app->getCurrentLevel()->getLevel());

  }

  // - - - Column Selection

  else if (columnSelection) {

    TXsheet *currentXsheet = app->getCurrentXsheet()->getXsheet();

    if (currentXsheet && !columnSelection->isEmpty()) {

      int sceneLength             = currentXsheet->getFrameCount();

      std::set<int> columnIndices = columnSelection->getIndices();</int>

      std::set<int>::iterator it;</int>

      for (it = columnIndices.begin(); it != columnIndices.end(); ++it) {

        int columnIndex = *it;

        int r0, r1;

        currentXsheet->getCellRange(columnIndex, r0, r1);

        if (r1 < 0) continue;  // skip empty column

        for (int r = r0; r <= r1; r++)

          if (TXshLevelP level = currentXsheet->getCell(r, columnIndex).m_level)

            m_selectedLevels.insert(level);

      }

    } else

      m_selectedLevels.insert(app->getCurrentLevel()->getLevel());

  }

  // - - - Cast Selection

  else if (castSelection) {

    std::vector<txshlevel *=""> levels;</txshlevel>

    castSelection->getSelectedLevels(levels);

    for (TXshLevel *level : levels) m_selectedLevels.insert(level);

  }

  // - - - Schematic Nodes Selection

  else if (fxSelection) {

    TXsheet *currentXsheet  = app->getCurrentXsheet()->getXsheet();

    QList<tfxp> selectedFxs = fxSelection->getFxs();</tfxp>

    if (currentXsheet && !selectedFxs.isEmpty()) {

      for (int f = 0; f < selectedFxs.size(); f++) {

        TLevelColumnFx *lcfx =

            dynamic_cast<tlevelcolumnfx *="">(selectedFxs.at(f).getPointer());</tlevelcolumnfx>

        if (lcfx) {

          int r0, r1;

          int firstRow =

              lcfx->getXshColumn()->getCellColumn()->getRange(r0, r1);

          for (int r = r0; r <= r1; r++)

            if (TXshLevelP level =

                    lcfx->getXshColumn()->getCellColumn()->getCell(r).m_level)

              m_selectedLevels.insert(level);

        }

      }

      if (m_selectedLevels.isEmpty())

        m_selectedLevels.insert(app->getCurrentLevel()->getLevel());

    } else

      m_selectedLevels.insert(app->getCurrentLevel()->getLevel());

  } else

    m_selectedLevels.insert(app->getCurrentLevel()->getLevel());

  // Unite flags, Remove unsupported items

  unsigned int levelTypeFlag         = 0;