#include "preferencespopup.h"

// Tnz6 includes

#include "menubarcommandids.h"

#include "versioncontrol.h"

#include "levelsettingspopup.h"

#include "tapp.h"

#include "cleanupsettingsmodel.h"

#include "formatsettingspopups.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"

#include "toonzqt/lutcalibrator.h"

// TnzLib includes

#include "toonz/txsheethandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txshleveltypes.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"

#include "tfont.h"

#include "kis_tablet_support_win8.h"

// Qt includes

#include <qhboxlayout></qhboxlayout>

#include <qcombobox></qcombobox>

#include <qfontcombobox></qfontcombobox>

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

#include <qkeysequence></qkeysequence>

using namespace DVGui;

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

//    Local namespace

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

namespace {

enum DpiPolicy { DP_ImageDpi, DP_CustomDpi };

inline void setupLayout(QGridLayout* lay, int margin = 15) {

  lay->setMargin(margin);

  lay->setHorizontalSpacing(5);

  lay->setVerticalSpacing(10);

  lay->setColumnStretch(2, 1);

}

QGridLayout* insertGroupBox(const QString label, QGridLayout* layout) {

  QGroupBox* box   = new QGroupBox(label);

  QGridLayout* lay = new QGridLayout();

  setupLayout(lay, 5);

  box->setLayout(lay);

  layout->addWidget(box, layout->rowCount(), 0, 1, 3);

  return lay;

}

inline TPixel colorToTPixel(const QColor& color) {

  return TPixel(color.red(), color.green(), color.blue(), color.alpha());

}

}  // namespace

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

SizeField::SizeField(QSize min, QSize max, QSize value, QWidget* parent)

    : QWidget(parent) {

  m_fieldX =

      new DVGui::IntLineEdit(this, value.width(), min.width(), max.width());

  m_fieldY =

      new DVGui::IntLineEdit(this, value.height(), min.height(), max.height());

  QHBoxLayout* lay = new QHBoxLayout();

  lay->setSpacing(5);

  lay->setMargin(0);

  lay->addWidget(m_fieldX, 1);

  lay->addWidget(new QLabel("x", this), 0);

  lay->addWidget(m_fieldY, 1);

  lay->addStretch(1);

  setLayout(lay);

  bool ret = true;

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

                            SIGNAL(editingFinished()));

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

                            SIGNAL(editingFinished()));

  assert(ret);

}

QSize SizeField::getValue() const {

  return QSize(m_fieldX->getValue(), m_fieldY->getValue());

}

void SizeField::setValue(const QSize& size) {

  m_fieldX->setValue(size.width());

  m_fieldY->setValue(size.height());

}

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

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

  QLabel* gammaLabel = new QLabel(LevelSettingsPopup::tr("Color Space Gamma:"));

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

  m_colorSpaceGamma = new DVGui::DoubleLineEdit(this);

  m_colorSpaceGamma->setRange(0.1, 10.);

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

  addLayout(gridLayout);

  endVLayout();

  // Establish connections

  bool ret = true;

  // enable gamma field only when the regexp field contains ".exr"

  ret = connect(m_regExp, SIGNAL(editingFinished()),

                SLOT(updateEnabledStatus())) &&

        ret;

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

  // enable gamma field only when the regexp field contains ".exr"

  m_colorSpaceGamma->setEnabled(m_regExp->text().contains(".exr"));

}

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

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

  m_colorSpaceGamma->setValue(lo.m_colorSpaceGamma);

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

  if (m_colorSpaceGamma->isEnabled())

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

  return lf;

}

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

//    PreferencesPopup::AdditionalStyleEdit  implementation

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

PreferencesPopup::AdditionalStyleEdit::AdditionalStyleEdit(

    PreferencesPopup* parent)

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

  setWindowTitle(tr("Additional Style Sheet"));

  setModal(true);

  m_edit                   = new QTextEdit(this);

  QPushButton* okButton    = new QPushButton(tr("OK"), this);

  QPushButton* applyButton = new QPushButton(tr("Apply"), this);

  QPushButton* closeButton = new QPushButton(tr("Close"), this);

  QString placeHolderTxt(

      "/* Type additional style sheet here to customize GUI. \n"

      "   Example: To enlarge the Style Editor buttons */\n\n"

      "#StyleEditor #bottomWidget QPushButton{ \n  padding : 13 21; \n }");

  m_edit->setPlaceholderText(placeHolderTxt);

  m_edit->setAcceptRichText(false);

  m_topLayout->addWidget(m_edit);

  addButtonBarWidget(okButton, applyButton, closeButton);

  bool ret = true;

  ret      = ret && connect(okButton, SIGNAL(pressed()), this, SLOT(onOK()));

  ret = ret && connect(applyButton, SIGNAL(pressed()), this, SLOT(onApply()));

  ret = ret && connect(closeButton, SIGNAL(pressed()), this, SLOT(close()));

}

void PreferencesPopup::AdditionalStyleEdit::showEvent(QShowEvent*) {

  m_edit->setPlainText(Preferences::instance()->getAdditionalStyleSheet());

}

void PreferencesPopup::AdditionalStyleEdit::onOK() {

  onApply();

  close();

}

void PreferencesPopup::AdditionalStyleEdit::onApply() {

  Preferences::instance()->setValue(additionalStyleSheet,

                                    m_edit->toPlainText());

  emit additionalSheetEdited();

}

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

//   PreferencesPopup::Display30bitCheckerView  implementation

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

PreferencesPopup::Display30bitChecker::GLView::GLView(QWidget* parent,

                                                      bool is30bit)

    : QOpenGLWidget(parent), m_is30bit(is30bit) {

  setFixedSize(500, 100);

  if (m_is30bit) setTextureFormat(TGL_TexFmt10);

}

void PreferencesPopup::Display30bitChecker::GLView::initializeGL() {

  initializeOpenGLFunctions();

  glClear(GL_COLOR_BUFFER_BIT);

}

void PreferencesPopup::Display30bitChecker::GLView::resizeGL(int width,

                                                             int height) {

  glViewport(0, 0, width, height);

  glMatrixMode(GL_PROJECTION);

  glLoadIdentity();

  glOrtho(0, 1, 0, 1, -1, 1);

  glMatrixMode(GL_MODELVIEW);

  glLoadIdentity();

}

void PreferencesPopup::Display30bitChecker::GLView::paintGL() {

  initializeOpenGLFunctions();

  glPushMatrix();

  glBegin(GL_QUADS);

  glColor3d(0.071, 0.153, 0.0);

  glVertex3d(0, 0, 0);

  glVertex3d(0, 1, 0);

  glColor3d(0.141, 0.239, 0.0);

  glVertex3d(1, 1, 0);

  glVertex3d(1, 0, 0);

  glEnd();

  glPopMatrix();

}

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

PreferencesPopup::Display30bitChecker::Display30bitChecker(

    PreferencesPopup* parent)

    : QDialog(parent) {

  setModal(true);

  m_currentDefaultFormat = QSurfaceFormat::defaultFormat();

  setWindowTitle(tr("Check 30bit display availability"));

  QSurfaceFormat sFmt = m_currentDefaultFormat;

  sFmt.setRedBufferSize(10);

  sFmt.setGreenBufferSize(10);

  sFmt.setBlueBufferSize(10);

  sFmt.setAlphaBufferSize(2);

  QSurfaceFormat::setDefaultFormat(sFmt);

  GLView* view8bit      = new GLView(this, false);

  GLView* view10bit     = new GLView(this, true);

  QPushButton* closeBtn = new QPushButton(tr("Close"), this);

  QString infoLabel     = tr(

      "If the lower gradient looks smooth and has no banding compared to the upper gradient,\n\

30bit display is available in the current configuration.");

  QVBoxLayout* lay = new QVBoxLayout();

  lay->setMargin(10);

  lay->setSpacing(10);

  {

    lay->addWidget(view8bit);

    lay->addWidget(view10bit);

    lay->addWidget(new QLabel(infoLabel, this));

    lay->addWidget(closeBtn, 0, Qt::AlignCenter);

  }

  setLayout(lay);

  lay->setSizeConstraint(QLayout::SetFixedSize);

  connect(closeBtn, SIGNAL(clicked()), this, SLOT(accept()));

}

PreferencesPopup::Display30bitChecker::~Display30bitChecker() {

  QSurfaceFormat::setDefaultFormat(m_currentDefaultFormat);

}

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

//    PreferencesPopup  implementation

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

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

}

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

QList<comboboxitem> PreferencesPopup::buildFontStyleList() const {</comboboxitem>

  TFontManager* instance = TFontManager::instance();

  std::vector<std::wstring> typefaces;</std::wstring>

  std::vector<std::wstring>::iterator it;</std::wstring>

  QString font  = m_pref->getStringValue(interfaceFont);

  QString style = m_pref->getStringValue(interfaceFontStyle);

  try {

    instance->loadFontNames();

    instance->setFamily(font.toStdWString());

    instance->getAllTypefaces(typefaces);

  } catch (TFontCreationError&) {

    it = typefaces.begin();

    typefaces.insert(it, style.toStdWString());

  }

  QList<comboboxitem> styleList;</comboboxitem>

  for (it = typefaces.begin(); it != typefaces.end(); ++it)

    styleList.append(ComboBoxItem(QString::fromStdWString(*it),

                                  QString::fromStdWString(*it)));

  return styleList;

}

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

void PreferencesPopup::onAutoSaveChanged() {

  bool on = getUI<qgroupbox*>(autosaveEnabled)->isChecked();</qgroupbox*>

  if (!on) return;

  CheckBox* autoSaveSceneCB      = getUI<checkbox*>(autosaveSceneEnabled);</checkbox*>

  CheckBox* autoSaveOtherFilesCB = getUI<checkbox*>(autosaveOtherFilesEnabled);</checkbox*>

  if (!autoSaveSceneCB->isChecked() && !autoSaveOtherFilesCB->isChecked()) {

    autoSaveSceneCB->setChecked(true);

    autoSaveOtherFilesCB->setChecked(true);

  }

}

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

void PreferencesPopup::onAutoSaveOptionsChanged() {

  bool autoSaveScene = getUI<checkbox*>(autosaveSceneEnabled)->isChecked();</checkbox*>

  bool autoSaveOtherFiles =

      getUI<checkbox*>(autosaveOtherFilesEnabled)->isChecked();</checkbox*>

  if (!autoSaveScene && !autoSaveOtherFiles) {

    getUI<qgroupbox*>(autosaveEnabled)->setChecked(false);</qgroupbox*>

  }

}

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

void PreferencesPopup::onWatchFileSystemClicked() {

  // emit signal to update behavior of the File browser

  TApp::instance()->getCurrentScene()->notifyPreferenceChanged(

      "WatchFileSystem");

}

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

void PreferencesPopup::onPathAliasPriorityChanged() {

  TApp::instance()->getCurrentScene()->notifyPreferenceChanged(

      "PathAliasPriority");

}

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

void PreferencesPopup::onStyleSheetTypeChanged() {

  QApplication::setOverrideCursor(Qt::WaitCursor);

  QString currentStyle = m_pref->getCurrentStyleSheet();

  qApp->setStyleSheet(currentStyle);

  QApplication::restoreOverrideCursor();

}

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

void PreferencesPopup::onIconThemeChanged() {

  // Switch between dark or light icons

  QIcon::setThemeName(Preferences::instance()->getIconTheme() ? "dark"

                                                              : "light");

  // qDebug() << "Icon theme name (preference switch):" << QIcon::themeName();

}

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

void PreferencesPopup::onPixelsOnlyChanged() {

  QComboBox* unitOm           = getUI<qcombobox*>(linearUnits);</qcombobox*>

  QComboBox* cameraUnitOm     = getUI<qcombobox*>(cameraUnits);</qcombobox*>

  DoubleLineEdit* defLevelDpi = getUI<doublelineedit*>(DefLevelDpi);</doublelineedit*>

  MeasuredDoubleLineEdit* defLevelWidth =

      getUI<measureddoublelineedit*>(DefLevelWidth);</measureddoublelineedit*>

  MeasuredDoubleLineEdit* defLevelHeight =

      getUI<measureddoublelineedit*>(DefLevelHeight);</measureddoublelineedit*>

  bool isPixel = m_pref->getBoolValue(pixelsOnly);

  if (isPixel) {

    m_pref->setValue(DefLevelDpi, Stage::standardDpi);

    TCamera* 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 (unitOm->currentText() != tr("pixel"))

      unitOm->setCurrentText(tr("pixel"));

    if (cameraUnitOm->currentText() != tr("pixel"))

      cameraUnitOm->setCurrentText(tr("pixel"));

    unitOm->setDisabled(true);

    cameraUnitOm->setDisabled(true);

    defLevelDpi->setDisabled(true);

    defLevelDpi->setValue(Stage::standardDpi);

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

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

    defLevelWidth->setValue(m_pref->getDoubleValue(DefLevelWidth));

    defLevelHeight->setValue(m_pref->getDoubleValue(DefLevelHeight));

    defLevelHeight->setDecimals(0);

    defLevelWidth->setDecimals(0);

  } else {

    QString tempUnit = m_pref->getStringValue(oldUnits);

    unitOm->setCurrentIndex(unitOm->findData(tempUnit));

    tempUnit = m_pref->getStringValue(oldCameraUnits);

    cameraUnitOm->setCurrentIndex(cameraUnitOm->findData(tempUnit));

    unitOm->setDisabled(false);

    cameraUnitOm->setDisabled(false);

    bool isRaster = m_pref->getIntValue(DefLevelType) != PLI_XSHLEVEL;

    if (isRaster) {

      defLevelDpi->setDisabled(false);

    }

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

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

    defLevelWidth->setValue(m_pref->getDoubleValue(DefLevelWidth));

    defLevelHeight->setValue(m_pref->getDoubleValue(DefLevelHeight));

    defLevelHeight->setDecimals(4);

    defLevelWidth->setDecimals(4);

  }

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

}

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

void PreferencesPopup::onUnitChanged() {

  CheckBox* pixelsOnlyCB = getUI<checkbox*>(pixelsOnly);</checkbox*>

  if (!pixelsOnlyCB->isChecked() &&

      (m_pref->getStringValue(linearUnits) == "pixel" ||

       m_pref->getStringValue(cameraUnits) == "pixel")) {

    pixelsOnlyCB->setCheckState(Qt::Checked);

  }

}

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

void PreferencesPopup::beforeRoomChoiceChanged() {

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

}

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

void PreferencesPopup::onColorCalibrationChanged() {

  LutManager::instance()->update();

  TApp::instance()->getCurrentScene()->notifyPreferenceChanged(

      "ColorCalibration");

}

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

void PreferencesPopup::onDefLevelTypeChanged() {

  bool isRaster = m_pref->getIntValue(DefLevelType) != PLI_XSHLEVEL &&

                  !m_pref->getBoolValue(newLevelSizeToCameraSizeEnabled);

  m_controlIdMap.key(DefLevelWidth)->setEnabled(isRaster);

  m_controlIdMap.key(DefLevelHeight)->setEnabled(isRaster);

  if (!m_pref->getBoolValue(pixelsOnly))

    m_controlIdMap.key(DefLevelDpi)->setEnabled(isRaster);

}

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

void PreferencesPopup::onUseNumpadForSwitchingStylesClicked() {

  bool checked = m_pref->getBoolValue(useNumpadForSwitchingStyles);

  if (checked) {

    // check if there are any commands with numpadkey shortcuts

    CommandManager* cm = CommandManager::instance();

    QList<qaction*> actionsList;</qaction*>

    for (int key = Qt::Key_0; key <= Qt::Key_9; key++) {

      std::string str = QKeySequence(key).toString().toStdString();

      QAction* action = cm->getActionFromShortcut(str);

      if (action) actionsList.append(action);

    }

    QAction* tabAction = cm->getActionFromShortcut("Tab");

    if (tabAction) actionsList.append(tabAction);

    tabAction = cm->getActionFromShortcut("Shift+Tab");

    if (tabAction) actionsList.append(tabAction);

    // if there are actions using numpad shortcuts, notify to release them.

    if (!actionsList.isEmpty()) {

      QString msgStr =

          tr("Numpad keys are assigned to the following commands.\nIs it OK to "

             "release these shortcuts?");

      for (int a = 0; a < actionsList.size(); a++) {

        msgStr += "\n" + actionsList.at(a)->iconText() + "  (" +

                  actionsList.at(a)->shortcut().toString() + ")";

      }

      int ret = DVGui::MsgBox(msgStr, tr("OK"), tr("Cancel"), 1);

      if (ret == 2 || ret == 0) {  // canceled

        getUI<checkbox*>(useNumpadForSwitchingStyles)->setChecked(false);</checkbox*>

        return;

      } else {  // accepted, then release shortcuts

        for (int a = 0; a < actionsList.size(); a++)

          cm->setShortcut(actionsList[a], "");

      }

    }

  }

  // emit signal to update Palette and Viewer

  TApp::instance()->getCurrentScene()->notifyPreferenceChanged(

      "NumpadForSwitchingStyles");

}

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

void PreferencesPopup::onLevelBasedToolsDisplayChanged() {

  TApp::instance()->getCurrentScene()->notifyPreferenceChanged(

      "ToolbarDisplay");

}

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

void PreferencesPopup::onShowKeyframesOnCellAreaChanged() {

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

}

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

void PreferencesPopup::onShowXSheetToolbarClicked() {

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

}

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

void PreferencesPopup::onModifyExpressionOnMovingReferencesChanged() {

  TApp::instance()->getCurrentScene()->notifyPreferenceChanged(

      "modifyExpressionOnMovingReferences");

}

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

void PreferencesPopup::onBlankCountChanged() {

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

}

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

void PreferencesPopup::onBlankColorChanged() {

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

}

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

void PreferencesPopup::onOnionSkinVisibilityChanged() {

  bool onionActive = m_pref->getBoolValue(onionSkinEnabled);

  m_controlIdMap.key(onionPaperThickness)->setEnabled(onionActive);

  m_controlIdMap.key(backOnionColor)->setEnabled(onionActive);

  m_controlIdMap.key(frontOnionColor)->setEnabled(onionActive);

  m_controlIdMap.key(onionInksOnly)->setEnabled(onionActive);

  OnionSkinMask osm =

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

  osm.enable(onionActive);

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

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

}

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

void PreferencesPopup::onOnionColorChanged() {

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

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

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

}

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

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

                         // header  I can put this declaration?!

void PreferencesPopup::onTranspCheckDataChanged() { invalidateIcons(); }

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

void PreferencesPopup::onChessboardChanged() {

  CommonChessboard::instance()->update();

}

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

void PreferencesPopup::onSVNEnabledChanged() {

  if (m_pref->getBoolValue(SVNEnabled)) {

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

      getUI<checkbox*>(SVNEnabled)->setChecked(false);</checkbox*>

  }

}

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

void PreferencesPopup::notifySceneChanged() {

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

}

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

void PreferencesPopup::onAutoSaveExternallyChanged() {

  QGroupBox* autoSaveGroup = getUI<qgroupbox*>(autosaveEnabled);</qgroupbox*>

  autoSaveGroup->setChecked(m_pref->getBoolValue(autosaveEnabled));

}

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

void PreferencesPopup::onAutoSavePeriodExternallyChanged() {

  IntLineEdit* minuteFld = getUI<intlineedit*>(autosavePeriod);</intlineedit*>

  minuteFld->setValue(m_pref->getIntValue(autosavePeriod));

}

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

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->setValue(projectRoot, index);

}

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

void PreferencesPopup::onEditAdditionalStyleSheet() {

  if (!m_additionalStyleEdit) {

    m_additionalStyleEdit = new AdditionalStyleEdit(this);

    bool ret = connect(m_additionalStyleEdit, SIGNAL(additionalSheetEdited()),

                       this, SLOT(onAdditionalStyleSheetEdited()));

    assert(ret);

  }

  m_additionalStyleEdit->show();

}

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

void PreferencesPopup::onAdditionalStyleSheetEdited() {

  onStyleSheetTypeChanged();

}

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

void PreferencesPopup::onPixelUnitExternallySelected(bool on) {

  CheckBox* pixelsOnlyCB = getUI<checkbox*>(pixelsOnly);</checkbox*>

  // call slot function onPixelsOnlyChanged() accordingly

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

}

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

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

  m_pref->setValue(interfaceFont, text);

  // rebuild font styles

  QComboBox* fontStyleCombo         = getUI<qcombobox*>(interfaceFontStyle);</qcombobox*>

  QString oldTypeface               = fontStyleCombo->currentText();

  QList<comboboxitem> newStyleItems = buildFontStyleList();</comboboxitem>

  fontStyleCombo->clear();

  for (ComboBoxItem& item : newStyleItems)

    fontStyleCombo->addItem(item.first, item.second);

  if (!oldTypeface.isEmpty()) {

    int newIndex = fontStyleCombo->findText(oldTypeface);

    if (newIndex < 0) newIndex = 0;

    fontStyleCombo->setCurrentIndex(newIndex);

  }

  if (text.contains("Comic Sans"))

    DVGui::warning(tr("Life is too short for Comic Sans"));

  if (text.contains("Wingdings"))

    DVGui::warning(tr("Good luck.  You're on your own from here."));

}

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

void PreferencesPopup::onLutPathChanged() {

  FileField* lutPathFileField = getUI<filefield*>(colorCalibrationLutPaths);</filefield*>

  m_pref->setColorCalibrationLutPath(LutManager::instance()->getMonitorName(),

                                     lutPathFileField->getPath());

  onColorCalibrationChanged();

}

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

void PreferencesPopup::onCheck30bitDisplay() {

  Display30bitChecker checker(this);

  checker.exec();

}

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

void PreferencesPopup::onAddLevelFormat() {

  bool ok            = true;

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

                                      tr("Assign the new level format name:"),

                                      tr("New Format"), &ok);

  if (ok) {

    int formatIdx = Preferences::instance()->addLevelFormat(formatName);

    rebuildFormatsList();

    m_levelFormatNames->setCurrentIndex(formatIdx);

  }

}

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

void PreferencesPopup::onRemoveLevelFormat() {

  Preferences::instance()->removeLevelFormat(

      m_levelFormatNames->currentIndex());

  rebuildFormatsList();

}

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

void PreferencesPopup::onEditLevelFormat() {

  if (!m_formatProperties) {

    m_formatProperties = new FormatProperties(this);

    bool ret = connect(m_formatProperties, SIGNAL(dialogClosed()),

                       SLOT(onLevelFormatEdited()));

    assert(ret);

  }

  const Preferences::LevelFormat& lf =

      Preferences::instance()->levelFormat(m_levelFormatNames->currentIndex());

  m_formatProperties->setLevelFormat(lf);

  m_formatProperties->show();