#include "toonzqt/styleselection.h"

// TnzQt includes

#include "toonzqt/dvdialog.h"

#include "toonzqt/gutil.h"

#include "toonzqt/selectioncommandids.h"

#include "styledata.h"

// TnzLib includes

#include "toonz/tpalettehandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/studiopalette.h"

#include "toonz/palettecmd.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/cleanupcolorstyles.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/levelproperties.h"

// TnzCore includes

#include "tcolorstyles.h"

#include "tpixelutils.h"

#include "tundo.h"

#include "tconvert.h"

#include "../toonz/menubarcommandids.h"

#include "historytypes.h"

// Qt includes

#include <qapplication></qapplication>

#include <qclipboard></qclipboard>

#include <qbytearray></qbytearray>

#include <qbuffer></qbuffer>

using namespace DVGui;

enum StyleType { NORMALSTYLE, STUDIOSTYLE, LINKEDSTYLE };

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

namespace {

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

void copyStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle,

                           int pageIndex, std::set<int> *styleIndicesInPage) {</int>

  if (!palette || pageIndex < 0) return;

  int n = styleIndicesInPage->size();

  if (n == 0) return;

  TPalette::Page *page = palette->getPage(pageIndex);

  assert(page);

  StyleData *data = new StyleData();

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

  for (it = styleIndicesInPage->begin(); it != styleIndicesInPage->end();

       ++it) {

    int indexInPage    = *it;

    int styleId        = page->getStyleId(indexInPage);

    TColorStyle *style = page->getStyle(indexInPage);

    if (!style) continue;

    TColorStyle *newStyle = style->clone();

    data->addStyle(styleId, newStyle);

  }

  QApplication::clipboard()->setMimeData(data);

}

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

/*! Paste styles contained in \b data in the end of current palette page.

                Add to styleIndicesInPage pasted styles index.

*/

bool pasteStylesDataWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle,

                                const StyleData *data, int indexInPage,

                                int pageIndex,

                                std::set<int> *styleIndicesInPage) {</int>

  if (!palette) palette = pltHandle->getPalette();

  if (!palette) return false;

  // page = pagina corrente

  TPalette::Page *page = palette->getPage(pageIndex);

  if (!data) return false;

  // comincio a fare paste

  int i;

  int styleId = 0;

  for (i = 0; i < data->getStyleCount(); i++) {

    styleId            = data->getStyleIndex(i);

    TColorStyle *style = data->getStyle(i)->clone();

    // Se la palette e' di cleanup gli stili devono essere 8.

    if (palette->isCleanupPalette() && palette->getStyleInPagesCount() >= 8) {

      delete style;

      break;

    }

    // For now styles will be inserted regardless the styleId of copied styles

    // are already used in the target palette or not.

    styleId = palette->getFirstUnpagedStyle();

    if (styleId >= 0)

      palette->setStyle(styleId, style);

    else

      styleId = palette->addStyle(style);

    // check the type of the original(copied) style

    // If the original is NormalStyle

    if (style->getGlobalName() == L"") {

      // 1. If pasting normal style to level palette, do nothing

      if (palette->getGlobalName() == L"") {

      }

      // 2. If pasting normal style to studio palette, add a new link and make

      // it linkable

      else {

        std::wstring gname =

            L"-" + palette->getGlobalName() + L"-" + std::to_wstring(styleId);

        style->setGlobalName(gname);

      }

    }

    // If the original is StudioPaletteStyle

    else if (style->getOriginalName() == L"") {

      // 3. If pasting StudioPaletteStyle to level palette, set the style name

      // into the original name.

      // 4. If pasting StudioPaletteStyle to studio palette, set the style name

      // into the original name and keep the link.

      style->setOriginalName(style->getName());

    }

    // If the original is linked style, do nothing

    else {

    }

    // move in the page

    // inserisco lo stile nella pagina

    int index = indexInPage + i;

    page->insertStyle(index, styleId);

    // e lo seleziono

    if (styleIndicesInPage) styleIndicesInPage->insert(index);

  }

  if (palette == pltHandle->getPalette()) pltHandle->setStyleIndex(styleId);

  pltHandle->notifyPaletteChanged();

  pltHandle->notifyColorStyleSwitched();

  return true;

}

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

/*! Paste styles contained in application data after current style. Clear

   styleIndicesInPage

                and add to it pasted styles. If currentStyleIndex == -1 take

   paletteHandle current style.

*/

bool pasteStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle,

                            int pageIndex, std::set<int> *styleIndicesInPage) {</int>

  if (!palette) palette = pltHandle->getPalette();

  // page = pagina corrente

  TPalette::Page *page = palette->getPage(pageIndex);

  assert(page);

  // cerco il punto di inserimento (dopo lo stile corrente)

  int currentStyleIndex = pltHandle->getStyleIndex();

  int indexInPage       = page->search(currentStyleIndex) + 1;

  const StyleData *data =

      dynamic_cast<const *="" styledata="">(QApplication::clipboard()->mimeData());</const>

  if (!data) return false;

  // cancello la selezione

  if (styleIndicesInPage) styleIndicesInPage->clear();

  return pasteStylesDataWithoutUndo(palette, pltHandle, data, indexInPage,

                                    pageIndex, styleIndicesInPage);

}

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

void deleteStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle,

                             int pageIndex, std::set<int> *styleIndicesInPage,</int>

                             int fir = 0) {

  if (!palette) palette = pltHandle->getPalette();

  int n = styleIndicesInPage->size();

  if (n == 0) return;

  TPalette::Page *page = palette->getPage(pageIndex);

  assert(page);

  int currentStyleIndexInPage = page->search(pltHandle->getStyleIndex());

  bool mustChangeCurrentStyle =

      currentStyleIndexInPage >= 0 &&

      styleIndicesInPage->count(currentStyleIndexInPage) > 0;

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

  for (it = styleIndicesInPage->rbegin(); it != styleIndicesInPage->rend();

       ++it) {

    int j       = *it;

    int styleId = page->getStyleId(j);

    if (styleId < 2) {

      error(QObject::tr("It is not possible to delete the style #") +

            QString::number(styleId));

    } else {

      if (styleId == pltHandle->getStyleIndex()) pltHandle->setStyleIndex(1);

      palette->setStyle(styleId, TPixel32::Red);

      page->removeStyle(j);

    }

  }

  styleIndicesInPage->clear();

  if (mustChangeCurrentStyle) {

    // ho cancellato lo stile corrente

    if (currentStyleIndexInPage < page->getStyleCount()) {

      // posso fare in modo che lo stile selezionato sia nella stessa posizione

      pltHandle->setStyleIndex(page->getStyleId(currentStyleIndexInPage));

    } else if (page->getStyleCount() > 0) {

      // almeno faccio in modo che sia nella stessa pagina

      int styleId = page->getStyleId(page->getStyleCount() - 1);

      pltHandle->setStyleIndex(styleId);

    } else {

      // seleziono lo stile #1 (che c'e' sempre). n.b. questo puo' comportare un

      // cambio pagina

      pltHandle->setStyleIndex(1);

    }

  }

  // This function is used in undo and redo. So do not activate dirtyflag.

  pltHandle->notifyColorStyleChanged(false, false);

  pltHandle->notifyPaletteChanged();

}

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

void cutStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle,

                          int pageIndex, std::set<int> *styleIndicesInPage) {</int>

  copyStylesWithoutUndo(palette, pltHandle, pageIndex, styleIndicesInPage);

  deleteStylesWithoutUndo(palette, pltHandle, pageIndex, styleIndicesInPage);

}

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

void insertStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle,

                             int pageIndex, std::set<int> *styleIndicesInPage) {</int>

  if (!palette) palette = pltHandle->getPalette();

  if (!palette) return;

  TPalette::Page *page = palette->getPage(pageIndex);

  if (!page) return;

  const StyleData *data =

      dynamic_cast<const *="" styledata="">(QApplication::clipboard()->mimeData());</const>

  if (!data) return;

  int styleId = 0;

  // comincio a fare paste

  std::set<int>::iterator it = styleIndicesInPage->begin();</int>

  int i;

  for (i = 0; i < data->getStyleCount(); i++, it++) {

    styleId            = data->getStyleIndex(i);

    TColorStyle *style = data->getStyle(i)->clone();

    palette->setStyle(styleId, style);

    // inserisco lo stile nella pagina

    int index = *it;

    page->insertStyle(index, styleId);

  }

  if (palette == pltHandle->getPalette()) pltHandle->setStyleIndex(styleId);

  pltHandle->notifyColorStyleChanged(false);

  pltHandle->notifyPaletteChanged();

}

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

// PasteStylesUndo

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

class PasteStylesUndo final : public TUndo {

  TStyleSelection *m_selection;

  int m_oldStyleIndex;

  int m_pageIndex;

  std::set<int> m_styleIndicesInPage;</int>

  TPaletteP m_palette;

  QMimeData *m_data;

public:

  PasteStylesUndo(TStyleSelection *selection, int oldStyleIndex,

                  QMimeData *data)

      : m_selection(selection), m_oldStyleIndex(oldStyleIndex), m_data(data) {

    m_pageIndex          = m_selection->getPageIndex();

    m_styleIndicesInPage = m_selection->getIndicesInPage();

    m_palette            = m_selection->getPaletteHandle()->getPalette();

  }

  ~PasteStylesUndo() { delete m_data; }

  void undo() const override {

    TPaletteHandle *paletteHandle    = m_selection->getPaletteHandle();

    std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

    cutStylesWithoutUndo(m_palette.getPointer(), paletteHandle, m_pageIndex,

                         &styleIndicesInPage);

    m_selection->selectNone();

    m_selection->makeCurrent();

    // Setto l'indice corrente.

    if (m_palette.getPointer() == paletteHandle->getPalette())

      paletteHandle->setStyleIndex(m_oldStyleIndex);

  }

  void redo() const override {

    // Se e' la paletta corrente setto l'indice corrente.

    TPaletteHandle *paletteHandle = m_selection->getPaletteHandle();

    if (m_palette.getPointer() == paletteHandle->getPalette())

      paletteHandle->setStyleIndex(m_oldStyleIndex);

    TPalette::Page *page = m_palette->getPage(m_pageIndex);

    assert(page);

    int indexInPage       = page->search(m_oldStyleIndex) + 1;

    const StyleData *data = dynamic_cast<const *="" styledata="">(m_data);</const>

    assert(data);

    std::set<int> styleIndicesInPage;</int>

    pasteStylesDataWithoutUndo(m_palette.getPointer(), paletteHandle, data,

                               indexInPage, m_pageIndex, &styleIndicesInPage);

    // Se e' la paletta corrente aggiorno la selezione

    if (m_selection && m_palette.getPointer() == paletteHandle->getPalette()) {

      m_selection->selectNone();

      m_selection->select(m_pageIndex);

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

      for (it = styleIndicesInPage.begin(); it != styleIndicesInPage.end();

           ++it)

        m_selection->select(m_pageIndex, *it, true);

      m_selection->makeCurrent();

    }

  }

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

  QString getHistoryString() override {

    return QObject::tr("Paste Style  in Palette : %1")

        .arg(QString::fromStdWString(m_palette->getPaletteName()));

  }

  int getHistoryType() override { return HistoryType::Palette; }

};

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

// DeleteStylesUndo

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

class DeleteStylesUndo final : public TUndo {

  TStyleSelection *m_selection;

  int m_pageIndex;

  std::set<int> m_styleIndicesInPage;</int>

  QMimeData *m_data;

  TPaletteP m_palette;

public:

  DeleteStylesUndo(TStyleSelection *selection, QMimeData *data)

      : m_selection(selection), m_data(data) {

    m_pageIndex          = m_selection->getPageIndex();

    m_styleIndicesInPage = m_selection->getIndicesInPage();

    m_palette            = m_selection->getPaletteHandle()->getPalette();

  }

  void setStyleIndicesInPage(const std::set<int> &styleIndicesInPage) {</int>

    m_styleIndicesInPage = styleIndicesInPage;

  }

  void setPageIndex(int pageIndex) { m_pageIndex = pageIndex; }

  ~DeleteStylesUndo() { delete m_data; }

  void undo() const override {

    TPaletteHandle *paletteHandle = m_selection->getPaletteHandle();

    // Prendo il data corrente

    QClipboard *clipboard  = QApplication::clipboard();

    QMimeData *currentData = cloneData(clipboard->mimeData());

    // Setto il vecchio data

    clipboard->setMimeData(cloneData(m_data), QClipboard::Clipboard);

    std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

    insertStylesWithoutUndo(m_palette.getPointer(), paletteHandle, m_pageIndex,

                            &styleIndicesInPage);

    if (m_selection && m_palette.getPointer() == paletteHandle->getPalette()) {

      m_selection->selectNone();

      m_selection->select(m_pageIndex);

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

      for (it = styleIndicesInPage.begin(); it != styleIndicesInPage.end();

           ++it)

        m_selection->select(m_pageIndex, *it, true);

      m_selection->makeCurrent();

    }

    // Rimetto il data corrente.

    clipboard->setMimeData(currentData, QClipboard::Clipboard);

    // do not activate dirty flag here in case that the m_palette is not current

    // when undo

    paletteHandle->notifyColorStyleChanged(false, false);

  }

  void redo() const override {

    std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

    deleteStylesWithoutUndo(m_palette.getPointer(),

                            m_selection->getPaletteHandle(), m_pageIndex,

                            &styleIndicesInPage);

    if (m_selection) {

      m_selection->selectNone();

      m_selection->makeCurrent();

    }

  }

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

  QString getHistoryString() override {

    return QObject::tr("Delete Style  from Palette : %1")

        .arg(QString::fromStdWString(m_palette->getPaletteName()));

  }

  int getHistoryType() override { return HistoryType::Palette; }

};

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

// CutStylesUndo

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

class CutStylesUndo final : public TUndo {

  TStyleSelection *m_selection;

  int m_pageIndex;

  std::set<int> m_styleIndicesInPage;</int>

  QMimeData *m_oldData;  //!< data before cut

  QMimeData *m_data;     //!< data containing cut styles

  TPaletteP m_palette;

public:

  CutStylesUndo(TStyleSelection *selection, QMimeData *data, QMimeData *oldData)

      : m_selection(selection), m_oldData(oldData), m_data(data) {

    m_pageIndex          = m_selection->getPageIndex();

    m_styleIndicesInPage = m_selection->getIndicesInPage();

    m_palette            = m_selection->getPaletteHandle()->getPalette();

  }

  ~CutStylesUndo() {

    delete m_oldData;

    delete m_data;

  }

  void undo() const override {

    TPaletteHandle *paletteHandle = m_selection->getPaletteHandle();

    // Setto il data del cut

    QClipboard *clipboard = QApplication::clipboard();

    clipboard->setMimeData(cloneData(m_data), QClipboard::Clipboard);

    std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

    insertStylesWithoutUndo(m_palette.getPointer(), paletteHandle, m_pageIndex,

                            &styleIndicesInPage);

    if (m_selection && m_palette.getPointer() == paletteHandle->getPalette()) {

      m_selection->selectNone();

      m_selection->select(m_pageIndex);

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

      for (it = styleIndicesInPage.begin(); it != styleIndicesInPage.end();

           ++it)

        m_selection->select(m_pageIndex, *it, true);

      m_selection->makeCurrent();

    }

    // Setto il che c'era prima del cut

    clipboard->setMimeData(cloneData(m_oldData), QClipboard::Clipboard);

  }

  void redo() const override {

    std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

    cutStylesWithoutUndo(m_palette.getPointer(),

                         m_selection->getPaletteHandle(), m_pageIndex,

                         &styleIndicesInPage);

    m_selection->selectNone();

    m_selection->makeCurrent();

  }

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

  QString getHistoryString() override {

    return QObject::tr("Cut Style  from Palette : %1")

        .arg(QString::fromStdWString(m_palette->getPaletteName()));

  }

  int getHistoryType() override { return HistoryType::Palette; }

};

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

}  // namespace

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

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

// TStyleSelection

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

TStyleSelection::TStyleSelection()

    : m_paletteHandle(0)

    , m_xsheetHandle(0)

    , m_pageIndex(-1)

    , m_levelHandle(0) {}

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

TStyleSelection::~TStyleSelection() {}

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

void TStyleSelection::enableCommands() {

  if (m_paletteHandle && m_paletteHandle->getPalette() &&

      !m_paletteHandle->getPalette()->isCleanupPalette()) {

    enableCommand(this, MI_Cut, &TStyleSelection::cutStyles);

    enableCommand(this, MI_Copy, &TStyleSelection::copyStyles);

    enableCommand(this, MI_Paste, &TStyleSelection::pasteStyles);

    enableCommand(this, MI_PasteValues, &TStyleSelection::pasteStylesValue);

    enableCommand(this, MI_PasteColors, &TStyleSelection::pasteStylesColor);

    enableCommand(this, MI_PasteNames, &TStyleSelection::pasteStylesName);

    // available only for level palette

    if (m_paletteHandle->getPalette()->getGlobalName() == L"") {

      enableCommand(this, MI_GetColorFromStudioPalette,

                    &TStyleSelection::getBackOriginalStyle);

      enableCommand(this, MI_ToggleLinkToStudioPalette,

                    &TStyleSelection::toggleLink);

      enableCommand(this, MI_RemoveReferenceToStudioPalette,

                    &TStyleSelection::removeLink);

    }

  }

  enableCommand(this, MI_Clear, &TStyleSelection::deleteStyles);

  enableCommand(this, MI_EraseUnusedStyles, &TStyleSelection::eraseUnusedStyle);

  enableCommand(this, MI_BlendColors, &TStyleSelection::blendStyles);

}

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

void TStyleSelection::select(int pageIndex) {

  m_pageIndex = pageIndex;

  m_styleIndicesInPage.clear();

}

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

void TStyleSelection::select(int pageIndex, int styleIndexInPage, bool on) {

  if (on) {

    if (pageIndex != m_pageIndex) m_styleIndicesInPage.clear();

    m_pageIndex = pageIndex;

    m_styleIndicesInPage.insert(styleIndexInPage);

  } else if (pageIndex == m_pageIndex)

    m_styleIndicesInPage.erase(styleIndexInPage);

}

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

bool TStyleSelection::isSelected(int pageIndex, int id) const {

  return m_pageIndex == pageIndex &&

         m_styleIndicesInPage.find(id) != m_styleIndicesInPage.end();

}

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

bool TStyleSelection::isPageSelected(int pageIndex) const {

  return m_pageIndex == pageIndex;

}

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

bool TStyleSelection::canHandleStyles() {

  TPalette *palette = getPalette();

  if (!palette) return false;

  TPalette::Page *page = palette->getPage(m_pageIndex);

  if (!page) return false;

  if ((isSelected(m_pageIndex, 0) && page->getStyleId(0) == 0) ||

      (isSelected(m_pageIndex, 1) && page->getStyleId(1) == 1))

    return false;

  return true;

}

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

void TStyleSelection::selectNone() {

  m_pageIndex = -1;

  m_styleIndicesInPage.clear();

  notifyView();

}

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

bool TStyleSelection::isEmpty() const {

  return m_pageIndex < 0 && m_styleIndicesInPage.empty();

}

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

int TStyleSelection::getStyleCount() const {

  return m_styleIndicesInPage.size();

}

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

void TStyleSelection::cutStyles() {

  if (isEmpty()) return;

  QClipboard *clipboard = QApplication::clipboard();

  QMimeData *oldData    = cloneData(clipboard->mimeData());

  if (!canHandleStyles()) {

    error(QObject::tr("It is not possible to delete styles #0 and #1."));

    return;

  }

  TPalette *palette = m_paletteHandle->getPalette();

  if (!palette) return;

  if (palette->isLocked()) return;

  StyleData *data = new StyleData();

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

  TPalette::Page *page = palette->getPage(m_pageIndex);

  std::vector<int> styleIds;</int>

  for (it = m_styleIndicesInPage.begin(); it != m_styleIndicesInPage.end();

       ++it) {

    int j       = *it;

    int styleId = page->getStyleId(j);

    if (styleId < 0) continue;

    TColorStyle *style = page->getStyle(j)->clone();

    data->addStyle(styleId, style);

    styleIds.push_back(page->getStyleId(*it));

  }

  std::unique_ptr<tundo> undo(new CutStylesUndo(this, data, oldData));</tundo>

  if (m_xsheetHandle) {

    if (eraseStylesInDemand(palette, styleIds, m_xsheetHandle) == 0) return;

  }

  palette->setDirtyFlag(true);

  cutStylesWithoutUndo(palette, m_paletteHandle, m_pageIndex,

                       &m_styleIndicesInPage);

  TUndoManager::manager()->add(undo.release());

}

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

void TStyleSelection::copyStyles() {

  if (isEmpty()) return;

  copyStylesWithoutUndo(m_paletteHandle->getPalette(), m_paletteHandle,

                        m_pageIndex, &m_styleIndicesInPage);

}

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

void TStyleSelection::pasteStyles() {

  TPalette *palette = getPalette();

  // se non c'e' palette o pagina corrente esco

  if (!palette || m_pageIndex < 0) return;

  if (palette->isLocked()) return;

  TPalette::Page *page = palette->getPage(m_pageIndex);

  if (!page) return;

  if (isSelected(m_pageIndex, 0) && page->getStyleId(0) == 0) {

    error(QObject::tr("Can't paste styles there"));

    return;

  }

  int oldStyleIndex     = m_paletteHandle->getStyleIndex();

  QClipboard *clipboard = QApplication::clipboard();

  QMimeData *oldData    = cloneData(clipboard->mimeData());

  pasteStylesWithoutUndo(m_paletteHandle->getPalette(), m_paletteHandle,

                         m_pageIndex, &m_styleIndicesInPage);

  palette->setDirtyFlag(true);

  TUndoManager::manager()->add(

      new PasteStylesUndo(this, oldStyleIndex, oldData));

}

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

void TStyleSelection::deleteStyles() {

  TPalette *palette = getPalette();

  if (!palette || m_pageIndex < 0) return;

  if (palette->isLocked()) return;

  if (!canHandleStyles()) {

    error(QObject::tr("It is not possible to delete styles #0 and #1."));

    return;

  }

  if (getStyleCount() == 0) return;

  StyleData *data = new StyleData();

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

  TPalette::Page *page = palette->getPage(m_pageIndex);

  std::vector<int> styleIds;</int>

  for (it = m_styleIndicesInPage.begin(); it != m_styleIndicesInPage.end();

       ++it) {

    int j       = *it;

    int styleId = page->getStyleId(j);

    if (styleId < 0) continue;

    TColorStyle *style = page->getStyle(j)->clone();

    data->addStyle(styleId, style);

    styleIds.push_back(page->getStyleId(*it));

  }

  TUndoScopedBlock undoBlock;

  if (m_xsheetHandle) {

    if (eraseStylesInDemand(palette, styleIds, m_xsheetHandle) ==

        0)  // Could add an undo

      return;

  }

  std::unique_ptr<tundo> undo(new DeleteStylesUndo(this, data));</tundo>

  deleteStylesWithoutUndo(m_paletteHandle->getPalette(), m_paletteHandle,

                          m_pageIndex, &m_styleIndicesInPage);

  palette->setDirtyFlag(true);

  TUndoManager::manager()->add(undo.release());

}

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

void TStyleSelection::eraseUnusedStyle() {

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

  int row, column, i, j;

  TPalette *palette = m_paletteHandle->getPalette();

  findPaletteLevels(levels, row, column, palette, m_xsheetHandle->getXsheet());

  // Verifico quali stili sono usati e quali no

  std::map<int, bool=""> usedStyleIds;</int,>

  int pageCount = palette->getPageCount();

  for (auto const level : levels) {

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

    level->getFids(fids);

    int m, i, j;

    for (m = 0; m < (int)fids.size(); m++) {

      TImageP image = level->getFrame(fids[m], false);

      if (!image) continue;

      for (i = 0; i < pageCount; i++) {

        TPalette::Page *page = palette->getPage(i);

        assert(page);

        for (j = 0; j < page->getStyleCount(); j++) {

          int styleId = page->getStyleId(j);

          if (m != 0 && usedStyleIds[styleId]) continue;

          if (i == 0 && j == 0)  // Il primo stile della prima pagina non deve

                                 // essere mai cancellato

          {

            usedStyleIds[styleId] = true;

            continue;

          }

          usedStyleIds[styleId] = isStyleUsed(image, styleId);

        }

      }

    }

  }

  // check if there are styles to be erased

  QMap<int, std::set<int="">> styleIndicesInPageMap;</int,>

  QString indicesStr;

  int count = 0;

  // Butto gli stili non usati

  for (i = 0; i < pageCount; i++) {

    // Variabili usate per l'undo

    std::set<int> styleIndicesInPage;</int>

    TPalette::Page *page = palette->getPage(i);

    assert(page);

    for (j = 0; j < page->getStyleCount(); j++) {

      int styleId = page->getStyleId(j);

      if (usedStyleIds[styleId]) continue;

      styleIndicesInPage.insert(j);

      if (count < 10) indicesStr.append(QString::number(styleId) + ", ");

      count++;

    }

    if (!styleIndicesInPage.empty())

      styleIndicesInPageMap.insert(i, styleIndicesInPage);

  }

  if (styleIndicesInPageMap.isEmpty()) {

    DVGui::error(QObject::tr("There are no unused styles."));

    return;

  }

  if (count <= 10)

    indicesStr.chop(2);

  else

    indicesStr.append(

        QObject::tr("and %1 more styles.").arg(QString::number(count - 10)));

  // open confirmation popup

  QString question =

      QObject::tr(

          "Erasing unused styles with following indices. Are you sure?\n\n%1")

          .arg(indicesStr);

  int ret =

      DVGui::MsgBox(question, QObject::tr("Erase"), QObject::tr("Cancel"), 0);

  if (ret == 2 || ret == 0) return;

  TUndoManager::manager()->beginBlock();

  QMap<int, std::set<int="">>::const_iterator styleMapItr =</int,>

      styleIndicesInPageMap.constBegin();

  while (styleMapItr != styleIndicesInPageMap.constEnd()) {

    int pageIndex                    = styleMapItr.key();

    std::set<int> styleIndicesInPage = styleMapItr.value();</int>

    StyleData *data                  = new StyleData();

    TPalette::Page *page             = palette->getPage(pageIndex);

    for (auto indexInPage : styleIndicesInPage) {

      int styleId = page->getStyleId(indexInPage);

      data->addStyle(styleId, page->getStyle(indexInPage)->clone());

    }

    // Cancello gli stili

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

    for (it = styleIndicesInPage.rbegin(); it != styleIndicesInPage.rend();

         ++it)

      page->removeStyle(*it);

    // Undo

    DeleteStylesUndo *undo = new DeleteStylesUndo(this, data);

    undo->setPageIndex(pageIndex);

    undo->setStyleIndicesInPage(styleIndicesInPage);

    TUndoManager::manager()->add(undo);

    ++styleMapItr;

  }

  TUndoManager::manager()->endBlock();

  m_paletteHandle->setStyleIndex(1);

}

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

namespace {

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

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

// UndoPasteValues

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

class UndoPasteValues final : public TUndo {

  TStyleSelection *m_selection;

  TPaletteHandle *m_paletteHandle;

  int m_pageIndex;

  TPaletteP m_palette;

  bool m_pasteName;

  bool m_pasteColor;

  class Item {

  public:

    int m_index;

    TColorStyle *m_oldStyle;

    TColorStyle *m_newStyle;

    Item(int index, const TColorStyle *oldStyle, const TColorStyle *newStyle)

        : m_index(index)

        , m_oldStyle(oldStyle->clone())

        , m_newStyle(newStyle->clone()) {}

    Item(int index, const TColorStyle *newStyle)

        : m_index(index), m_oldStyle(0), m_newStyle(newStyle->clone()) {}

    ~Item() {

      delete m_oldStyle;

      delete m_newStyle;

    }

  };

  std::vector<item *=""> m_items;</item>

  std::vector<item *=""> m_itemsInserted;</item>

  TPalette *getPalette() const { return m_palette.getPointer(); }

public:

  UndoPasteValues(TStyleSelection *selection, bool pasteName,

                  bool pasteColor = true)

      : m_selection(selection)

      , m_pasteName(pasteName)

      , m_pasteColor(pasteColor) {

    m_pageIndex     = m_selection->getPageIndex();

    m_paletteHandle = m_selection->getPaletteHandle();

    m_palette       = m_paletteHandle->getPalette();

  }

  ~UndoPasteValues() {

    clearPointerContainer(m_items);

    clearPointerContainer(m_itemsInserted);

  }

  void addItem(int index, const TColorStyle *oldStyle,

               const TColorStyle *newStyle) {

    m_items.push_back(new Item(index, oldStyle, newStyle));

  }

  void addItemToInsert(const std::set<int> styleIndicesInPage) {</int>

    TPalette::Page *page = getPalette()->getPage(m_pageIndex);

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

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

      m_itemsInserted.push_back(new Item(*it, page->getStyle(*it)));

  }

  void pasteValue(int styleId, const TColorStyle *newStyle) const {

    // preserva il vecchio nome se m_pasteOnlyColor e' falso

    std::wstring str = newStyle->getName();

    if (m_pasteColor) {

      getPalette()->setStyle(styleId, newStyle->clone());

      if (!m_pasteName) getPalette()->getStyle(styleId)->setName(str);

    } else if (m_pasteName)

      getPalette()->getStyle(styleId)->setName(newStyle->getName());

  }

  void undo() const override {