#include "toonz/palettecmd.h"

// TnzLib includes

#include "toonz/tpalettehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/studiopalette.h"

#include "toonz/txsheet.h"

#include "toonz/txshcolumn.h"

#include "toonz/txshcell.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/cleanupcolorstyles.h"

#include "toonz/studiopalette.h"

#include "toonz/txshlevel.h"

#include "toonz/toonzscene.h"

#include "toonz/toonzimageutils.h"

#include "toonz/cleanupcolorstyles.h"

#include "toonz/preferences.h"

// TnzCore includes

#include "tpalette.h"

#include "tcolorstyles.h"

#include "tundo.h"

#include "tvectorimage.h"

#include "ttoonzimage.h"

#include "trasterimage.h"

#include "tconvert.h"

#include "tcolorutils.h"

#include "tropcm.h"

#include "tstroke.h"

#include "tregion.h"

#include "tlevel_io.h"

#include "historytypes.h"

// tcg includes

#include "tcg/boost/range_utility.h"

// boost includes

#include <boost bind.hpp=""></boost>

#include <boost counting_range.hpp="" range=""></boost>

#include <boost adaptor="" range="" transformed.hpp=""></boost>

#include <boost adaptor="" filtered.hpp="" range=""></boost>

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

void findPaletteLevels(set<txshsimplelevel *=""> &levels, int &rowIndex,</txshsimplelevel>

                       int &columnIndex, TPalette *palette, TXsheet *xsheet) {

  rowIndex = columnIndex = -1;

  int columnCount        = xsheet->getColumnCount();

  int c;

  for (c = 0; c < columnCount; c++) {

    TXshColumn *column = xsheet->getColumn(c);

    if (!column || column->isEmpty()) continue;

    TXshLevelColumn *levelColumn = column->getLevelColumn();

    if (!levelColumn || levelColumn->isEmpty()) continue;

    int r0, r1;

    if (!column->getRange(r0, r1)) continue;

    int r;

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

      TXshCell cell = levelColumn->getCell(r);

      if (cell.isEmpty()) continue;

      TXshSimpleLevel *level = cell.getSimpleLevel();

      if (!level || level->getPalette() != palette) continue;

      levels.insert(level);

      if (rowIndex < 0) {

        rowIndex    = r;

        columnIndex = c;

      }

    }

  }

}

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

namespace {

bool isStyleUsed(const TVectorImageP vi, int styleId) {

  int strokeCount = vi->getStrokeCount();

  int i;

  for (i = strokeCount - 1; i >= 0; i--) {

    TStroke *stroke = vi->getStroke(i);

    if (stroke && stroke->getStyle() == styleId) return true;

  }

  int regionCount = vi->getRegionCount();

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

    TRegion *region = vi->getRegion(i);

    if (region || region->getStyle() != styleId) return true;

  }

  return false;

}

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

bool isStyleUsed(const TToonzImageP vi, int styleId) {

  TRasterCM32P ras = vi->getRaster();

  for (int y = 0; y < ras->getLy(); y++) {

    TPixelCM32 *pix = ras->pixels(y), *endPix = pix + ras->getLx();

    while (pix < endPix) {

      if (pix->getPaint() == styleId) return true;

      if (pix->getInk() == styleId) return true;

      pix++;

    }

  }

  return false;

}

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

/*! Return true if one style is used. */

bool areStylesUsed(const TImageP image, const std::vector<int> styleIds) {</int>

  int j;

  for (j = 0; j < (int)styleIds.size(); j++)

    if (isStyleUsed(image, styleIds[j])) return true;

  return false;

}

}  // namespace

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

bool isStyleUsed(const TImageP image, int styleId) {

  TVectorImageP vi = image;

  TToonzImageP ti  = image;

  if (vi) return isStyleUsed(vi, styleId);

  if (ti) return isStyleUsed(ti, styleId);

  return false;

}

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

/*! Return true if one style is used. */

bool areStylesUsed(const set<txshsimplelevel *=""> levels,</txshsimplelevel>

                   const std::vector<int> styleIds) {</int>

  for (auto const level : levels) {

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

    level->getFids(fids);

    int i;

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

      TImageP image = level->getFrame(fids[i], true);

      if (areStylesUsed(image, styleIds)) return true;

    }

  }

  return false;

}

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

//

// arrangeStyles

// srcPage : {a0,a1,...an } ==> dstPage : {b,b+1,...b+n-1}

//

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

/*! \namespace PaletteCmd

                \brief Provides a collection of methods to manage \b TPalette.

*/

namespace {

class ArrangeStylesUndo : public TUndo {

  TPaletteHandle *m_paletteHandle;

  TPaletteP m_palette;

  int m_dstPageIndex;

  int m_dstIndexInPage;

  int m_srcPageIndex;

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

public:

  ArrangeStylesUndo(TPaletteHandle *paletteHandle, int dstPageIndex,

                    int dstIndexInPage, int srcPageIndex,

                    const std::set<int> &srcIndicesInPage)</int>

      : m_paletteHandle(paletteHandle)

      , m_dstPageIndex(dstPageIndex)

      , m_dstIndexInPage(dstIndexInPage)

      , m_srcPageIndex(srcPageIndex)

      , m_srcIndicesInPage(srcIndicesInPage) {

    m_palette = m_paletteHandle->getPalette();

    assert(m_palette);

    assert(0 <= dstPageIndex && dstPageIndex < m_palette->getPageCount());

    assert(0 <= srcPageIndex && srcPageIndex < m_palette->getPageCount());

    TPalette::Page *dstPage = m_palette->getPage(dstPageIndex);

    assert(dstPage);

    assert(0 <= dstIndexInPage && dstIndexInPage <= dstPage->getStyleCount());

    assert(!srcIndicesInPage.empty());

    TPalette::Page *srcPage = m_palette->getPage(srcPageIndex);

    assert(srcPage);

    assert(0 <= *srcIndicesInPage.begin() &&

           *srcIndicesInPage.rbegin() < srcPage->getStyleCount());

  }

  void undo() const {

    TPalette::Page *srcPage = m_palette->getPage(m_srcPageIndex);

    assert(srcPage);

    TPalette::Page *dstPage = m_palette->getPage(m_dstPageIndex);

    assert(dstPage);

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

    int count = m_srcIndicesInPage.size();

    int h     = m_dstIndexInPage;

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

    for (i = m_srcIndicesInPage.begin(); i != m_srcIndicesInPage.end(); ++i) {

      if (srcPage == dstPage && (*i) <= h)

        h--;

      else

        break;

    }

    assert(h + count - 1 <= dstPage->getStyleCount());

    int k;

    for (k = 0; k < count; k++) {

      styles.push_back(dstPage->getStyleId(h));

      dstPage->removeStyle(h);

    }

    k = 0;

    for (i = m_srcIndicesInPage.begin(); i != m_srcIndicesInPage.end();

         ++i, ++k)

      srcPage->insertStyle(*i, styles[k]);

    m_paletteHandle->notifyPaletteChanged();

  }

  void redo() const {

    TPalette::Page *srcPage = m_palette->getPage(m_srcPageIndex);

    assert(srcPage);

    TPalette::Page *dstPage = m_palette->getPage(m_dstPageIndex);

    assert(dstPage);

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

    std::set<int>::const_reverse_iterator i;</int>

    std::vector<int>::iterator j;</int>

    int k = m_dstIndexInPage;

    for (i = m_srcIndicesInPage.rbegin(); i != m_srcIndicesInPage.rend(); ++i) {

      int index = *i;

      if (m_dstPageIndex == m_srcPageIndex && index < k) k--;

      styles.push_back(srcPage->getStyleId(index));

      srcPage->removeStyle(index);

    }

    for (j = styles.begin(); j != styles.end(); ++j)

      dstPage->insertStyle(k, *j);

    m_palette->setDirtyFlag(true);

    m_paletteHandle->notifyPaletteChanged();

  }

  int getSize() const {

    return sizeof *this + m_srcIndicesInPage.size() * sizeof(int);

  }

  QString getHistoryString() {

    return QObject::tr("Arrange Styles  in Palette %1")

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

  }

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

};

}  // namespace

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

void PaletteCmd::arrangeStyles(TPaletteHandle *paletteHandle, int dstPageIndex,

                               int dstIndexInPage, int srcPageIndex,

                               const std::set<int> &srcIndicesInPage) {</int>

  if (dstPageIndex == srcPageIndex &&

      dstIndexInPage == *srcIndicesInPage.begin())

    return;

  ArrangeStylesUndo *undo =

      new ArrangeStylesUndo(paletteHandle, dstPageIndex, dstIndexInPage,

                            srcPageIndex, srcIndicesInPage);

  undo->redo();

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

}

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

// CreateStyle

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

namespace {

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

class CreateStyleUndo : public TUndo {

  TPaletteHandle *m_paletteHandle;

  TPaletteP m_palette;

  int m_pageIndex;

  int m_styleId;

  TColorStyle *m_style;

public:

  CreateStyleUndo(TPaletteHandle *paletteHandle, int pageIndex, int styleId)

      : m_paletteHandle(paletteHandle)

      , m_pageIndex(pageIndex)

      , m_styleId(styleId) {

    m_palette = m_paletteHandle->getPalette();

    m_style   = m_palette->getStyle(m_styleId)->clone();

    assert(m_palette);

    assert(0 <= pageIndex && pageIndex < m_palette->getPageCount());

    assert(0 <= styleId && styleId < m_palette->getStyleCount());

  }

  void undo() const {

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

    assert(page);

    int indexInPage = page->search(m_styleId);

    assert(indexInPage >= 0);

    page->removeStyle(indexInPage);

    m_paletteHandle->notifyPaletteChanged();

  }

  void redo() const {

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

    assert(page);

    assert(m_palette->getStylePage(m_styleId) == 0);

    int indexInPage = page->addStyle(m_styleId);

    if (indexInPage == -1) {

      indexInPage = page->getStyleCount();

      page->insertStyle(indexInPage, m_style->getMainColor());

      assert(m_styleId == page->getStyleId(indexInPage));

    }

    m_palette->getStyle(m_styleId)->setMainColor(m_style->getMainColor());

    m_palette->getStyle(m_styleId)->setName(m_style->getName());

    m_paletteHandle->notifyPaletteChanged();

  }

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

  QString getHistoryString() {

    return QObject::tr("Create Style#%1  in Palette %2")

        .arg(QString::number(m_styleId))

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

  }

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

};

}  // namespace

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

void PaletteCmd::createStyle(TPaletteHandle *paletteHandle,

                             TPalette::Page *page) {

  int index         = paletteHandle->getStyleIndex();

  TPalette *palette = paletteHandle->getPalette();

  int newIndex;

  int UnpagedId = palette->getFirstUnpagedStyle();

  if (UnpagedId != -1 && !palette->isCleanupPalette()) {

    if (index == -1)

      palette->getStyle(UnpagedId)->setMainColor(TPixel32::Black);

    else

      palette->getStyle(UnpagedId)->setMainColor(

          palette->getStyle(index)->getMainColor());

    newIndex = page->addStyle(UnpagedId);

  } else if (!palette->isCleanupPalette()) {

    if (index == -1)

      newIndex = page->addStyle(TPixel32::Black);

    else {

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

      TCleanupStyle *cleanupStyle = dynamic_cast<tcleanupstyle *="">(style);</tcleanupstyle>

      if ((cleanupStyle || index == 0) && palette->isCleanupPalette()) {

        TColorCleanupStyle *newCleanupStyle = new TColorCleanupStyle();

        if (cleanupStyle) {

          int i;

          for (i = 0; i < cleanupStyle->getParamCount(); i++)

            newCleanupStyle->setColorParamValue(

                i, cleanupStyle->getColorParamValue(i));

        }

        newIndex = page->addStyle(newCleanupStyle);

      } else

        newIndex = page->addStyle(style->getMainColor());

    }

  } else /*- CleanupPaletteの場合 -*/

  {

    newIndex = page->addStyle(new TColorCleanupStyle(TPixel32::Red));

  }

  int newStyleId = page->getStyleId(newIndex);

  /*-  StudioPalette上でStyleを追加した場合、GlobalNameを自動で割り振る -*/

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

    TColorStyle *cs = palette->getStyle(newStyleId);

    std::wstring gname =

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

    cs->setGlobalName(gname);

  }

  page->getStyle(newIndex)->setName(

      QString("color_%1").arg(newStyleId).toStdWString());

  paletteHandle->setStyleIndex(newStyleId);

  palette->setDirtyFlag(true);

  paletteHandle->notifyPaletteChanged();

  TUndoManager::manager()->add(new CreateStyleUndo(

      paletteHandle, page->getIndex(), page->getStyleId(newIndex)));

}

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

// addStyles

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

namespace {

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

// AddStylesUndo

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

class AddStylesUndo : public TUndo {

  TPaletteP m_palette;

  int m_pageIndex;

  int m_indexInPage;

  std::vector<std::pair<tcolorstyle *,="" int="">> m_styles;</std::pair<tcolorstyle>

  TPaletteHandle *m_paletteHandle;

public:

  // creare DOPO l'inserimento

  AddStylesUndo(const TPaletteP &palette, int pageIndex, int indexInPage,

                int count, TPaletteHandle *paletteHandle)

      : m_palette(palette)

      , m_pageIndex(pageIndex)

      , m_indexInPage(indexInPage)

      , m_paletteHandle(paletteHandle) {

    assert(m_palette);

    assert(0 <= m_pageIndex && m_pageIndex < m_palette->getPageCount());

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

    assert(page);

    assert(0 <= indexInPage && indexInPage + count <= page->getStyleCount());

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

      std::pair<tcolorstyle *,="" int=""> p;</tcolorstyle>

      p.second = page->getStyleId(m_indexInPage + i);

      p.first  = m_palette->getStyle(p.second)->clone();

      m_styles.push_back(p);

    }

  }

  ~AddStylesUndo() {

    for (int i = 0; i < (int)m_styles.size(); i++) delete m_styles[i].first;

  }

  void undo() const {

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

    assert(page);

    int count = m_styles.size();

    int i;

    for (i = count - 1; i >= 0; i--) page->removeStyle(m_indexInPage + i);

    m_paletteHandle->notifyPaletteChanged();

  }

  void redo() const {

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

    assert(page);

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

      TColorStyle *cs = m_styles[i].first->clone();

      int styleId     = m_styles[i].second;

      assert(m_palette->getStylePage(styleId) == 0);

      m_palette->setStyle(styleId, cs);

      page->insertStyle(m_indexInPage + i, styleId);

    }

    m_paletteHandle->notifyPaletteChanged();

  }

  int getSize() const {

    return sizeof *this + m_styles.size() * sizeof(TColorStyle);

  }

  QString getHistoryString() {

    return QObject::tr("Add Style  to Palette %1")

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

  }

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

};

}  // namespace

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

/*- ドラッグ＆ドロップ時に呼ばれる -*/

void PaletteCmd::addStyles(TPaletteHandle *paletteHandle, int pageIndex,

                           int indexInPage,

                           const std::vector<tcolorstyle *=""> &styles) {</tcolorstyle>

  TPalette *palette = paletteHandle->getPalette();

  assert(0 <= pageIndex && pageIndex < palette->getPageCount());

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

  assert(page);

  assert(0 <= indexInPage && indexInPage <= page->getStyleCount());

  int count = styles.size();

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

    page->insertStyle(indexInPage + i, styles[i]->clone());

    /*-- StudioPaletteから持ち込んだ場合、その元の名前をoriginalNameに入れる

     * --*/

    if (styles[i]->getGlobalName() != L"") {

      /*--

       * もし元のStyleにOriginalNameが無ければ（コピー元がStudioPaletteからということ）--*/

      if (styles[i]->getOriginalName() == L"") {

        /*-- 元のStyleの名前をペースト先のOriginalNameに入れる --*/

        page->getStyle(indexInPage + i)->setOriginalName(styles[i]->getName());

      }

    }

    /*--

     * それ以外の場合は、clone()でそれぞれの名前をコピーしているので、そのままでOK

     * --*/

  }

  TUndoManager::manager()->add(

      new AddStylesUndo(palette, pageIndex, indexInPage, count, paletteHandle));

  palette->setDirtyFlag(true);

}

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

// eraseStyles

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

namespace {

void eraseStylesInLevels(const set<txshsimplelevel *=""> &levels,</txshsimplelevel>

                         const std::vector<int> styleIds) {</int>

  for (auto const level : levels) {

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

    level->getFids(fids);

    int i;

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

      TImageP image    = level->getFrame(fids[i], true);

      TVectorImageP vi = image;

      TToonzImageP ti  = image;

      if (vi)

        vi->eraseStyleIds(styleIds);

      else if (ti)

        TRop::eraseStyleIds(ti.getPointer(), styleIds);

    }

  }

}

}  // namespace

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

void PaletteCmd::eraseStyles(const std::set<txshsimplelevel *=""> &levels,</txshsimplelevel>

                             const std::vector<int> &styleIds) {</int>

  typedef std::pair<const std::vector<tvectorimagep="" txshsimplelevelp,="">></const>

      LevelImages;

  struct Undo : public TUndo {

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

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

    mutable std::map<txshsimplelevelp, std::vector<tvectorimagep="">></txshsimplelevelp,>

        m_imagesByLevel;

  public:

    Undo(const std::set<txshsimplelevel *=""> &levels,</txshsimplelevel>

         const std::vector<int> &styleIds)</int>

        : m_levels(levels), m_styleIds(styleIds) {

      tcg::substitute(m_imagesByLevel,

                      levels | boost::adaptors::filtered(isVector) |

                          boost::adaptors::transformed(toEmptyLevelImages));

    }

    bool isValid() const { return !m_levels.empty(); }

    void redo() const {

      std::for_each(m_imagesByLevel.begin(), m_imagesByLevel.end(),

                    cloneImages);

      eraseStylesInLevels(m_levels, m_styleIds);

    }

    void undo() const {

      std::for_each(m_imagesByLevel.begin(), m_imagesByLevel.end(),

                    restoreImages);

    }

    int getSize() const { return 10 << 20; }  // At max 10 per 100 MB

  private:

    static bool isVector(const TXshSimpleLevel *level) {

      return (assert(level), level->getType() == PLI_XSHLEVEL);

    }

    static LevelImages toEmptyLevelImages(TXshSimpleLevel *level) {

      return LevelImages(level, std::vector<tvectorimagep>());</tvectorimagep>

    }

    static void copyStrokeIds(const TVectorImage &src, TVectorImage &dst) {

      UINT s, sCount = src.getStrokeCount();

      for (s = 0; s != sCount; ++s)

        dst.getStroke(s)->setId(src.getStroke(s)->getId());

    }

    static TVectorImageP cloneImage(const TXshSimpleLevel &level, int f) {

      TVectorImageP src = static_cast<tvectorimagep>(</tvectorimagep>

          level.getFrame(level.getFrameId(f), false));

      TVectorImageP dst = src->clone();

      copyStrokeIds(*src, *dst);

      return dst;

    }

    static void cloneImages(LevelImages &levelImages) {

      tcg::substitute(

          levelImages.second,

          boost::counting_range(0, levelImages.first->getFrameCount()) |

              boost::adaptors::transformed(boost::bind(

                  cloneImage, boost::cref(*levelImages.first), _1)));

    }

    static void restoreImage(const TXshSimpleLevelP &level, int f,

                             const TVectorImageP &vi) {

      level->setFrame(level->getFrameId(f), vi.getPointer());

    }

    static void restoreImages(LevelImages &levelImages) {

      int f, fCount = std::min(levelImages.first->getFrameCount(),

                               int(levelImages.second.size()));

      for (f = 0; f != fCount; ++f)

        restoreImage(levelImages.first, f, levelImages.second[f]);

    }

  };  // Undo

  if (levels.empty() || styleIds.empty()) return;

  std::auto_ptr<tundo> undo(new Undo(levels, styleIds));</tundo>

  if (static_cast<undo &="">(*undo).isValid()) {</undo>

    undo->redo();

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

  }

}

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

// addPage

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

namespace {

class AddPageUndo : public TUndo {

  TPaletteHandle *m_paletteHandle;

  TPaletteP m_palette;

  int m_pageIndex;

  std::wstring m_pageName;

  std::vector<std::pair<tcolorstyle *,="" int="">> m_styles;</std::pair<tcolorstyle>

public:

  // creare DOPO l'inserimento

  AddPageUndo(TPaletteHandle *paletteHandle, int pageIndex,

              std::wstring pageName)

      : m_paletteHandle(paletteHandle)

      , m_pageIndex(pageIndex)

      , m_pageName(pageName) {

    m_palette = m_paletteHandle->getPalette();

    assert(m_palette);

    assert(0 <= m_pageIndex && m_pageIndex < m_palette->getPageCount());

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

    assert(page);

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

      std::pair<tcolorstyle *,="" int=""> p;</tcolorstyle>

      p.first  = page->getStyle(i)->clone();

      p.second = page->getStyleId(i);

      m_styles.push_back(p);

    }

  }

  ~AddPageUndo() {

    for (int i = 0; i < (int)m_styles.size(); i++) delete m_styles[i].first;

  }

  void undo() const {

    m_palette->erasePage(m_pageIndex);

    m_paletteHandle->notifyPaletteChanged();

  }

  void redo() const {

    TPalette::Page *page = m_palette->addPage(m_pageName);

    assert(page);

    assert(page->getIndex() == m_pageIndex);

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

      TColorStyle *cs = m_styles[i].first->clone();

      int styleId     = m_styles[i].second;

      assert(m_palette->getStylePage(styleId) == 0);

      m_palette->setStyle(styleId, cs);

      page->addStyle(styleId);

    };

    m_paletteHandle->notifyPaletteChanged();

  }

  int getSize() const {

    return sizeof *this + m_styles.size() * sizeof(TColorStyle);

  }

  QString getHistoryString() {

    return QObject::tr("Add Page %1 to Palette %2")

        .arg(QString::fromStdWString(m_pageName))

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

  }

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

};

}  // namespace

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

void PaletteCmd::addPage(TPaletteHandle *paletteHandle, std::wstring name,

                         bool withUndo) {

  TPalette *palette = paletteHandle->getPalette();

  if (name == L"")

    name = L"page " + std::to_wstring(palette->getPageCount() + 1);

  TPalette::Page *page = palette->addPage(name);

  palette->setDirtyFlag(true);

  paletteHandle->notifyPaletteChanged();

  if (withUndo)

    TUndoManager::manager()->add(

        new AddPageUndo(paletteHandle, page->getIndex(), name));

}

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

// destroyPage

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

namespace {

class DestroyPageUndo : public TUndo {

  TPaletteHandle *m_paletteHandle;

  TPaletteP m_palette;

  int m_pageIndex;

  std::wstring m_pageName;

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

public:

  DestroyPageUndo(TPaletteHandle *paletteHandle, int pageIndex)

      : m_paletteHandle(paletteHandle), m_pageIndex(pageIndex) {

    m_palette = m_paletteHandle->getPalette();

    assert(m_palette);

    assert(0 <= pageIndex && pageIndex < m_palette->getPageCount());

    assert(m_palette->getPageCount() > 1);

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

    assert(page);

    m_pageName = page->getName();

    m_styles.resize(page->getStyleCount());

    for (int i    = 0; i < page->getStyleCount(); i++)

      m_styles[i] = page->getStyleId(i);

  }

  void undo() const {

    TPalette::Page *page = m_palette->addPage(m_pageName);

    m_palette->movePage(page, m_pageIndex);

    for (int i = 0; i < (int)m_styles.size(); i++) page->addStyle(m_styles[i]);

    m_paletteHandle->notifyPaletteChanged();

  }

  void redo() const {

    m_palette->erasePage(m_pageIndex);

    m_paletteHandle->notifyPaletteChanged();

  }

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

  QString getHistoryString() {

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

        .arg(QString::fromStdWString(m_pageName))

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

  }

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

};

}  // namespace

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

void PaletteCmd::destroyPage(TPaletteHandle *paletteHandle, int pageIndex) {

  TPalette *palette = paletteHandle->getPalette();

  assert(0 <= pageIndex && pageIndex < palette->getPageCount());

  TUndoManager::manager()->add(new DestroyPageUndo(paletteHandle, pageIndex));

  palette->erasePage(pageIndex);

  palette->setDirtyFlag(true);

  paletteHandle->notifyPaletteChanged();

}

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

// ReferenceImage

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

namespace {

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

// SetReferenceImageUndo

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

class SetReferenceImageUndo : public TUndo {

  TPaletteP m_palette;

  TPaletteP m_oldPalette, m_newPalette;

  TPaletteHandle *m_paletteHandle;

public:

  SetReferenceImageUndo(TPaletteP palette, TPaletteHandle *paletteHandle)

      : m_palette(palette)

      , m_oldPalette(palette->clone())

      , m_paletteHandle(paletteHandle) {}

  void onAdd() { m_newPalette = m_palette->clone(); }

  void undo() const {

    m_palette->assign(m_oldPalette.getPointer());

    m_paletteHandle->notifyPaletteChanged();

  }

  void redo() const {

    m_palette->assign(m_newPalette.getPointer());

    m_paletteHandle->notifyPaletteChanged();

  }

  int getSize() const { return sizeof(*this) + sizeof(TPalette) * 2; }

  QString getHistoryString() {

    return QObject::tr("Load Color Model %1  to Palette %2")

        .arg(QString::fromStdString(

            m_newPalette->getRefImgPath().getLevelName()))

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

  }

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

};

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

// loadRefImage

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

int loadRefImage(TPaletteHandle *paletteHandle,

                 PaletteCmd::ColorModelPltBehavior pltBehavior,

                 TPaletteP levelPalette, const TFilePath &_fp, int &frame,

                 ToonzScene *scene, const std::vector<int> &frames) {</int>

  bool paletteAlreadyLoaded = false;

  TFilePath fp              = scene->decodeFilePath(_fp);

  if (_fp == TFilePath()) {

    paletteAlreadyLoaded = true;

    fp                   = levelPalette->getRefImgPath();

  }

  TImageP img;

  try {

    TLevelReaderP lr(fp);

    if (fp != TFilePath() && lr) {

      TLevelP level = lr->loadInfo();

      if (level && level->getFrameCount() > 0) {

        TLevel::Iterator it;

        if (!paletteAlreadyLoaded) {

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

          for (it = level->begin(); it != level->end(); ++it) {

            if (it->first == -1 || it->first == -2) {

              assert(level->getFrameCount() == 1);

              fids.push_back(0);

              break;

            }

            // if the frame list is empty, store all fids of the level

            if (frames.empty()) {

              fids.push_back(it->first);

              continue;

            }

            // if the frame list is specified, load only the frames matches with

            // the list

            else {

              std::vector<int>::const_iterator framesIt;</int>

              for (framesIt = frames.begin(); framesIt != frames.end();

                   framesIt++) {

                if (it->first.getNumber() == *framesIt) {

                  fids.push_back(it->first);

                  break;

                }

              }

            }

          }

          levelPalette->setRefLevelFids(fids);

        }

        if (frame <= 0) frame = level->begin()->first.getNumber();

        const TLevel::Table *table = level->getTable();

        TFrameId fid(frame);

        if (table->find(fid) != table->end()) {

          img = lr->getFrameReader(fid)->load();

          if (img && img->getPalette() == 0) {

            if (paletteAlreadyLoaded || level->getPalette() != 0)

              img->setPalette(level->getPalette());

            else if ((fp.getType() == "tzp" || fp.getType() == "tzu"))

              img->setPalette(ToonzImageUtils::loadTzPalette(

                  fp.withType("plt").withNoFrame()));

          }

        }

      }

    } else

      img = levelPalette->getRefImg();

  } catch (TException &e) {

    std::wcout << L"error: " << e.getMessage() << std::endl;

  } catch (...) {

    std::cout << "error for other reasons" << std::endl;

  }

  if (!img) return 1;

  if (paletteAlreadyLoaded) {

    img->setPalette(0);

    levelPalette->setRefImgPath(_fp);

    return 0;