#include "outputsettingspopup.h"

// Tnz6 includes

#include "menubarcommandids.h"

#include "formatsettingspopups.h"

#include "tapp.h"

#include "camerasettingspopup.h"

#include "pane.h"

#include "boardsettingspopup.h"

// TnzQt includes

#include "toonzqt/menubarcommand.h"

#include "toonzqt/gutil.h"

#include "toonzqt/filefield.h"

#include "toonzqt/doublefield.h"

#include "toonzqt/checkbox.h"

// TnzLib includes

#include "toonz/tscenehandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/toonzscene.h"

#include "toonz/txsheet.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/preferences.h"

#include "toutputproperties.h"

#include "toonz/tcamera.h"

#include "toonz/boardsettings.h"

// TnzBase includes

#include "trasterfx.h"

// TnzCore includes

#include "tiio.h"

#include "tlevel_io.h"

#include "tenv.h"

#include "tsystem.h"

#include "tstream.h"

#include "tfiletype.h"

// Qt includes

#include <qlabel></qlabel>

#include <qpushbutton></qpushbutton>

#include <qcombobox></qcombobox>

#include <qmainwindow></qmainwindow>

#include <qframe></qframe>

#include <qmessagebox></qmessagebox>

#include <qmap></qmap>

#include <qlistwidget></qlistwidget>

#include <qscrollarea></qscrollarea>

#include <qpropertyanimation></qpropertyanimation>

#include <qspaceritem></qspaceritem>

#include <qevent></qevent>

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

namespace {

enum ResampleOption {

  c_standard = 0,

  c_improved,

  c_high,

  c_triangle,

  c_mitchell,

  c_cubic5,

  c_cubic75,

  c_cubic1,

  c_hann2,

  c_hann3,

  c_hamming2,

  c_hamming3,

  c_lanczos2,

  c_lanczos3,

  c_gauss,

  c_closestPixel,

  c_bilinear,

  ResampleOptionCount

};

struct resampleInfo {

  QString idString;

  TRenderSettings::ResampleQuality quality;

  QString uiString = "";

  resampleInfo(QString _idStr = "",

               TRenderSettings::ResampleQuality _quality =

                   TRenderSettings::StandardResampleQuality)

      : idString(_idStr), quality(_quality), uiString("") {}

};

QMap<resampleoption, resampleinfo=""> resampleInfoMap = {</resampleoption,>

    {c_standard,

     resampleInfo("Standard", TRenderSettings::StandardResampleQuality)},

    {c_improved,

     resampleInfo("Improved", TRenderSettings::ImprovedResampleQuality)},

    {c_high, resampleInfo("High", TRenderSettings::HighResampleQuality)},

    {c_triangle, resampleInfo("Triangle filter",

                              TRenderSettings::Triangle_FilterResampleQuality)},

    {c_mitchell, resampleInfo("Mitchell-Netravali filter",

                              TRenderSettings::Mitchell_FilterResampleQuality)},

    {c_cubic5, resampleInfo("Cubic convolution, a = .5",

                            TRenderSettings::Cubic5_FilterResampleQuality)},

    {c_cubic75, resampleInfo("Cubic convolution, a = .75",

                             TRenderSettings::Cubic75_FilterResampleQuality)},

    {c_cubic1, resampleInfo("Cubic convolution, a = 1",

                            TRenderSettings::Cubic1_FilterResampleQuality)},

    {c_hann2, resampleInfo("Hann window, rad = 2",

                           TRenderSettings::Hann2_FilterResampleQuality)},

    {c_hann3, resampleInfo("Hann window, rad = 3",

                           TRenderSettings::Hann3_FilterResampleQuality)},

    {c_hamming2, resampleInfo("Hamming window, rad = 2",

                              TRenderSettings::Hamming2_FilterResampleQuality)},

    {c_hamming3, resampleInfo("Hamming window, rad = 3",

                              TRenderSettings::Hamming3_FilterResampleQuality)},

    {c_lanczos2, resampleInfo("Lanczos window, rad = 2",

                              TRenderSettings::Lanczos2_FilterResampleQuality)},

    {c_lanczos3, resampleInfo("Lanczos window, rad = 3",

                              TRenderSettings::Lanczos3_FilterResampleQuality)},

    {c_gauss, resampleInfo("Gaussian convolution",

                           TRenderSettings::Gauss_FilterResampleQuality)},

    {c_closestPixel,

     resampleInfo("Closest Pixel (Nearest Neighbor)",

                  TRenderSettings::ClosestPixel_FilterResampleQuality)},

    {c_bilinear,

     resampleInfo("Bilinear",

                  TRenderSettings::Bilinear_FilterResampleQuality)}};

ResampleOption quality2index(TRenderSettings::ResampleQuality quality) {

  QMapIterator<resampleoption, resampleinfo=""> i(resampleInfoMap);</resampleoption,>

  while (i.hasNext()) {

    i.next();

    if (i.value().quality == quality) return i.key();

  }

  return c_standard;

}

enum ChannelWidth { c_8bit, c_16bit, c_32bit };  // 32bit: compute in float

enum DominantField { c_odd, c_even, c_none };

enum ThreadsOption {

  c_single,

  c_half,

  c_all,

};

enum GranularityOption { c_off, c_large, c_medium, c_small };

bool checkForSeqNum(QString type) {

  TFileType::Type typeInfo = TFileType::getInfoFromExtension(type);

  if ((typeInfo & TFileType::IMAGE) && !(typeInfo & TFileType::LEVEL))

    return true;

  else

    return false;

}

}  // anonymous namespace

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

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

/*! \class OutputSettingsPopup

                \brief The OutputSettingsPopup class provides a output settings

   dialog.

                Inherits \b Dialog.

                This class allows to set output properties of current scene.

                It's composed of a list of field to set this preperties:

                a \b DVGui::FileField to set output directory, a LineEdit for

   output name,

                a \b QComboBox to choose format, a button near QComboBox that

   open a popup

                to change format chosen settings, other QComboBox to choose

   camera,

                resample balance, channel width and dominant field and other

   number field

                to set values for frame and time stretch.

*/

OutputSettingsPopup::OutputSettingsPopup(bool isPreview)

    : Dialog(TApp::instance()->getMainWindow(), false, isPreview,

             isPreview ? "PreviewSettings" : "OutputSettings")

    , m_subcameraChk(nullptr)

    , m_applyShrinkChk(nullptr)

    , m_outputCameraOm(nullptr)

    , m_isPreviewSettings(isPreview)

    , m_allowMT(Preferences::instance()->getFfmpegMultiThread())

    , m_presetCombo(nullptr)

    , m_syncColorSettingsButton(nullptr) {

  setWindowTitle(isPreview ? tr("Preview Settings") : tr("Output Settings"));

  if (!isPreview) setObjectName("OutputSettingsPopup");

  // create panel

  QFrame *panel = createPanel(isPreview);

  // preview settings

  if (isPreview) {

    m_topLayout->setMargin(5);

    m_topLayout->addWidget(panel, 0);

    return;

  }

  // outputsettings with category list & scrollable panel

  QPushButton *addPresetButton    = new QPushButton(tr("Add"), this);

  QPushButton *removePresetButton = new QPushButton(tr("Remove"), this);

  m_presetCombo                   = new QComboBox(this);

  addPresetButton->setObjectName("PushButton_NoPadding");

  removePresetButton->setObjectName("PushButton_NoPadding");

  QString tooltip =

      tr("Save current output settings.\nThe parameters to be saved are:\n- "

         "Camera settings\n- Project folder to be saved in\n- File format\n- "

         "File options\n- Resample Balance\n- Channel width\n- Linear Color "

         "Space\n- Color Space Gamma");

  addPresetButton->setToolTip(tooltip);

  /*-- プリセットフォルダを調べ、コンボボックスにアイテムを格納する --*/

  updatePresetComboItems();

  QListWidget *categoryList = new QListWidget(this);

  QStringList categories;

  categories << tr("Camera") << tr("Color") << tr("File") << tr("More");

  categoryList->addItems(categories);

  categoryList->setFixedWidth(100);

  categoryList->setCurrentRow(0);

  m_scrollArea = new QScrollArea(this);

  m_scrollArea->setWidgetResizable(true);

  m_scrollArea->setWidget(panel);

  QPushButton *renderButton = new QPushButton(tr("Render"), this);

  renderButton->setIcon(createQIcon("render"));

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

  renderButton->setFixedWidth(200);

  m_topLayout->setMargin(5);

  {

    QHBoxLayout *presetLay = new QHBoxLayout();

    presetLay->setMargin(0);

    presetLay->setSpacing(5);

    {

      presetLay->addStretch(1);

      presetLay->addWidget(new QLabel(tr("Presets:"), this), 1,

                           Qt::AlignRight | Qt::AlignVCenter);

      presetLay->addWidget(m_presetCombo, 1);

      presetLay->addWidget(addPresetButton, 0);

      presetLay->addWidget(removePresetButton, 0);

    }

    m_topLayout->addLayout(presetLay, 0);

    QHBoxLayout *middleLay = new QHBoxLayout();

    middleLay->setMargin(0);

    middleLay->setSpacing(5);

    {

      middleLay->addWidget(categoryList, 0);

      middleLay->addWidget(m_scrollArea, 1);

    }

    m_topLayout->addLayout(middleLay, 1);

    m_topLayout->addSpacing(5);

    m_topLayout->addWidget(renderButton, 0, Qt::AlignCenter);

  }

  bool ret = true;

  ret      = ret &&

        connect(renderButton, SIGNAL(pressed()), this, SLOT(onRenderClicked()));

  ret = ret && connect(addPresetButton, SIGNAL(pressed()), this,

                       SLOT(onAddPresetButtonPressed()));

  ret = ret && connect(removePresetButton, SIGNAL(pressed()), this,

                       SLOT(onRemovePresetButtonPressed()));

  ret = ret && connect(m_presetCombo, SIGNAL(activated(const QString &)), this,

                       SLOT(onPresetSelected(const QString &)));

  ret = ret && connect(categoryList, SIGNAL(itemClicked(QListWidgetItem *)),

                       this, SLOT(onCategoryActivated(QListWidgetItem *)));

  assert(ret);

}

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

void OutputSettingsPopup::onCategoryActivated(QListWidgetItem *item) {

  AnimatedLabel *label;

  QFrame *frame;

  if (item->text() == tr("Camera")) {

    label = m_cameraLabel;

    frame = m_cameraBox;

  } else if (item->text() == tr("Color")) {

    label = m_colorLabel;

    frame = m_colorBox;

  } else if (item->text() == tr("File")) {

    label = m_fileLabel;

    frame = m_fileBox;

  } else if (item->text() == tr("More")) {

    label = m_moreLabel;

    frame = m_moreBox;

  } else

    return;

  m_scrollArea->ensureWidgetVisible(frame);

  QPropertyAnimation *a = new QPropertyAnimation(label, "color");

  a->setDuration(1000);

  a->setStartValue(QColor(255, 255, 0, 128));

  a->setEndValue(QColor(255, 255, 0, 0));

  a->setEasingCurve(QEasingCurve::OutBack);

  a->start(QPropertyAnimation::DeleteWhenStopped);

}

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

QFrame *OutputSettingsPopup::createPanel(bool isPreview) {

  QFrame *panel = new QFrame(this);

  m_cameraLabel = new AnimatedLabel(tr("Camera Settings"), this);

  m_colorLabel  = new AnimatedLabel(tr("Color Settings"), this);

  if (isPreview)

    m_syncColorSettingsButton =

        new DVGui::CheckBox(tr("Sync with Output Settings"));

  m_fileLabel = new AnimatedLabel(tr("File Settings"), this);

  m_cameraBox = createCameraSettingsBox(isPreview);

  m_colorBox  = createColorSettingsBox(isPreview);

  m_fileBox   = createFileSettingsBox(isPreview);

  if (!isPreview) {

    m_moreLabel = new AnimatedLabel(tr("More Settings"), this);

    m_moreBox   = createMoreSettingsBox();

  }

  QVBoxLayout *lay = new QVBoxLayout();

  lay->setMargin(5);

  lay->setSpacing(3);

  {

    lay->addWidget(m_cameraLabel, 0);

    lay->addWidget(m_cameraBox, 0);

    lay->addSpacing(10);

    QHBoxLayout *colorLabelLay = new QHBoxLayout();

    colorLabelLay->setMargin(0);

    colorLabelLay->setSpacing(0);

    {

      colorLabelLay->addWidget(m_colorLabel, 0);

      colorLabelLay->addStretch(1);

      if (isPreview && m_syncColorSettingsButton)

        colorLabelLay->addWidget(m_syncColorSettingsButton, 0);

    }

    lay->addLayout(colorLabelLay, 0);

    lay->addWidget(m_colorBox, 0);

    lay->addSpacing(10);

    lay->addWidget(m_fileLabel, 0);

    lay->addWidget(m_fileBox, 0);

    if (!isPreview) {

      lay->addSpacing(10);

      lay->addWidget(m_moreLabel, 0);

      lay->addWidget(m_moreBox, 0);

    }

    lay->addStretch(1);

  }

  panel->setLayout(lay);

  if (isPreview && m_syncColorSettingsButton) {

    bool ret = connect(m_syncColorSettingsButton, SIGNAL(stateChanged(int)),

                       SLOT(onSyncColorSettingsChecked(int)));

    assert(ret);

  }

  return panel;

}

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

QFrame *OutputSettingsPopup::createCameraSettingsBox(bool isPreview) {

  QFrame *cameraSettingsBox = new QFrame(this);

  cameraSettingsBox->setObjectName("OutputSettingsBox");

  // Output Camera

  m_outputCameraOm = new QComboBox();

  // Frame Start-End

  m_startFld = new DVGui::IntLineEdit(this);

  m_endFld   = new DVGui::IntLineEdit(this);

  // Step-Shrink

  m_stepFld   = new DVGui::IntLineEdit(this);

  m_shrinkFld = new DVGui::IntLineEdit(this);

  QFrame *cameraParametersBox = nullptr;

  if (!isPreview) {

    m_cameraSettings    = new CameraSettingsPopup();

    cameraParametersBox = new QFrame(this);

    cameraParametersBox->setObjectName("OutputSettingsCameraBox");

    m_outputCameraOm->setFocusPolicy(Qt::StrongFocus);

    m_outputCameraOm->installEventFilter(this);

  } else {

    // Subcamera checkbox

    m_subcameraChk = new DVGui::CheckBox(tr("Use Sub-Camera"));

    m_applyShrinkChk =

        new DVGui::CheckBox(tr("Apply Shrink to Main Viewer"), this);

  }

  m_outputCameraOm->setSizeAdjustPolicy(QComboBox::AdjustToContents);

  //-----

  QVBoxLayout *lay = new QVBoxLayout();

  lay->setMargin(10);

  lay->setSpacing(10);

  {

    // Output Camera

    QHBoxLayout *outCamLay = new QHBoxLayout();

    outCamLay->setMargin(0);

    outCamLay->setSpacing(5);

    {

      outCamLay->addWidget(new QLabel(tr("Output Camera:"), this), 0);

      outCamLay->addWidget(m_outputCameraOm, 0);

      outCamLay->addStretch(1);

    }

    lay->addLayout(outCamLay);

    if (!isPreview) {

      QVBoxLayout *camParamLay = new QVBoxLayout();

      camParamLay->setMargin(5);

      camParamLay->setSpacing(0);

      { camParamLay->addWidget(m_cameraSettings); }

      cameraParametersBox->setLayout(camParamLay);

      lay->addWidget(cameraParametersBox);

    }

    // Frame start/end

    QGridLayout *frameShrinkLay = new QGridLayout();

    frameShrinkLay->setMargin(0);

    frameShrinkLay->setHorizontalSpacing(5);

    frameShrinkLay->setVerticalSpacing(10);

    {

      frameShrinkLay->addWidget(new QLabel(tr("Frame Start:"), this), 0, 0,

                                Qt::AlignRight | Qt::AlignVCenter);

      frameShrinkLay->addWidget(m_startFld, 0, 1);

      frameShrinkLay->addItem(

          new QSpacerItem(3, 1, QSizePolicy::Fixed, QSizePolicy::Fixed), 0, 2);

      frameShrinkLay->addWidget(new QLabel(tr("End:"), this), 0, 3,

                                Qt::AlignRight | Qt::AlignVCenter);

      frameShrinkLay->addWidget(m_endFld, 0, 4);

      frameShrinkLay->addItem(

          new QSpacerItem(10, 1, QSizePolicy::Fixed, QSizePolicy::Fixed), 0, 5);

      frameShrinkLay->addWidget(new QLabel(tr("Step:"), this), 0, 6,

                                Qt::AlignRight | Qt::AlignVCenter);

      frameShrinkLay->addWidget(m_stepFld, 0, 7);

      frameShrinkLay->addWidget(new QLabel(tr("Shrink:"), this), 1, 0,

                                Qt::AlignRight | Qt::AlignVCenter);

      frameShrinkLay->addWidget(m_shrinkFld, 1, 1);

      if (isPreview)

        frameShrinkLay->addWidget(m_applyShrinkChk, 1, 4, 1, 5,

                                  Qt::AlignRight | Qt::AlignVCenter);

    }

    frameShrinkLay->setColumnStretch(8, 1);

    lay->addLayout(frameShrinkLay);

  }

  cameraSettingsBox->setLayout(lay);

  //-----

  bool ret = true;

  ret      = ret &&

        connect(m_outputCameraOm, SIGNAL(currentIndexChanged(const QString &)),

                SLOT(onCameraChanged(const QString &)));

  ret = ret && connect(m_startFld, SIGNAL(editingFinished()),

                       SLOT(onFrameFldEditFinished()));

  ret = ret && connect(m_endFld, SIGNAL(editingFinished()),

                       SLOT(onFrameFldEditFinished()));

  ret = ret && connect(m_stepFld, SIGNAL(editingFinished()),

                       SLOT(onFrameFldEditFinished()));

  ret = ret && connect(m_shrinkFld, SIGNAL(editingFinished()),

                       SLOT(onFrameFldEditFinished()));

  if (!isPreview) {

    ret = ret && connect(m_cameraSettings, SIGNAL(changed()), this,

                         SLOT(onCameraSettingsChanged()));

  } else {

    ret = ret && connect(m_applyShrinkChk, SIGNAL(stateChanged(int)),

                         SLOT(onApplyShrinkChecked(int)));

  }

  assert(ret);

  return cameraSettingsBox;

}

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

QFrame *OutputSettingsPopup::createColorSettingsBox(bool isPreview) {

  QFrame *colorSettingsBox = new QFrame(this);

  colorSettingsBox->setObjectName("OutputSettingsBox");

  // Channel Width

  m_channelWidthOm = new QComboBox();

  // Linear Color Space

  m_linearColorSpaceChk = new DVGui::CheckBox();

  // color space gamma

  m_colorSpaceGammaFld = new DVGui::DoubleLineEdit(this, 2.2);

  // Channel Width

  m_channelWidthOm->addItem(tr("8 bit"), "8 bit");

  m_channelWidthOm->addItem(tr("16 bit"), "16 bit");

  m_channelWidthOm->addItem(tr("32 bit Floating point"), "32 bit");

  m_linearColorSpaceChk->setToolTip(

      tr("On rendering, color values will be temporarily converted to linear "

         "light from nonlinear RGB values by using color space gamma."));

  if (m_isPreviewSettings)

    m_colorSpaceGammaFld->setRange(-1.0, 5.0);

  else

    m_colorSpaceGammaFld->setRange(1.0, 5.0);

  m_colorSpaceGammaFld->setDecimals(3);

  QString colorSpaceGammaTooltip =

      tr("Color Space Gamma value is used for conversion between the linear "

         "and nonlinear color spaces,\n"

         "when the \"Linear Color Space\" option is enabled.");

  if (m_isPreviewSettings)

    colorSpaceGammaTooltip +=

        tr("\nInput less than 1.0 to sync the value with the output settings.");

  m_colorSpaceGammaFld->setToolTip(colorSpaceGammaTooltip);

  if (!isPreview) {

    m_channelWidthOm->setFocusPolicy(Qt::StrongFocus);

  }

  QGridLayout *gridLay = new QGridLayout();

  gridLay->setMargin(5);

  gridLay->setHorizontalSpacing(5);

  gridLay->setVerticalSpacing(10);

  {

    // Channel Width

    gridLay->addWidget(new QLabel(tr("Channel Width:"), this), 0, 0,

                       Qt::AlignRight | Qt::AlignVCenter);

    gridLay->addWidget(m_channelWidthOm, 0, 1, 1, 2,

                       Qt::AlignLeft | Qt::AlignVCenter);

    // Linear Color Space and Color SpaceGamma

    gridLay->addWidget(new QLabel(tr("Linear Color Space:"), this), 1, 0,

                       Qt::AlignRight | Qt::AlignVCenter);

    gridLay->addWidget(m_linearColorSpaceChk, 1, 1,

                       Qt::AlignLeft | Qt::AlignVCenter);

    gridLay->addWidget(new QLabel(tr("Color Space Gamma:"), this), 1, 2,

                       Qt::AlignRight | Qt::AlignVCenter);

    gridLay->addWidget(m_colorSpaceGammaFld, 1, 3);

  }

  gridLay->setColumnStretch(2, 1);

  colorSettingsBox->setLayout(gridLay);

  bool ret = true;

  ret      = ret && connect(m_channelWidthOm, SIGNAL(currentIndexChanged(int)),

                            SLOT(onChannelWidthChanged(int)));

  ret      = ret && connect(m_linearColorSpaceChk, SIGNAL(stateChanged(int)),

                            SLOT(onLinearColorSpaceChecked(int)));

  ret = ret && connect(m_colorSpaceGammaFld, SIGNAL(editingFinished()),

                       SLOT(onColorSpaceGammaEdited()));

  assert(ret);

  return colorSettingsBox;

}

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

QFrame *OutputSettingsPopup::createFileSettingsBox(bool isPreview) {

  QFrame *fileSettingsBox = new QFrame(this);

  fileSettingsBox->setObjectName("OutputSettingsBox");

  // Resample Balance

  m_resampleBalanceOm = new QComboBox();

  // Threads

  m_threadsComboOm = new QComboBox();

  // Granularity

  m_rasterGranularityOm = new QComboBox();

  // Resample Balance

  translateResampleOptions();

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

    m_resampleBalanceOm->addItem(resampleInfoMap[(ResampleOption)i].uiString,

                                 resampleInfoMap[(ResampleOption)i].idString);

  }

  QStringList threadsChoices;

  threadsChoices << tr("Single") << tr("Half") << tr("All");

  m_threadsComboOm->addItems(threadsChoices);

  QStringList granularityChoices;

  granularityChoices << tr("None") << tr("Large") << tr("Medium")

                     << tr("Small");

  m_rasterGranularityOm->addItems(granularityChoices);

  if (!isPreview) {

    // Save In

    m_saveInFileFld = new DVGui::FileField(0, QString(""));

    // File Name

    m_fileNameFld = new DVGui::LineEdit(QString(""));

    // File Format

    m_fileFormat       = new QComboBox();

    m_fileFormatButton = new QPushButton(tr("Options"));

    // File Format

    QStringList formats;

    TImageWriter::getSupportedFormats(formats, true);

    TLevelWriter::getSupportedFormats(formats, true);

    Tiio::Writer::getSupportedFormats(formats, true);

    formats.sort();

    m_fileFormat->addItems(formats);

    m_fileFormat->setFocusPolicy(Qt::StrongFocus);

    m_resampleBalanceOm->setFocusPolicy(Qt::StrongFocus);

    m_threadsComboOm->setFocusPolicy(Qt::StrongFocus);

    m_rasterGranularityOm->setFocusPolicy(Qt::StrongFocus);

    m_fileFormat->installEventFilter(this);

    m_resampleBalanceOm->installEventFilter(this);

    m_channelWidthOm->installEventFilter(this);

    m_threadsComboOm->installEventFilter(this);

    m_rasterGranularityOm->installEventFilter(this);

  }

  //-----

  QVBoxLayout *lay = new QVBoxLayout();

  lay->setMargin(10);

  lay->setSpacing(10);

  {

    if (!isPreview) {

      QGridLayout *upperGridLay = new QGridLayout();

      upperGridLay->setMargin(0);

      upperGridLay->setHorizontalSpacing(5);

      upperGridLay->setVerticalSpacing(10);

      {

        // Save In

        upperGridLay->addWidget(new QLabel(tr("Save in:"), this), 0, 0,

                                Qt::AlignRight | Qt::AlignVCenter);

        upperGridLay->addWidget(m_saveInFileFld, 0, 1, 1, 3);

        // File Name

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

                                Qt::AlignRight | Qt::AlignVCenter);

        upperGridLay->addWidget(m_fileNameFld, 1, 1);

        // File Format

        upperGridLay->addWidget(m_fileFormat, 1, 2);

        upperGridLay->addWidget(m_fileFormatButton, 1, 3);

      }

      upperGridLay->setColumnStretch(1, 1);

      lay->addLayout(upperGridLay);

    }

    QGridLayout *bottomGridLay = new QGridLayout();

    bottomGridLay->setMargin(0);

    bottomGridLay->setHorizontalSpacing(5);

    bottomGridLay->setVerticalSpacing(10);

    {

      // Resample Balance

      bottomGridLay->addWidget(new QLabel(tr("Resample Balance:"), this), 0, 0,

                               Qt::AlignRight | Qt::AlignVCenter);

      bottomGridLay->addWidget(m_resampleBalanceOm, 0, 1, 1, 2,

                               Qt::AlignLeft | Qt::AlignVCenter);

      // Threads

      bottomGridLay->addWidget(new QLabel(tr("Dedicated CPUs:"), this), 1, 0,

                               Qt::AlignRight | Qt::AlignVCenter);

      bottomGridLay->addWidget(m_threadsComboOm, 1, 1);

      // Granularity

      bottomGridLay->addWidget(new QLabel(tr("Render Tile:"), this), 2, 0,

                               Qt::AlignRight | Qt::AlignVCenter);

      bottomGridLay->addWidget(m_rasterGranularityOm, 2, 1);

      if (m_subcameraChk) {

        bottomGridLay->addWidget(m_subcameraChk, 3, 1, 1, 2);

      }

    }

    bottomGridLay->setColumnStretch(2, 1);

    lay->addLayout(bottomGridLay);

  }

  fileSettingsBox->setLayout(lay);

  //-----

  bool ret = true;

  if (!isPreview) {

    ret = ret && connect(m_saveInFileFld, SIGNAL(pathChanged()), this,

                         SLOT(onPathChanged()));

    ret = ret && connect(m_fileNameFld, SIGNAL(editingFinished()),

                         SLOT(onNameChanged()));

    ret = ret &&

          connect(m_fileFormat, SIGNAL(currentIndexChanged(const QString &)),

                  SLOT(onFormatChanged(const QString &)));

    ret = ret && connect(m_fileFormatButton, SIGNAL(pressed()), this,

                         SLOT(openSettingsPopup()));

  }

  ret = ret && connect(m_resampleBalanceOm, SIGNAL(currentIndexChanged(int)),

                       SLOT(onResampleChanged(int)));

  ret = ret && connect(m_threadsComboOm, SIGNAL(currentIndexChanged(int)),

                       SLOT(onThreadsComboChanged(int)));

  ret = ret && connect(m_rasterGranularityOm, SIGNAL(currentIndexChanged(int)),

                       SLOT(onRasterGranularityChanged(int)));

  if (m_subcameraChk)

    ret = ret && connect(m_subcameraChk, SIGNAL(stateChanged(int)),

                         SLOT(onSubcameraChecked(int)));

  assert(ret);

  return fileSettingsBox;

}

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

QFrame *OutputSettingsPopup::createMoreSettingsBox() {

  QFrame *moreSettingsBox = new QFrame(this);

  moreSettingsBox->setObjectName("OutputSettingsBox");

  // Board

  m_addBoard         = new DVGui::CheckBox(tr("Add Clapperboard"), this);

  m_boardSettingsBtn = new QPushButton(tr("Edit Clapperboard..."), this);

  // Gamma

  m_gammaFld = new DVGui::DoubleLineEdit();

  // Dominant Field

  m_dominantFieldOm = new QComboBox();

  // Stretch

  TRenderSettings rs = getProperties()->getRenderSettings();

  // Scene Settings FPS

  double frameRate = getProperties()->getFrameRate();

  m_frameRateFld   = new DVGui::DoubleLineEdit(this, frameRate);

  m_stretchFromFld = new DVGui::DoubleLineEdit(this, rs.m_timeStretchFrom);

  m_stretchToFld   = new DVGui::DoubleLineEdit(this, rs.m_timeStretchTo);

  m_multimediaOm   = new QComboBox(this);

  m_doStereoscopy  = new DVGui::CheckBox(tr("Do stereoscopy"), this);

  m_stereoShift    = new DVGui::DoubleLineEdit(this, 0.05);

  // Dominant Field

  QStringList dominantField;

  dominantField << tr("Odd (NTSC)") << tr("Even (PAL)") << tr("None");

  m_dominantFieldOm->addItems(dominantField);

  m_dominantFieldOm->setFocusPolicy(Qt::StrongFocus);

  m_dominantFieldOm->installEventFilter(this);

  m_stretchFromFld->setRange(1, 1000);

  m_stretchToFld->setRange(1, 1000);

  m_stretchFromFld->setDecimals(2);

  m_stretchToFld->setDecimals(2);

  // Multimedia rendering enum

  QStringList multimediaTypes;

  multimediaTypes << tr("None") << tr("Fx Schematic Flows")

                  << tr("Fx Schematic Terminal Nodes");

  m_multimediaOm->addItems(multimediaTypes);

  m_multimediaOm->setFocusPolicy(Qt::StrongFocus);

  m_multimediaOm->installEventFilter(this);

  m_stereoShift->setEnabled(false);

  //-----

  QGridLayout *lay = new QGridLayout();

  lay->setMargin(5);

  lay->setHorizontalSpacing(5);

  lay->setVerticalSpacing(10);

  {

    // clapperboard

    lay->addWidget(m_addBoard, 0, 0);

    lay->addWidget(m_boardSettingsBtn, 0, 1, 1, 3,

                   Qt::AlignLeft | Qt::AlignVCenter);

    // Gamma

    lay->addWidget(new QLabel(tr("Gamma:"), this), 1, 0,

                   Qt::AlignRight | Qt::AlignVCenter);

    lay->addWidget(m_gammaFld, 1, 1, Qt::AlignLeft | Qt::AlignVCenter);

    // Dominant Field

    lay->addWidget(new QLabel(tr("Dominant Field:"), this), 2, 0,

                   Qt::AlignRight | Qt::AlignVCenter);

    lay->addWidget(m_dominantFieldOm, 2, 1, 1, 2,

                   Qt::AlignLeft | Qt::AlignVCenter);

    // Scene Settings' FPS

    lay->addWidget(new QLabel(tr("Frame Rate:"), this), 3, 0,

                   Qt::AlignRight | Qt::AlignVCenter);

    lay->addWidget(m_frameRateFld, 3, 1, Qt::AlignLeft | Qt::AlignVCenter);

    lay->addWidget(new QLabel(tr("(linked to Scene Settings)"), this), 3, 2, 1,

                   2, Qt::AlignLeft | Qt::AlignVCenter);

    // Stretch

    lay->addWidget(new QLabel(tr("Stretch from FPS:"), this), 4, 0,

                   Qt::AlignRight | Qt::AlignVCenter);

    lay->addWidget(m_stretchFromFld, 4, 1, Qt::AlignLeft | Qt::AlignVCenter);

    lay->addWidget(new QLabel(tr("  To:"), this), 4, 2,

                   Qt::AlignRight | Qt::AlignVCenter);

    lay->addWidget(m_stretchToFld, 4, 3, Qt::AlignLeft | Qt::AlignVCenter);

    // new in V6.1

    // Multimedia rendering enum

    lay->addWidget(new QLabel(tr("Multiple Rendering:"), this), 5, 0,

                   Qt::AlignRight | Qt::AlignVCenter);

    lay->addWidget(m_multimediaOm, 5, 1, 1, 3,

                   Qt::AlignLeft | Qt::AlignVCenter);

    lay->addWidget(m_doStereoscopy, 6, 0);

    lay->addWidget(new QLabel(tr("Camera Shift:")), 6, 1, 1, 2,

                   Qt::AlignRight | Qt::AlignVCenter);

    lay->addWidget(m_stereoShift, 6, 3, Qt::AlignLeft | Qt::AlignVCenter);

  }

  lay->setColumnStretch(4, 1);

  moreSettingsBox->setLayout(lay);

  //-----

  bool ret = true;

  // clapperboard

  ret = ret && connect(m_addBoard, SIGNAL(stateChanged(int)), this,

                       SLOT(onAddBoardChecked(int)));

  ret = ret && connect(m_boardSettingsBtn, SIGNAL(clicked()), this,

                       SLOT(onBoardSettingsBtnClicked()));

  ret = ret && connect(m_gammaFld, SIGNAL(editingFinished()),

                       SLOT(onGammaFldEditFinished()));

  ret = ret && connect(m_dominantFieldOm, SIGNAL(currentIndexChanged(int)),

                       SLOT(onDominantFieldChanged(int)));

  ret = ret && connect(m_frameRateFld, SIGNAL(editingFinished()), this,

                       SLOT(onFrameRateEditingFinished()));

  ret = ret && connect(m_stretchFromFld, SIGNAL(editingFinished()),

                       SLOT(onStretchFldEditFinished()));

  ret = ret && connect(m_stretchToFld, SIGNAL(editingFinished()),

                       SLOT(onStretchFldEditFinished()));

  ret = ret && connect(m_multimediaOm, SIGNAL(currentIndexChanged(int)), this,

                       SLOT(onMultimediaChanged(int)));

  ret = ret && connect(m_doStereoscopy, SIGNAL(stateChanged(int)),

                       SLOT(onStereoChecked(int)));

  ret = ret && connect(m_stereoShift, SIGNAL(editingFinished()),

                       SLOT(onStereoChanged()));

  assert(ret);

  return moreSettingsBox;

}

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

/*! Return current \b ToonzScene scene.

 */

ToonzScene *OutputSettingsPopup::getCurrentScene() const {

  ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();

  return scene;

}

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

/*!	Return current scene output properties \b TOutputProperties, if

                current scene is not empty.

*/

TOutputProperties *OutputSettingsPopup::getProperties() const {

  ToonzScene *scene = getCurrentScene();

  if (!scene) return 0;

  return m_isPreviewSettings ? scene->getProperties()->getPreviewProperties()

                             : scene->getProperties()->getOutputProperties();

}

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

void OutputSettingsPopup::showEvent(QShowEvent *) {

  TSceneHandle *sceneHandle   = TApp::instance()->getCurrentScene();

  TXsheetHandle *xsheetHandle = TApp::instance()->getCurrentXsheet();

  bool ret =

      connect(sceneHandle, SIGNAL(sceneChanged()), this, SLOT(updateField()));

  ret = ret && connect(sceneHandle, SIGNAL(sceneSwitched()), this,

                       SLOT(updateField()));

  ret = ret && connect(xsheetHandle, SIGNAL(xsheetChanged()), this,

                       SLOT(updateField()));

  updateField();

  assert(ret);

}

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

void OutputSettingsPopup::hideEvent(QHideEvent *e) {

  TSceneHandle *sceneHandle   = TApp::instance()->getCurrentScene();

  TXsheetHandle *xsheetHandle = TApp::instance()->getCurrentXsheet();

  bool ret = disconnect(sceneHandle, SIGNAL(sceneChanged()), this,

                        SLOT(updateField()));

  ret      = ret && disconnect(sceneHandle, SIGNAL(sceneSwitched()), this,

                               SLOT(updateField()));

  ret = ret && disconnect(xsheetHandle, SIGNAL(xsheetChanged()), this,

                          SLOT(updateField()));

  assert(ret);

  Dialog::hideEvent(e);

}

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

// ignore wheelevent on comboboxes

bool OutputSettingsPopup::eventFilter(QObject *obj, QEvent *e) {

  if (e->type() == QEvent::Wheel) {

    QComboBox *combo = qobject_cast<qcombobox *="">(obj);</qcombobox>

    if (combo && !combo->hasFocus()) return true;

  }

  return QObject::eventFilter(obj, e);

}