#include "preferencespopup.h"

// Tnz6 includes

#include "menubarcommandids.h"

#include "versioncontrol.h"

#include "levelsettingspopup.h"

#include "tapp.h"

#include "cleanupsettingsmodel.h"

// TnzQt includes

#include "toonzqt/tabbar.h"

#include "toonzqt/menubarcommand.h"

#include "toonzqt/checkbox.h"

#include "toonzqt/gutil.h"

#include "toonzqt/doublefield.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/filefield.h"

// TnzLib includes

#include "toonz/txsheethandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txshleveltypes.h"

#include "toonz/tscenehandle.h"

#include "toonz/toonzscene.h"

#include "toonz/tcamera.h"

#include "toonz/levelproperties.h"

#include "toonz/tonionskinmaskhandle.h"

#include "toonz/stage.h"

// TnzCore includes

#include "tsystem.h"

// Qt includes

#include <qhboxlayout></qhboxlayout>

#include <qcombobox></qcombobox>

#include <qlabel></qlabel>

#include <qstackedwidget></qstackedwidget>

#include <qlineedit></qlineedit>

#include <qfiledialog></qfiledialog>

#include <qfile></qfile>

#include <qpushbutton></qpushbutton>

#include <qapplication></qapplication>

#include <qmainwindow></qmainwindow>

#include <qstringlist></qstringlist>

#include <qlistwidget></qlistwidget>

#include <qgroupbox></qgroupbox>

using namespace DVGui;

//*******************************************************************************************

//    Local namespace

//*******************************************************************************************

namespace {

static const int unitsCount = 5, inchIdx = 2;

static const QString units[unitsCount] = {"cm", "mm", "inch", "field", "pixel"};

static const QString rooms[2]          = {"standard", "studioGhibli"};

enum DpiPolicy { DP_ImageDpi, DP_CustomDpi };

}  // namespace

//**********************************************************************************

//    PreferencesPopup::FormatProperties  implementation

//**********************************************************************************

PreferencesPopup::FormatProperties::FormatProperties(PreferencesPopup *parent)

    : DVGui::Dialog(parent, false, true) {

  setWindowTitle(tr("Level Settings by File Format"));

  setModal(true);  // The underlying selected format should not

  // be changed by the user

  // Main layout

  beginVLayout();

  QGridLayout *gridLayout = new QGridLayout;

  int row                 = 0;

  // Key values

  QLabel *nameLabel = new QLabel(tr("Name:"));

  nameLabel->setFixedHeight(20);  // Due to DVGui::Dialog's quirky behavior

  gridLayout->addWidget(nameLabel, row, 0, Qt::AlignRight);

  m_name = new DVGui::LineEdit;

  gridLayout->addWidget(m_name, row++, 1);

  QLabel *regExpLabel = new QLabel(tr("Regular Expression:"));

  gridLayout->addWidget(regExpLabel, row, 0, Qt::AlignRight);

  m_regExp = new DVGui::LineEdit;

  gridLayout->addWidget(m_regExp, row++, 1);

  QLabel *priorityLabel = new QLabel(tr("Priority"));

  gridLayout->addWidget(priorityLabel, row, 0, Qt::AlignRight);

  m_priority = new DVGui::IntLineEdit;

  gridLayout->addWidget(m_priority, row++, 1);

  gridLayout->setRowMinimumHeight(row++, 20);

  // LevelProperties

  m_dpiPolicy = new QComboBox;

  gridLayout->addWidget(m_dpiPolicy, row++, 1);

  m_dpiPolicy->addItem(QObject::tr("Image DPI"));

  m_dpiPolicy->addItem(QObject::tr("Custom DPI"));

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

  gridLayout->addWidget(dpiLabel, row, 0, Qt::AlignRight);

  m_dpi = new DVGui::DoubleLineEdit;

  m_dpi->setRange(1, (std::numeric_limits<double>::max)());  // Tried</double>

                                                             // limits::min(),

                                                             // but input 0 was

  gridLayout->addWidget(m_dpi, row++,

                        1);  // then replaced with something * e^-128

  m_premultiply = new DVGui::CheckBox(LevelSettingsPopup::tr("Premultiply"));

  gridLayout->addWidget(m_premultiply, row++, 1);

  m_whiteTransp =

      new DVGui::CheckBox(LevelSettingsPopup::tr("White As Transparent"));

  gridLayout->addWidget(m_whiteTransp, row++, 1);

  m_doAntialias =

      new DVGui::CheckBox(LevelSettingsPopup::tr("Add Antialiasing"));

  gridLayout->addWidget(m_doAntialias, row++, 1);

  QLabel *antialiasLabel =

      new QLabel(LevelSettingsPopup::tr("Antialias Softness:"));

  gridLayout->addWidget(antialiasLabel, row, 0, Qt::AlignRight);

  m_antialias = new DVGui::IntLineEdit(

      this, 10, 0, 100);  // Tried 1, but then m_doAntialias was forcedly

  gridLayout->addWidget(m_antialias, row++, 1);  // initialized to true

  QLabel *subsamplingLabel = new QLabel(LevelSettingsPopup::tr("Subsampling:"));

  gridLayout->addWidget(subsamplingLabel, row, 0, Qt::AlignRight);

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

  gridLayout->addWidget(m_subsampling, row++, 1);

  addLayout(gridLayout);

  endVLayout();

  // Establish connections

  bool ret = true;

  ret = connect(m_dpiPolicy, SIGNAL(currentIndexChanged(int)),

                SLOT(updateEnabledStatus())) &&

        ret;

  ret =

      connect(m_doAntialias, SIGNAL(clicked()), SLOT(updateEnabledStatus())) &&

      ret;

  assert(ret);

}

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

void PreferencesPopup::FormatProperties::updateEnabledStatus() {

  m_dpi->setEnabled(m_dpiPolicy->currentIndex() == DP_CustomDpi);

  m_antialias->setEnabled(m_doAntialias->isChecked());

}

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

void PreferencesPopup::FormatProperties::setLevelFormat(

    const Preferences::LevelFormat &lf) {

  const LevelOptions &lo = lf.m_options;

  m_name->setText(lf.m_name);

  m_regExp->setText(lf.m_pathFormat.pattern());

  m_priority->setValue(lf.m_priority);

  m_dpiPolicy->setCurrentIndex(

      lo.m_dpiPolicy == LevelOptions::DP_ImageDpi ? DP_ImageDpi : DP_CustomDpi);

  m_dpi->setValue(lo.m_dpi);

  m_premultiply->setChecked(lo.m_premultiply);

  m_whiteTransp->setChecked(lo.m_whiteTransp);

  m_doAntialias->setChecked(lo.m_antialias > 0);

  m_antialias->setValue(lo.m_antialias);

  m_subsampling->setValue(lo.m_subsampling);

  updateEnabledStatus();

}

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

Preferences::LevelFormat PreferencesPopup::FormatProperties::levelFormat()

    const {

  Preferences::LevelFormat lf(m_name->text());

  // Assign key values

  lf.m_pathFormat.setPattern(m_regExp->text());

  lf.m_priority = m_priority->getValue();

  // Assign level format values

  lf.m_options.m_dpiPolicy = (m_dpiPolicy->currentIndex() == DP_ImageDpi)

                                 ? LevelOptions::DP_ImageDpi

                                 : LevelOptions::DP_CustomDpi;

  lf.m_options.m_dpi         = m_dpi->getValue();

  lf.m_options.m_subsampling = m_subsampling->getValue();

  lf.m_options.m_antialias =

      m_doAntialias->isChecked() ? m_antialias->getValue() : 0;

  lf.m_options.m_premultiply = m_premultiply->isChecked();

  lf.m_options.m_whiteTransp = m_whiteTransp->isChecked();

  return lf;

}

//**********************************************************************************

//    PreferencesPopup  implementation

//**********************************************************************************

void PreferencesPopup::onPixelsOnlyChanged(int index) {

  bool enabled = index == Qt::Checked;

  if (enabled) {

    m_pref->setDefLevelDpi(Stage::standardDpi);

    m_pref->setPixelsOnly(true);

    TCamera *camera;

    camera =

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

    TDimension camRes = camera->getRes();

    TDimensionD camSize;

    camSize.lx = camRes.lx / Stage::standardDpi;

    camSize.ly = camRes.ly / Stage::standardDpi;

    camera->setSize(camSize);

    TDimension cleanupRes = CleanupSettingsModel::instance()

                                ->getCurrentParameters()

                                ->m_camera.getRes();

    TDimensionD cleanupSize;

    cleanupSize.lx = cleanupRes.lx / Stage::standardDpi;

    cleanupSize.ly = cleanupRes.ly / Stage::standardDpi;

    CleanupSettingsModel::instance()->getCurrentParameters()->m_camera.setSize(

        cleanupSize);

    m_pref->storeOldUnits();

    if (m_unitOm->currentIndex() != 4) m_unitOm->setCurrentIndex(4);

    if (m_cameraUnitOm->currentIndex() != 4) m_cameraUnitOm->setCurrentIndex(4);

    m_unitOm->setDisabled(true);

    m_cameraUnitOm->setDisabled(true);

    m_defLevelDpi->setDisabled(true);

    m_defLevelDpi->setValue(Stage::standardDpi);

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

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

    m_defLevelWidth->setValue(m_pref->getDefLevelWidth());

    m_defLevelHeight->setValue(m_pref->getDefLevelHeight());

    m_defLevelHeight->setDecimals(0);

    m_defLevelWidth->setDecimals(0);

  } else {

    QString tempUnit;

    int unitIndex;

    tempUnit  = m_pref->getOldUnits();

    unitIndex = m_unitOm->findText(tempUnit);

    m_unitOm->setCurrentIndex(unitIndex);

    tempUnit  = m_pref->getOldCameraUnits();

    unitIndex = m_cameraUnitOm->findText(tempUnit);

    m_cameraUnitOm->setCurrentIndex(unitIndex);

    m_unitOm->setDisabled(false);

    m_cameraUnitOm->setDisabled(false);

    m_pref->setPixelsOnly(false);

    int levelType = m_pref->getDefLevelType();

    bool isRaster = levelType != PLI_XSHLEVEL;

    if (isRaster) {

      m_defLevelDpi->setDisabled(false);

    }

    m_defLevelHeight->setMeasure("level.ly");

    m_defLevelWidth->setMeasure("level.lx");

    m_defLevelWidth->setValue(m_pref->getDefLevelWidth());

    m_defLevelHeight->setValue(m_pref->getDefLevelHeight());

    m_defLevelHeight->setDecimals(4);

    m_defLevelWidth->setDecimals(4);

  }

}

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

void PreferencesPopup::onProjectRootChanged() {

  int index = 0;

  if (m_projectRootStuff->isChecked()) index |= 0x08;

  if (m_projectRootDocuments->isChecked()) index |= 0x04;

  if (m_projectRootDesktop->isChecked()) index |= 0x02;

  if (m_projectRootCustom->isChecked()) index |= 0x01;

  m_pref->setProjectRoot(index);

  if (index & 0x01) {

    m_customProjectRootFileField->show();

    m_customProjectRootLabel->show();

    m_projectRootDirections->show();

  } else {

    m_customProjectRootFileField->hide();

    m_customProjectRootLabel->hide();

    m_projectRootDirections->hide();

  }

}

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

void PreferencesPopup::onCustomProjectRootChanged() {

  QString text = m_customProjectRootFileField->getPath();

  m_pref->setCustomProjectRoot(text.toStdWString());

}

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

void PreferencesPopup::onPixelUnitExternallySelected(bool on) {

  // call slot function onPixelsOnlyChanged() accordingly

  m_pixelsOnlyCB->setCheckState((on) ? Qt::Checked : Qt::Unchecked);

}

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

void PreferencesPopup::onUnitChanged(int index) {

  if (index == 4 && m_pixelsOnlyCB->isChecked() == false) {

    m_pixelsOnlyCB->setCheckState(Qt::Checked);

  }

  m_pref->setUnits(::units[index].toStdString());

}

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

void PreferencesPopup::onCameraUnitChanged(int index) {

  if (index == 4 && m_pixelsOnlyCB->isChecked() == false) {

    m_pixelsOnlyCB->setChecked(true);

  }

  m_pref->setCameraUnits(::units[index].toStdString());

}

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

void PreferencesPopup::onRoomChoiceChanged(int index) {

  TApp::instance()->writeSettings();

  m_pref->setCurrentRoomChoice(index);

}

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

void PreferencesPopup::onImportPolicyChanged(int index) {

  m_pref->setDefaultImportPolicy(index);

}

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

void PreferencesPopup::onImportPolicyExternallyChanged(int policy) {

  // call slot function onImportPolicyChanged() accordingly

  m_importPolicy->setCurrentIndex(policy);

}

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

void PreferencesPopup::onScanLevelTypeChanged(const QString &text) {

  m_pref->setScanLevelType(text.toStdString());

}

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

void PreferencesPopup::onMinuteChanged() {

  m_pref->setAutosavePeriod(m_minuteFld->getValue());

}

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

void PreferencesPopup::onChunkSizeChanged() {

  m_pref->setDefaultTaskChunkSize(m_chunkSizeFld->getValue());

}

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

void PreferencesPopup::onBlankCountChanged() {

  if (m_blanksCount && m_blankColor)

    m_pref->setBlankValues(m_blanksCount->getValue(), m_blankColor->getColor());

  TApp::instance()->getCurrentScene()->notifyPreferenceChanged("BlankCount");

}

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

void PreferencesPopup::onOnionPaperThicknessChanged() {

  if (m_onionPaperThickness) {

    m_pref->setOnionPaperThickness(m_onionPaperThickness->getValue());

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

  }

}

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

void PreferencesPopup::onBlankColorChanged(const TPixel32 &, bool isDragging) {

  if (isDragging) return;

  if (m_blanksCount && m_blankColor)

    m_pref->setBlankValues(m_blanksCount->getValue(), m_blankColor->getColor());

  TApp::instance()->getCurrentScene()->notifyPreferenceChanged("BlankColor");

}

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

void PreferencesPopup::onAutomaticSVNRefreshChanged(int index) {

  m_pref->enableAutomaticSVNFolderRefresh(index == Qt::Checked);

}

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

void PreferencesPopup::onSVNEnabledChanged(int index) {

  bool enabled = index == Qt::Checked;

  if (enabled) {

    if (VersionControl::instance()->testSetup())

      m_pref->enableSVN(true);

    else {

      if (m_enableVersionControl) m_enableVersionControl->setChecked(false);

    }

  } else

    m_pref->enableSVN(false);

}

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

void invalidateIcons();  // implemented in sceneviewer.cpp; in which fucking

                         // header  I can put this declaration?!

void PreferencesPopup::onTranspCheckDataChanged(const TPixel32 &,

                                                bool isDragging) {

  if (isDragging) return;

  m_pref->setTranspCheckData(m_transpCheckBgColor->getColor(),

                             m_transpCheckInkColor->getColor(),

                             m_transpCheckPaintColor->getColor());

  invalidateIcons();

}

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

void PreferencesPopup::onOnionDataChanged(const TPixel32 &, bool isDragging) {

  if (isDragging) return;

  bool inksOnly            = false;

  if (m_inksOnly) inksOnly = m_inksOnly->isChecked();

  m_pref->setOnionData(m_frontOnionColor->getColor(),

                       m_backOnionColor->getColor(), inksOnly);

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

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

}

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

void PreferencesPopup::onOnionDataChanged(int) {

  bool inksOnly            = false;

  if (m_inksOnly) inksOnly = m_inksOnly->isChecked();

  m_pref->setOnionData(m_frontOnionColor->getColor(),

                       m_backOnionColor->getColor(), inksOnly);

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

}

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

void PreferencesPopup::onViewValuesChanged() {

  m_pref->setViewValues(m_viewShrink->getValue(), m_viewStep->getValue());

}

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

void PreferencesPopup::onIconSizeChanged() {

  TDimension size(m_iconSizeLx->getValue(), m_iconSizeLy->getValue());

  if (m_pref->getIconSize() == size) return;

  m_pref->setIconSize(size);

}

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

void PreferencesPopup::onAutoExposeChanged(int index) {

  m_pref->enableAutoExpose(index == Qt::Checked);

}

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

void PreferencesPopup::onIgnoreImageDpiChanged(int index) {

  m_pref->setIgnoreImageDpi(index == Qt::Checked);

}

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

void PreferencesPopup::onSubsceneFolderChanged(int index) {

  m_pref->enableSubsceneFolder(index == Qt::Checked);

}

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

void PreferencesPopup::onViewGeneratedMovieChanged(int index) {

  m_pref->enableGeneratedMovieView(index == Qt::Checked);

}

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

void PreferencesPopup::onXsheetStepChanged() {

  m_pref->setXsheetStep(m_xsheetStep->getValue());

}

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

void PreferencesPopup::onXsheetAutopanChanged(int index) {

  m_pref->enableXsheetAutopan(index == Qt::Checked);

}

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

void PreferencesPopup::onIgnoreAlphaonColumn1Changed(int index) {

  m_pref->enableIgnoreAlphaonColumn1(index == Qt::Checked);

}

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

void PreferencesPopup::onRewindAfterPlayback(int index) {

  m_pref->enableRewindAfterPlayback(index == Qt::Checked);

}

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

void PreferencesPopup::onFitToFlipbook(int index) {

  m_pref->enableFitToFlipbook(index == Qt::Checked);

}

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

void PreferencesPopup::onPreviewAlwaysOpenNewFlip(int index) {

  m_pref->enablePreviewAlwaysOpenNewFlip(index == Qt::Checked);

}

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

void PreferencesPopup::onAskForOverrideRender(int index) {

  m_pref->setAskForOverrideRender(index == Qt::Checked);

}

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

void PreferencesPopup::onRasterOptimizedMemoryChanged(int index) {

  if (m_pref->isRasterOptimizedMemory() == (index == Qt::Checked)) return;

  m_pref->enableRasterOptimizedMemory(index == Qt::Checked);

}

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

void PreferencesPopup::onGetFillOnlySavebox(int index) {

  if (m_pref->getFillOnlySavebox() == (index == Qt::Checked)) return;

  m_pref->setFillOnlySavebox(index == Qt::Checked);

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

}

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

void PreferencesPopup::onSaveUnpaintedInCleanupChanged(int index) {

  if (m_pref->isSaveUnpaintedInCleanupEnable() == (index == Qt::Checked))

    return;

  m_pref->enableSaveUnpaintedInCleanup(index == Qt::Checked);

}

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

void PreferencesPopup::onMinimizeSaveboxAfterEditing(int index) {

  m_pref->enableMinimizeSaveboxAfterEditing(index == Qt::Checked);

}

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

void PreferencesPopup::onDefaultViewerChanged(int index) {

  m_pref->enableDefaultViewer(index == Qt::Checked);

}

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

void PreferencesPopup::onAutoSaveChanged(bool on) {

  m_pref->enableAutosave(on);

  if (on && !m_autoSaveSceneCB->isChecked() &&

      !m_autoSaveOtherFilesCB->isChecked()) {

    m_autoSaveSceneCB->setChecked(true);

    m_autoSaveOtherFilesCB->setChecked(true);

  }

}

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

void PreferencesPopup::onAutoSaveSceneChanged(int index) {

  m_pref->enableAutosaveScene(index == Qt::Checked);

  if (!m_autoSaveOtherFilesCB->isChecked() && index == Qt::Unchecked) {

    m_autoSaveGroup->setChecked(false);

  }

}

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

void PreferencesPopup::onAutoSaveOtherFilesChanged(int index) {

  m_pref->enableAutosaveOtherFiles(index == Qt::Checked);

  if (!m_autoSaveSceneCB->isChecked() && index == Qt::Unchecked) {

    m_autoSaveGroup->setChecked(false);

  }

}

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

void PreferencesPopup::onStartupPopupChanged(int index) {

  m_pref->enableStartupPopup(index == Qt::Checked);

}

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

void PreferencesPopup::onKeyframeTypeChanged(int index) {

  m_pref->setKeyframeType(index + 2);

}

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

void PreferencesPopup::onAutocreationTypeChanged(int index) {

  m_pref->setAutocreationType(index);

}

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

void PreferencesPopup::onAnimationStepChanged() {

  m_pref->setAnimationStep(m_animationStepField->getValue());

}

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

void PreferencesPopup::onLanguageTypeChanged(int index) {

  m_pref->setCurrentLanguage(index);

  QString currentLanguage = m_pref->getCurrentLanguage();

}

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

void PreferencesPopup::onMoveCurrentFrameChanged(int index) {

  m_pref->enableMoveCurrent(index == Qt::Checked);

}

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

void PreferencesPopup::onReplaceAfterSaveLevelAsChanged(int index) {

  m_pref->enableReplaceAfterSaveLevelAs(index == Qt::Checked);

}

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

void PreferencesPopup::setViewerBgColor(const TPixel32 &color,

                                        bool isDragging) {

  m_pref->setViewerBGColor(color, isDragging);

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

}

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

void PreferencesPopup::setPreviewBgColor(const TPixel32 &color,

                                         bool isDragging) {

  m_pref->setPreviewBGColor(color, isDragging);

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

}

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

void PreferencesPopup::setChessboardColor1(const TPixel32 &color,

                                           bool isDragging) {

  m_pref->setChessboardColor1(color, isDragging);

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

}

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

void PreferencesPopup::setChessboardColor2(const TPixel32 &color,

                                           bool isDragging) {

  m_pref->setChessboardColor2(color, isDragging);

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

}

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

void PreferencesPopup::onColumnIconChange(const QString &value) {

  m_pref->setColumnIconLoadingPolicy(value == tr("At Once")

                                         ? Preferences::LoadAtOnce

                                         : Preferences::LoadOnDemand);

}

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

void PreferencesPopup::onOnionSkinVisibilityChanged(int index) {

  m_pref->enableOnionSkin(index == Qt::Checked);

  m_frontOnionColor->setEnabled(index == Qt::Checked);

  m_backOnionColor->setEnabled(index == Qt::Checked);

  m_inksOnly->setEnabled(index == Qt::Checked);

  m_onionPaperThickness->setEnabled(index == Qt::Checked);

  OnionSkinMask osm =

      TApp::instance()->getCurrentOnionSkin()->getOnionSkinMask();

  osm.enable(index == Qt::Checked);

  TApp::instance()->getCurrentOnionSkin()->setOnionSkinMask(osm);

  TApp::instance()->getCurrentOnionSkin()->notifyOnionSkinMaskChanged();

}

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

void PreferencesPopup::onOnionSkinDuringPlaybackChanged(int index) {

  m_pref->setOnionSkinDuringPlayback(index == Qt::Checked);

}

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

void PreferencesPopup::onActualPixelOnSceneModeChanged(int index) {

  m_pref->enableActualPixelViewOnSceneEditingMode(index == Qt::Checked);

}

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

void PreferencesPopup::onMultiLayerStylePickerChanged(int index) {

  m_pref->enableMultiLayerStylePicker(index == Qt::Checked);

}

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

void PreferencesPopup::onLevelNameOnEachMarkerChanged(int index) {

  m_pref->enableLevelNameOnEachMarker(index == Qt::Checked);

}

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

void PreferencesPopup::onInitialLoadTlvCachingBehaviorChanged(int index) {

  m_pref->setInitialLoadTlvCachingBehavior(index);

}

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

void PreferencesPopup::onViewerZoomCenterChanged(int index) {

  m_pref->setViewerZoomCenter(index);

}

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

void PreferencesPopup::onRemoveSceneNumberFromLoadedLevelNameChanged(

    int index) {

  m_pref->enableRemoveSceneNumberFromLoadedLevelName(index == Qt::Checked);

}

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

void PreferencesPopup::onShowRasterImageDarkenBlendedInViewerChanged(

    int index) {

  m_pref->enableShowRasterImagesDarkenBlendedInViewer(index == Qt::Checked);

}

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

void PreferencesPopup::onShowFrameNumberWithLettersChanged(int index) {

  m_pref->enableShowFrameNumberWithLetters(index == Qt::Checked);

}

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

void PreferencesPopup::onPaletteTypeForRasterColorModelChanged(int index) {

  m_pref->setPaletteTypeOnLoadRasterImageAsColorModel(index);

}

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

void PreferencesPopup::onShowKeyframesOnCellAreaChanged(int index) {

  m_pref->enableShowKeyframesOnXsheetCellArea(index == Qt::Checked);

}

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

void PreferencesPopup::onStyleSheetTypeChanged(int index) {

  m_pref->setCurrentStyleSheet(index);

  QApplication::setOverrideCursor(Qt::WaitCursor);

  QString currentStyle = m_pref->getCurrentStyleSheet();

  qApp->setStyleSheet(currentStyle);

  QApplication::restoreOverrideCursor();

}

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

/*

QWidget* PreferencesPopup::create(const QString &lbl, bool def, const char*slot)

{

  DVGui::CheckBox* cb = new DVGui::CheckBox(lbl);

  cb->setMaximumHeight(WidgetHeight);

  cb->setChecked(def);

  bool ret = connect(cb, SIGNAL(stateChanged (int)), slot);

  assert(ret);

  return cb;

}

*/

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

void PreferencesPopup::onUndoMemorySizeChanged() {

  int value = m_undoMemorySize->getValue();

  m_pref->setUndoMemorySize(value);

}

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

void PreferencesPopup::onDragCellsBehaviourChanged(int index) {

  m_pref->setDragCellsBehaviour(index);

}

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

#ifdef LINETEST

void PreferencesPopup::onLineTestFpsCapture(int index) {

  if (index == 0) m_pref->setLineTestFpsCapture(0);

  if (index == 1)

    m_pref->setLineTestFpsCapture(25);

  else if (index == 2)

    m_pref->setLineTestFpsCapture(30);

}

#endif

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

void PreferencesPopup::onLevelsBackupChanged(int index) {

  m_pref->enableLevelsBackup(index == Qt::Checked);

}

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

void PreferencesPopup::onSceneNumberingChanged(int index) {

  m_pref->enableSceneNumbering(index == Qt::Checked);

}

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

void PreferencesPopup::onDefLevelTypeChanged(int index) {

  if (0 <= index && index < m_defLevelType->count()) {

    int levelType = m_defLevelType->itemData(index).toInt();

    m_pref->setDefLevelType(levelType);

    bool isRaster = levelType != PLI_XSHLEVEL;

    m_defLevelWidth->setEnabled(isRaster);

    m_defLevelHeight->setEnabled(isRaster);

    if (!m_pixelsOnlyCB->isChecked()) m_defLevelDpi->setEnabled(isRaster);

  }

}

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

void PreferencesPopup::onDefLevelParameterChanged() {

  double w   = m_defLevelWidth->getValue();

  double h   = m_defLevelHeight->getValue();

  double dpi = m_defLevelDpi->getValue();

  m_pref->setDefLevelWidth(w);

  m_pref->setDefLevelHeight(h);

  m_pref->setDefLevelDpi(dpi);

}

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

void PreferencesPopup::onVectorSnappingTargetChanged(int index) {

  m_vectorSnappingTargetCB->setCurrentIndex(index);

  m_pref->setVectorSnappingTarget(index);

}

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

void PreferencesPopup::rebuildFormatsList() {

  const Preferences &prefs = *Preferences::instance();

  m_levelFormatNames->clear();

  int lf, lfCount = prefs.levelFormatsCount();

  for (lf = 0; lf != lfCount; ++lf)

    m_levelFormatNames->addItem(prefs.levelFormat(lf).m_name);

  m_editLevelFormat->setEnabled(m_levelFormatNames->count() > 0);

}

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

void PreferencesPopup::onAddLevelFormat() {

  bool ok            = true;

  QString formatName = DVGui::getText(tr("New Level Format"),