#include "vectorizerpopup.h"

// Tnz6 includes

#include "tapp.h"

#include "fileselection.h"

#include "castselection.h"

#include "cellselection.h"

#include "overwritepopup.h"

#include "vectorizerswatch.h"

#include "filebrowserpopup.h"

#include "menubarcommandids.h"

// TnzQt includes

#include "toonzqt/menubarcommand.h"

#include "toonzqt/intfield.h"

#include "toonzqt/colorfield.h"

#include "toonzqt/checkbox.h"

#include "toonzqt/gutil.h"

// TnzLib includes

#include "toonz/namebuilder.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshleveltypes.h"

#include "toonz/txsheet.h"

#include "toonz/txshcell.h"

#include "toonz/toonzscene.h"

#include "toonz/tcenterlinevectorizer.h"

#include "toonz/dpiscale.h"

#include "toonz/txshchildlevel.h"

#include "toonz/levelset.h"

#include "toonz/tscenehandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/sceneproperties.h"

#include "toonz/imagemanager.h"

#include "toonz/Naa2TlvConverter.h"

// TnzCore includes

#include "tsystem.h"

#include "tconvert.h"

#include "tpalette.h"

#include "trasterimage.h"

#include "ttoonzimage.h"

#include "tcolorstyles.h"

#include "tstroke.h"

#include "tpersistset.h"

#include "columncommand.h"

// Qt includes

#include <qframe></qframe>

#include <qcombobox></qcombobox>

#include <qcoreapplication></qcoreapplication>

#include <qpushbutton></qpushbutton>

#include <qhboxlayout></qhboxlayout>

#include <qvboxlayout></qvboxlayout>

#include <qstring></qstring>

#include <qlabel></qlabel>

#include <qsplitter></qsplitter>

#include <qgridlayout></qgridlayout>

#include <qscrollarea></qscrollarea>

#include <qaction></qaction>

#include <qmainwindow></qmainwindow>

#include <qtoolbutton></qtoolbutton>

using namespace DVGui;

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

//    Local namespace  classes

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

namespace {

struct Param {

  QString m_name;

  int m_bit;

  Param(const QString &name, int bit) : m_name(name), m_bit(bit) {}

};

struct ParamGroup {

  int m_startRow, m_separatorRow;

  std::vector<param> m_params;

  ParamGroup(int startRow, int separatorRow)

      : m_startRow(startRow), m_separatorRow(separatorRow) {}

};

}  // namespace

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

//    Local namespace stuff

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

namespace {

std::vector<paramgroup> l_centerlineParamGroups;</paramgroup>

std::vector<paramgroup> l_outlineParamGroups;</paramgroup>

bool l_quitLoop = false;

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

VectorizerParameters *getCurrentVectorizerParameters() {

  return TApp::instance()

      ->getCurrentScene()

      ->getScene()

      ->getProperties()

      ->getVectorizerParameters();

}

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

bool getSelectedLevels(std::set<txshlevel *=""> &levels, int &r0, int &c0, int &r1,</txshlevel>

                       int &c1) {

  TXsheet *xsheet = TApp::instance()->getCurrentXsheet()->getXsheet();

  CastSelection *castSelection =

      dynamic_cast<castselection *="">(TSelection::getCurrent());</castselection>

  TCellSelection *cellSelection =

      dynamic_cast<tcellselection *="">(TSelection::getCurrent());</tcellselection>

  if (castSelection) {

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

    castSelection->getSelectedLevels(selectedLevels);

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

      levels.insert(selectedLevels[i]);

    return false;

  } else if (cellSelection) {

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

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

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

        TXshCell cell = xsheet->getCell(r, c);

        if (TXshLevel *level = cell.isEmpty() ? 0 : cell.getSimpleLevel())

          levels.insert(level);

      }

    }

    return true;

  }

  return false;

}

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

TXshLevel *getSelectedLevel() {

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

  int r0, c0, r1, c1;

  getSelectedLevels(levels, r0, c0, r1, c1);

  return (levels.size() == 1) ? *levels.begin() : (TXshLevel *)0;

}

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

TFilePath getSelectedLevelPath() {

  TXshLevel *level = getSelectedLevel();

  return level

             ? TApp::instance()->getCurrentScene()->getScene()->decodeFilePath(

                   level->getPath())

             : TFilePath();

}

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

void getSelectedFids(std::vector<tframeid> &fids, TXshSimpleLevel *level,</tframeid>

                     int r0, int c0, int r1, int c1) {

  TXsheet *xsheet = TApp::instance()->getCurrentXsheet()->getXsheet();

  std::set<tframeid> fidsSet;</tframeid>

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

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

      TXshCell cell = xsheet->getCell(r, c);

      TXshSimpleLevel *curLevel = cell.isEmpty() ? 0 : cell.getSimpleLevel();

      if (curLevel != level) continue;

      fidsSet.insert(cell.getFrameId());

    }

  }

  std::set<tframeid>::iterator fst, fsEnd = fidsSet.end();</tframeid>

  for (fst = fidsSet.begin(); fst != fsEnd; ++fst) fids.push_back(*fst);

}

// Toonz Raster Level may have palette including MyPaint styles,

// which cannot be rendered in vector levels.

// In such case replace MyPaint styles by solid color styles.

void replaceMyPaintBrushStyles(TPalette *palette) {

  for (int s = 0; s < palette->getStyleCount(); s++) {

    TColorStyle *style = palette->getStyle(s);

    if (style->getTagId() == 4001)  // TMyPaintBrushStyle

      palette->setStyle(s, style->getMainColor());

  }

}

}  // namespace

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

//    Vectorizer implementation

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

Vectorizer::Vectorizer()

    : m_dialog(new OverwriteDialog)

    , m_isCanceled(false)

    , m_dialogShown(false) {}

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

Vectorizer::~Vectorizer() {

  // DO NOT REMOVE - DESTRUCTS INCOMPLETE TYPES IN THE HEADER FILE

}

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

TVectorImageP Vectorizer::doVectorize(TImageP img, TPalette *palette,

                                      const VectorizerConfiguration &conf) {

  TToonzImageP ti  = img;

  TRasterImageP ri = img;

  if (!ti && !ri) return TVectorImageP();

  VectorizerCore vCore;

  connect(&vCore, SIGNAL(partialDone(int, int)), this,

          SIGNAL(partialDone(int, int)));

  connect(this, SIGNAL(transmitCancel()), &vCore, SLOT(onCancel()),

          Qt::DirectConnection);  // Direct connection *must* be

                                  // established for child cancels

  return vCore.vectorize(img, conf, palette);

}

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

void Vectorizer::setLevel(const TXshSimpleLevelP &level) {

  m_level = level;

  // Creo il livello pli

  TXshSimpleLevel *sl = m_level.getPointer();

  if (!sl) return;

  int rowCount = sl->getFrameCount();

  if (rowCount <= 0 || sl->isEmpty()) return;

  TXshLevel *xl;

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

  // Build the new level name

  std::wstring levelName = sl->getName() + L"v";

  {

    std::unique_ptr<namebuilder> nameBuilder(</namebuilder>

        NameBuilder::getBuilder(levelName));

    for (;;) {

      levelName = nameBuilder->getNext();

      if (scene->getLevelSet()->getLevel(levelName) == 0) break;

    }

  }

  TFilePath dstPath = sl->getPath().withName(levelName).withType("pli");

  dstPath           = scene->decodeFilePath(dstPath);

  bool overWrite = false;

  if (TSystem::doesExistFileOrLevel(dstPath)) {

    m_dialogShown = true;

    std::wstring name = m_dialog->execute(scene, dstPath, true);

    if (m_dialog->cancelPressed()) return;

    switch (m_dialog->getChoice()) {

    case OverwriteDialog::KEEP_OLD:

      xl = scene->getLevelSet()->getLevel(levelName);

      if (!xl) xl = scene->loadLevel(dstPath);

      m_vLevel = xl->getSimpleLevel();

      return;

    case OverwriteDialog::OVERWRITE:

      overWrite = true;

      break;

    default:

      levelName = name;

      break;

    }

  }

  xl = scene->createNewLevel(PLI_XSHLEVEL, levelName);

  TXshSimpleLevel *vl = xl->getSimpleLevel();

  assert(vl);

  if (overWrite) {

    vl->setPath(scene->codeFilePath(dstPath));

    vl->setName(levelName);

  }

  TPalette *palette = 0;

  if (sl->getType() == TZP_XSHLEVEL) {

    palette = sl->getPalette()->clone();

    replaceMyPaintBrushStyles(palette);

  } else

    palette = new TPalette;

  palette->setPaletteName(vl->getName());

  vl->setPalette(palette);

  m_vLevel = vl;

}

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

int Vectorizer::doVectorize() {

  struct {

    Vectorizer *m_this;

    CenterlineConfiguration m_cConf;

    NewOutlineConfiguration m_oConf;

    void updateConfig(double weight) {

      if (m_this->m_params.m_isOutline)

        m_oConf = m_this->m_params.getOutlineConfiguration(weight);

      else

        m_cConf = m_this->m_params.getCenterlineConfiguration(weight);

    }

  } locals = {this};

  VectorizerConfiguration &configuration =

      m_params.m_isOutline

          ? static_cast<vectorizerconfiguration &="">(locals.m_oConf)</vectorizerconfiguration>

          : static_cast<vectorizerconfiguration &="">(locals.m_cConf);</vectorizerconfiguration>

  if (!m_vLevel) return 0;

  if (m_dialog->getChoice() == OverwriteDialog::KEEP_OLD && m_dialogShown)

    return m_fids.size();

  TXshSimpleLevel *sl = m_level.getPointer();

  if (!sl) return 0;

  int rowCount = sl->getFrameCount();

  if (rowCount <= 0 || sl->isEmpty()) return 0;

  double frameRange[2] = {static_cast<double>(m_fids.front().getNumber()) - 1,</double>

                          static_cast<double>(m_fids.back().getNumber()) - 1};</double>

  int count = 0;

  std::vector<tframeid>::const_iterator ft, fEnd = m_fids.end();</tframeid>

  for (ft = m_fids.begin(); ft != fEnd; ++ft) {

    // Retrieve the image to be vectorized

    TImageP img;

    if (sl->getType() == OVL_XSHLEVEL || sl->getType() == TZP_XSHLEVEL ||

        sl->getType() == TZI_XSHLEVEL)

      img = sl->getFullsampledFrame(*ft, ImageManager::dontPutInCache);

    if (!img) continue;

    // Build image-toonz coordinate transformation

    TAffine dpiAff = getDpiAffine(sl, *ft, true);

    double factor  = norm(dpiAff * TPointD(1, 0));

    TPointD center;

    if (TToonzImageP ti = img)

      center = ti->getRaster()->getCenterD();

    else if (TRasterImageP ri = img)

      center = ri->getRaster()->getCenterD();

    // Build vectorizer configuration

    double weight = (ft->getNumber() - 1 - frameRange[0]) /

                    std::max(frameRange[1] - frameRange[0], 1.0);

    weight = tcrop(weight, 0.0, 1.0);

    locals.updateConfig(weight);  // TEMPORARY

    configuration.m_affine     = dpiAff * TTranslation(-center);

    configuration.m_thickScale = factor;

    // Build vectorization label to be displayed

    QString labelName = QString::fromStdWString(sl->getShortName());

    labelName.push_back(' ');

    labelName.append(QString::fromStdString(ft->expand(TFrameId::NO_PAD)));

    emit frameName(labelName);

    // Perform vectorization

    if (TVectorImageP vi =

            doVectorize(img, m_vLevel->getPalette(), configuration)) {

      TFrameId fid = *ft;

      if (fid.getNumber() < 0) fid = TFrameId(1, ft->getLetter());

      m_vLevel->setFrame(fid, vi);

      vi->setPalette(m_vLevel->getPalette());

      emit frameDone(++count);

    }

    // Stop if canceled

    if (m_isCanceled) break;

  }

  m_dialogShown = false;

  return count;

}

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

void Vectorizer::run() { doVectorize(); }

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

//    VectorizerPopup implementation

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

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

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

    , m_sceneHandle(TApp::instance()->getCurrentScene()) {

  struct Locals {

    int m_bit;

    Locals() : m_bit() {}

    static void addParameterGroup(std::vector<paramgroup> ¶mGroups,</paramgroup>

                                  int group, int startRow,

                                  int separatorRow = -1) {

      assert(group <= paramGroups.size());

      if (group == paramGroups.size())

        paramGroups.push_back(ParamGroup(startRow, separatorRow));

    }

    void addParameter(std::vector<paramgroup> ¶mGroups,</paramgroup>

                      const QString ¶mName) {

      paramGroups.back().m_params.push_back(Param(paramName, m_bit++));

    }

  } locals;

  // Su MAC i dialog modali non hanno bottoni di chiusura nella titleBar

  setModal(false);

  setWindowTitle(tr("Convert-to-Vector Settings"));

  setLabelWidth(125);

  setTopMargin(0);

  setTopSpacing(0);

  // Build vertical layout

  beginVLayout();

  QSplitter *splitter = new QSplitter(Qt::Vertical, this);

  splitter->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,

                                      QSizePolicy::MinimumExpanding));

  addWidget(splitter);

  QToolBar *leftToolBar = new QToolBar, *rightToolBar = new QToolBar;

  leftToolBar->setObjectName("MediumPaddingToolBar");

  rightToolBar->setObjectName("MediumPaddingToolBar");

  leftToolBar->setIconSize(QSize(17, 17));

  rightToolBar->setIconSize(QSize(17, 17));

  {

    QWidget *toolbarsContainer = new QWidget(this);

    toolbarsContainer->setFixedHeight(22);

    addWidget(toolbarsContainer);

    QHBoxLayout *toolbarsLayout = new QHBoxLayout(toolbarsContainer);

    toolbarsContainer->setLayout(toolbarsLayout);

    toolbarsLayout->setMargin(0);

    toolbarsLayout->setSpacing(0);

    QToolBar *spacingToolBar = new QToolBar(

        toolbarsContainer);  // The spacer object must be a toolbar.

    spacingToolBar->setFixedHeight(

        22);  // It's related to qss choices... I know it's stinky

    toolbarsLayout->addWidget(leftToolBar, 0, Qt::AlignLeft);

    toolbarsLayout->addWidget(spacingToolBar, 1);

    toolbarsLayout->addWidget(rightToolBar, 0, Qt::AlignRight);

  }

  endVLayout();

  // Build parameters area

  QScrollArea *paramsArea = new QScrollArea(splitter);

  paramsArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

  paramsArea->setWidgetResizable(true);

  splitter->addWidget(paramsArea);

  splitter->setStretchFactor(0, 1);

  m_paramsWidget = new QFrame(paramsArea);

  paramsArea->setWidget(m_paramsWidget);

  m_paramsLayout = new QGridLayout;

  m_paramsWidget->setLayout(m_paramsLayout);

  int group = 0, row = 0;

  locals.addParameterGroup(::l_centerlineParamGroups, group, row);

  locals.addParameterGroup(::l_outlineParamGroups, group++, row);

  // Vectorization mode

  m_typeMenu = new QComboBox(this);

  m_typeMenu->setFixedSize(245, WidgetHeight);

  QStringList formats;

  formats << tr("Centerline") << tr("Outline");

  m_typeMenu->addItems(formats);

  m_typeMenu->setMinimumHeight(WidgetHeight);

  bool isOutline = m_sceneHandle->getScene()

                       ->getProperties()

                       ->getVectorizerParameters()

                       ->m_isOutline;

  m_typeMenu->setCurrentIndex(isOutline ? 1 : 0);

  connect(m_typeMenu, SIGNAL(currentIndexChanged(int)), this,

          SLOT(onTypeChange(int)));

  m_paramsLayout->addWidget(new QLabel(tr("Mode")), row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_typeMenu, row++, 1);

  locals.addParameter(l_centerlineParamGroups, tr("Mode"));

  locals.addParameter(l_outlineParamGroups, tr("Mode"));

  //-------------------- Parameters area - Centerline ------------------------

  locals.addParameterGroup(l_centerlineParamGroups, group++, row);

  // Threshold

  m_cThresholdLabel = new QLabel(tr("Threshold"));

  m_cThreshold      = new IntField(this);

  m_paramsLayout->addWidget(m_cThresholdLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_cThreshold, row++, 1);

  locals.addParameter(l_centerlineParamGroups, tr("Threshold"));

  // Accuracy

  m_cAccuracyLabel = new QLabel(tr("Accuracy"));

  m_cAccuracy      = new IntField(this);

  m_paramsLayout->addWidget(m_cAccuracyLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_cAccuracy, row++, 1);

  locals.addParameter(l_centerlineParamGroups, tr("Accuracy"));

  // Despeckling

  m_cDespecklingLabel = new QLabel(tr("Despeckling"));

  m_cDespeckling      = new IntField(this);

  m_paramsLayout->addWidget(m_cDespecklingLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_cDespeckling, row++, 1);

  locals.addParameter(l_centerlineParamGroups, tr("Despeckling"));

  // Max Thickness

  m_cMaxThicknessLabel = new QLabel(tr("Max Thickness"));

  m_paramsLayout->addWidget(m_cMaxThicknessLabel, row, 0, Qt::AlignRight);

  m_cMaxThickness = new IntField(this);

  m_cMaxThickness->enableSlider(false);

  m_paramsLayout->addWidget(m_cMaxThickness, row++, 1, Qt::AlignLeft);

  locals.addParameter(l_centerlineParamGroups, tr("Max Thickness"));

  // Thickness Calibration

  m_cThicknessRatioLabel = new QLabel(tr("Thickness Calibration"));

  m_paramsLayout->addWidget(m_cThicknessRatioLabel, row, 0, Qt::AlignRight);

  /*m_cThicknessRatio = new IntField(this);

paramsLayout->addWidget(m_cThicknessRatio, row++, 1);*/

  QHBoxLayout *cThicknessRatioLayout = new QHBoxLayout;

  cThicknessRatioLayout->addSpacing(20);

  m_cThicknessRatioFirstLabel = new QLabel(tr("Start:"));

  cThicknessRatioLayout->addWidget(m_cThicknessRatioFirstLabel);

  m_cThicknessRatioFirst = new MeasuredDoubleLineEdit(this);

  m_cThicknessRatioFirst->setMeasure("percentage");

  cThicknessRatioLayout->addWidget(m_cThicknessRatioFirst);

  m_cThicknessRatioLastLabel = new QLabel(tr("End:"));

  cThicknessRatioLayout->addWidget(m_cThicknessRatioLastLabel);

  m_cThicknessRatioLast = new MeasuredDoubleLineEdit(this);

  m_cThicknessRatioLast->setMeasure("percentage");

  cThicknessRatioLayout->addWidget(m_cThicknessRatioLast);

  cThicknessRatioLayout->addStretch(1);

  m_paramsLayout->addLayout(cThicknessRatioLayout, row++, 1);

  locals.addParameter(l_centerlineParamGroups, tr("Thickness Calibration"));

  // Checkboxes

  {

    static const QString name = tr("Preserve Painted Areas");

    locals.addParameter(l_centerlineParamGroups, name);

    m_cPaintFill = new CheckBox(name, this);

    m_cPaintFill->setFixedHeight(WidgetHeight);

    m_paramsLayout->addWidget(m_cPaintFill, row++, 1);

  }

  {

    static const QString name = tr("Align Boundary Strokes Direction");

    locals.addParameter(l_centerlineParamGroups, name);

    m_cAlignBoundaryStrokesDirection = new CheckBox(name, this);

    m_cAlignBoundaryStrokesDirection->setFixedHeight(WidgetHeight);

    m_cAlignBoundaryStrokesDirection->setToolTip(

        tr("Align boundary strokes direction to be the same.\n(clockwise, i.e. "

           "left to right as viewed from inside of the shape)"));

    m_paramsLayout->addWidget(m_cAlignBoundaryStrokesDirection, row++, 1);

  }

  {

    static const QString name = tr("Add Border");

    locals.addParameter(l_centerlineParamGroups, name);

    m_cMakeFrame = new CheckBox(name, this);

    m_cMakeFrame->setFixedHeight(WidgetHeight);

    m_paramsLayout->addWidget(m_cMakeFrame, row++, 1);

  }

  locals.addParameterGroup(l_centerlineParamGroups, group++, row + 1, row);

  m_cNaaSourceSeparator = new Separator(tr("Full color non-AA images"));

  m_paramsLayout->addWidget(m_cNaaSourceSeparator, row++, 0, 1, 2);

  {

    static const QString name = tr("Enhanced ink recognition");

    locals.addParameter(l_centerlineParamGroups, name);

    m_cNaaSource = new CheckBox(name, this);

    m_cNaaSource->setFixedHeight(WidgetHeight);

    m_paramsLayout->addWidget(m_cNaaSource, row++, 1);

  }

  //-------------------- Parameters area - Outline ------------------------

  group = 1;

  locals.addParameterGroup(l_outlineParamGroups, group++, row);

  // Accuracy

  m_oAccuracyLabel = new QLabel(tr("Accuracy"));

  m_oAccuracy      = new IntField(this);

  m_paramsLayout->addWidget(m_oAccuracyLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_oAccuracy, row++, 1);

  locals.addParameter(l_outlineParamGroups, tr("Accuracy"));

  // Despeckling

  m_oDespecklingLabel = new QLabel(tr("Despeckling"));

  m_oDespeckling      = new IntField(this);

  m_paramsLayout->addWidget(m_oDespecklingLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_oDespeckling, row++, 1);

  locals.addParameter(l_outlineParamGroups, tr("Despeckling"));

  // Paint Fill

  {

    static const QString name = tr("Preserve Painted Areas");

    locals.addParameter(l_outlineParamGroups, name);

    m_oPaintFill = new CheckBox(name, this);

    m_oPaintFill->setFixedHeight(WidgetHeight);

    m_paramsLayout->addWidget(m_oPaintFill, row++, 1);

  }

  {

    static const QString name = tr("Align Boundary Strokes Direction");

    locals.addParameter(l_outlineParamGroups, name);

    m_oAlignBoundaryStrokesDirection = new CheckBox(name, this);

    m_oAlignBoundaryStrokesDirection->setFixedHeight(WidgetHeight);

    m_oAlignBoundaryStrokesDirection->setToolTip(

        tr("Align boundary strokes direction to be the same.\n(clockwise, i.e. "

           "left to right as viewed from inside of the shape)"));

    m_paramsLayout->addWidget(m_oAlignBoundaryStrokesDirection, row++, 1);

  }

  locals.addParameterGroup(l_outlineParamGroups, group++, row + 1, row);

  m_oCornersSeparator = new Separator(tr("Corners"));

  m_paramsLayout->addWidget(m_oCornersSeparator, row++, 0, 1, 2);

  // Adherence

  m_oAdherenceLabel = new QLabel(tr("Adherence"));

  m_oAdherence      = new IntField(this);

  m_paramsLayout->addWidget(m_oAdherenceLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_oAdherence, row++, 1);

  locals.addParameter(l_outlineParamGroups, tr("Adherence"));

  // Angle

  m_oAngleLabel = new QLabel(tr("Angle"));

  m_oAngle      = new IntField(this);

  m_paramsLayout->addWidget(m_oAngleLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_oAngle, row++, 1);

  locals.addParameter(l_outlineParamGroups, tr("Angle"));

  // Relative

  m_oRelativeLabel = new QLabel(tr("Curve Radius"));

  m_oRelative      = new IntField(this);

  m_paramsLayout->addWidget(m_oRelativeLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_oRelative, row++, 1);

  locals.addParameter(l_outlineParamGroups, tr("Curve Radius"));

  locals.addParameterGroup(l_outlineParamGroups, group++, row + 1, row);

  m_oFullColorSeparator = new Separator(tr("Raster Levels"));

  m_paramsLayout->addWidget(m_oFullColorSeparator, row++, 0, 1, 2);

  // Max Colors

  m_oMaxColorsLabel = new QLabel(tr("Max Colors"));

  m_oMaxColors      = new IntField(this);

  m_paramsLayout->addWidget(m_oMaxColorsLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_oMaxColors, row++, 1);

  locals.addParameter(l_outlineParamGroups, tr("Max Colors"));

  // Transparent Color

  m_oTransparentColorLabel = new QLabel(tr("Transparent Color"), this);

  m_oTransparentColor = new ColorField(this, true, TPixel32::Transparent, 48);

  m_paramsLayout->addWidget(m_oTransparentColorLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_oTransparentColor, row++, 1);

  locals.addParameter(l_outlineParamGroups, tr("Transparent Color"));

  locals.addParameterGroup(l_outlineParamGroups, group++, row + 1, row);

  m_oTlvSeparator = new Separator(tr("TLV Levels"));

  m_paramsLayout->addWidget(m_oTlvSeparator, row++, 0, 1, 2);

  // Tone Threshold

  m_oToneThresholdLabel = new QLabel(tr("Tone Threshold"));

  m_oToneThreshold      = new IntField(this);

  m_paramsLayout->addWidget(m_oToneThresholdLabel, row, 0, Qt::AlignRight);

  m_paramsLayout->addWidget(m_oToneThreshold, row++, 1);

  locals.addParameter(l_outlineParamGroups, tr("Tone Threshold"));

  m_paramsLayout->setRowStretch(row, 1);

  //-------------------- Swatch area ------------------------

  m_swatchArea = new VectorizerSwatchArea(this);

  splitter->addWidget(m_swatchArea);

  m_swatchArea->setEnabled(false);  // Initially not enabled

  connect(this, SIGNAL(valuesChanged()), m_swatchArea,

          SLOT(invalidateContents()));

  //---------------------- Toolbar --------------------------

  QAction *swatchAct =

      new QAction(createQIcon("preview"), tr("Toggle Swatch Preview"), this);

  swatchAct->setCheckable(true);

  leftToolBar->addAction(swatchAct);

  QAction *centerlineAct = new QAction(createQIcon("centerline"),

                                       tr("Toggle Centerlines Check"), this);

  centerlineAct->setCheckable(true);

  leftToolBar->addAction(centerlineAct);

  QToolButton *visibilityButton = new QToolButton(this);

  visibilityButton->setIcon(createQIcon("menu"));

  visibilityButton->setText(tr("Options"));

  visibilityButton->setPopupMode(QToolButton::InstantPopup);

  QMenu *visibilityMenu = new QMenu(visibilityButton);

  visibilityButton->setMenu(visibilityMenu);

  rightToolBar->addWidget(visibilityButton);

  rightToolBar->addSeparator();

  QAction *saveAct =

      new QAction(createQIcon("save"), tr("Save Settings"), this);

  rightToolBar->addAction(saveAct);

  QAction *loadAct =

      new QAction(createQIcon("load"), tr("Load Settings"), this);

  rightToolBar->addAction(loadAct);

  rightToolBar->addSeparator();

  QAction *resetAct =

      new QAction(createQIcon("settings_reset"), tr("Reset Settings"), this);

  rightToolBar->addAction(resetAct);

  connect(swatchAct, SIGNAL(triggered(bool)), m_swatchArea,

          SLOT(enablePreview(bool)));

  connect(centerlineAct, SIGNAL(triggered(bool)), m_swatchArea,

          SLOT(enableDrawCenterlines(bool)));

  connect(visibilityMenu, SIGNAL(aboutToShow()), this,

          SLOT(populateVisibilityMenu()));

  connect(saveAct, SIGNAL(triggered()), this, SLOT(saveParameters()));

  connect(loadAct, SIGNAL(triggered()), this, SLOT(loadParameters()));

  connect(resetAct, SIGNAL(triggered()), this, SLOT(resetParameters()));

  //------------------- Convert Button ----------------------

  // Convert Button

  m_okBtn = new QPushButton(QString(tr("Convert")), this);

  connect(m_okBtn, SIGNAL(clicked()), this, SLOT(onOk()));

  addButtonBarWidget(m_okBtn);

  // All detailed signals convey to the unique valuesChanged() signal. That

  // makes it easier

  // to disconnect update notifications whenever we loadConfiguration(..).

  connect(this, SIGNAL(valuesChanged()), this, SLOT(updateSceneSettings()));

  // Connect value changes to update the global

  // VectorizerPopUpSettingsContainer.

  // connect(m_typeMenu,SIGNAL(currentIndexChanged(const QString

  // &)),this,SLOT(updateSceneSettings()));

  connect(m_cThreshold, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_cAccuracy, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_cDespeckling, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_cMaxThickness, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  // connect(m_cThicknessRatio,SIGNAL(valueChanged(bool)),this,SLOT(onValueEdited(bool)));

  connect(m_cThicknessRatioFirst, SIGNAL(valueChanged()), this,

          SLOT(onValueEdited()));

  connect(m_cThicknessRatioLast, SIGNAL(valueChanged()), this,

          SLOT(onValueEdited()));

  connect(m_cMakeFrame, SIGNAL(stateChanged(int)), this, SLOT(onValueEdited()));

  connect(m_cPaintFill, SIGNAL(stateChanged(int)), this, SLOT(onValueEdited()));

  connect(m_cAlignBoundaryStrokesDirection, SIGNAL(stateChanged(int)), this,

          SLOT(onValueEdited()));

  connect(m_cNaaSource, SIGNAL(stateChanged(int)), this, SLOT(onValueEdited()));

  connect(m_oAccuracy, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_oDespeckling, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_oPaintFill, SIGNAL(stateChanged(int)), this, SLOT(onValueEdited()));

  connect(m_oAlignBoundaryStrokesDirection, SIGNAL(stateChanged(int)), this,

          SLOT(onValueEdited()));

  connect(m_oAdherence, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_oAngle, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_oRelative, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_oDespeckling, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_oMaxColors, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  connect(m_oTransparentColor, SIGNAL(colorChanged(const TPixel32 &, bool)),

          this, SLOT(onValueEdited(const TPixel32 &, bool)));

  connect(m_oToneThreshold, SIGNAL(valueChanged(bool)), this,

          SLOT(onValueEdited(bool)));

  refreshPopup();

  // Non e' corretto: manca la possibilita' di aggiornare la selezione del

  // livello corrente

  //  connect(TApp::instance()->getCurrentLevel(), SIGNAL(xshLevelChanged()),

  //                                         this, SLOT(updateValues()));