// System includes

#include "tsystem.h"

#include "timagecache.h"

// Geometry

#include "tgeometry.h"

// Image

#include "tiio.h"

#include "timageinfo.h"

#include "trop.h"

#include "tropcm.h"

// Sound

#include "tsop.h"

#include "tsound.h"

// Strings

#include "tconvert.h"

// File-related includes

#include "tfilepath.h"

#include "tfiletype.h"

#include "filebrowsermodel.h"

#include "fileviewerpopup.h"

// OpenGL

#include "tgl.h"

#include "tvectorgl.h"

#include "tvectorrenderdata.h"

// Qt helpers

#include "toonzqt/gutil.h"

#include "toonzqt/imageutils.h"

// App-Stage includes

#include "tapp.h"

#include "toutputproperties.h"

#include "toonz/txsheethandle.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/levelproperties.h"

#include "toonz/tscenehandle.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tcamera.h"

#include "toonz/preferences.h"

#include "toonz/tproject.h"

// Image painting

#include "toonz/imagepainter.h"

// Preview

#include "previewfxmanager.h"

// Panels

#include "pane.h"

// recent files

#include "mainwindow.h"

// Other widgets

#include "toonzqt/flipconsole.h"

#include "toonzqt/dvdialog.h"

#include "filmstripselection.h"

#include "castselection.h"

#include "histogrampopup.h"

// Qt includes

#include <qapplication></qapplication>

#include <qdesktopwidget></qdesktopwidget>

#include <qsettings></qsettings>

#include <qpainter></qpainter>

#include <qdialogbuttonbox></qdialogbuttonbox>

#include <qabstractbutton></qabstractbutton>

#include <qlabel></qlabel>

#include <qradiobutton></qradiobutton>

#include <qslider></qslider>

#include <qbuttongroup></qbuttongroup>

#include <qtoolbar></qtoolbar>

#include <qmainwindow></qmainwindow>

#include <qurl></qurl>

#include <qobject></qobject>

#include <qdesktopservices></qdesktopservices>

#include <qvboxlayout></qvboxlayout>

#include <qhboxlayout></qhboxlayout>

#include <qpushbutton></qpushbutton>

#include <stdint.h>  // for uintptr_t</stdint.h>

#ifdef _WIN32

#include "avicodecrestrictions.h"

#endif

#include "flipbook.h"

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

using namespace ImageUtils;

namespace {

QString getShortcut(const char *id) {

  return QString::fromStdString(

      CommandManager::instance()->getShortcutFromId(id));

}

}  // namespace

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

namespace {

/* inline TRect getImageBounds(const TImageP& img)

  {

    if(TRasterImageP ri= img)

      return ri->getRaster()->getBounds();

    else if(TToonzImageP ti= img)

      return ti->getRaster()->getBounds();

    else

    {

      TVectorImageP vi= img;

      return convert(vi->getBBox());

    }

  }*/

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

inline TRectD getImageBoundsD(const TImageP &img) {

  if (TRasterImageP ri = img)

    return TRectD(0, 0, ri->getRaster()->getLx(), ri->getRaster()->getLy());

  else if (TToonzImageP ti = img)

    return TRectD(0, 0, ti->getSize().lx, ti->getSize().ly);

  else {

    TVectorImageP vi = img;

    return vi->getBBox();

  }

}

}  // namespace

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

/*! \class FlipBook

                \brief The FlipBook class provides to view level images.

                Inherits \b QWidget.

                The object is composed of grid layout \b QGridLayout which

   contains an image

                viewer \b ImageViewer and a double button bar. It is possible

   decide widget

                title and which button bar show by setting QString and bool in

   constructor.

                You can set level to show in FlipBook using \b setLevel(); and

   call

                onDrawFrame() to show FlipBook current frame. The current frame

   can be

                set directly using setCurrentFrame(int index) or using slot

   methods connected

                to button bar.

    \sa FlipBookPool class.

*/

FlipBook::FlipBook(QWidget *parent, QString viewerTitle,

                   std::vector<int> flipConsoleButtonMask, UCHAR flags,</int>

                   bool isColorModel)  //, bool showOnlyPlayBackgroundButton)

    : QWidget(parent)

    , m_viewerTitle(viewerTitle)

    , m_levelNames()

    , m_levels()

    , m_playSound(false)

    , m_snd(0)

    , m_player(0)

    //, m_doCompare(false)

    , m_currentFrameToSave(0)

    , m_lw()

    , m_lr()

    , m_loadPopup(0)

    , m_savePopup(0)

    , m_shrink(1)

    , m_isPreviewFx(false)

    , m_previewedFx(0)

    , m_previewXsh(0)

    , m_previewUpdateTimer(this)

    , m_xl(0)

    , m_title1()

    , m_poolIndex(-1)

    , m_freezed(false)

    , m_loadbox()

    , m_dim()

    , m_loadboxes()

    , m_freezeButton(0)

    , m_flags(flags) {

  setAcceptDrops(true);

  setFocusPolicy(Qt::StrongFocus);

  // flipConsoleButtonMask = flipConsoleButtonMask & ~FlipConsole::eSubCamera;

  ImageUtils::FullScreenWidget *fsWidget =

      new ImageUtils::FullScreenWidget(this);

  m_imageViewer = new ImageViewer(

      fsWidget, this,

      std::find(flipConsoleButtonMask.begin(), flipConsoleButtonMask.end(),

                FlipConsole::eHisto) == flipConsoleButtonMask.end());

  fsWidget->setWidget(m_imageViewer);

  setFocusProxy(m_imageViewer);

  m_title = m_viewerTitle;

  m_imageViewer->setIsColorModel(isColorModel);

  // layout

  QVBoxLayout *mainLayout = new QVBoxLayout(this);

  mainLayout->setMargin(0);

  mainLayout->setSpacing(0);

  {

    mainLayout->addWidget(fsWidget, 1);

    m_flipConsole = new FlipConsole(

        mainLayout, flipConsoleButtonMask, true, 0,

        (viewerTitle == "") ? "FlipConsole" : viewerTitle, this, !isColorModel);

    mainLayout->addWidget(m_flipConsole);

  }

  setLayout(mainLayout);

  // signal-slot connection

  bool ret = connect(m_flipConsole, SIGNAL(buttonPressed(FlipConsole::EGadget)),

                     this, SLOT(onButtonPressed(FlipConsole::EGadget)));

  m_flipConsole->setFrameRate(TApp::instance()

                                  ->getCurrentScene()

                                  ->getScene()

                                  ->getProperties()

                                  ->getOutputProperties()

                                  ->getFrameRate());

  mainLayout->addWidget(m_flipConsole);

  m_previewUpdateTimer.setSingleShot(true);

  ret = ret && connect(parentWidget(), SIGNAL(closeButtonPressed()), this,

                       SLOT(onCloseButtonPressed()));

  ret = ret && connect(parentWidget(), SIGNAL(doubleClick(QMouseEvent *)), this,

                       SLOT(onDoubleClick(QMouseEvent *)));

  ret = ret && connect(&m_previewUpdateTimer, SIGNAL(timeout()), this,

                       SLOT(performFxUpdate()));

  assert(ret);

  m_viewerTitle = (m_viewerTitle.isEmpty()) ? tr("Flipbook") : m_viewerTitle;

  parentWidget()->setWindowTitle(m_viewerTitle);

}

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

/*! add freeze button to the flipbook. called from the function

   PreviewFxManager::openFlipBook.

        this button will hide for re-use, at onCloseButtonPressed

*/

void FlipBook::addFreezeButtonToTitleBar() {

  // If there is the button already, then reuse it.

  if (m_freezeButton) {

    m_freezeButton->show();

    return;

  }

  // If there is not, then newly make it

  TPanel *panel = qobject_cast<tpanel *="">(parentWidget());</tpanel>

  if (panel) {

    TPanelTitleBar *titleBar = panel->getTitleBar();

    m_freezeButton           = new TPanelTitleBarButton(

        titleBar, getIconThemePath("actions/20/pane_freeze.svg"));

    m_freezeButton->setToolTip("Freeze");

    titleBar->add(QPoint(-64, 0), m_freezeButton);

    connect(m_freezeButton, SIGNAL(toggled(bool)), this, SLOT(freeze(bool)));

    QPoint p(titleBar->width() - 64, 0);

    m_freezeButton->move(p);

    m_freezeButton->show();

  }

}

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

void FlipBook::freeze(bool on) {

  if (on)

    freezePreview();

  else

    unfreezePreview();

}

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

void FlipBook::focusInEvent(QFocusEvent *e) {

  m_flipConsole->makeCurrent();

  QWidget::focusInEvent(e);

}

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

namespace {

enum { eBegin, eIncrement, eEnd };

static DVGui::ProgressDialog *Pd = 0;

class ProgressBarMessager final : public TThread::Message {

public:

  int m_choice;

  int m_val;

  QString m_str;

  ProgressBarMessager(int choice, int val, const QString &str = "")

      : m_choice(choice), m_val(val), m_str(str) {}

  void onDeliver() override {

    switch (m_choice) {

    case eBegin:

      if (!Pd)

        Pd = new DVGui::ProgressDialog(

            QObject::tr("Saving previewed frames...."), QObject::tr("Cancel"),

            0, m_val);

      else

        Pd->setMaximum(m_val);

      Pd->show();

      break;

    case eIncrement:

      if (Pd->wasCanceled()) {

        delete Pd;

        Pd = 0;

      } else {

        // if (m_val==Pd->maximum()) Pd->hide();

        Pd->setValue(m_val);

      }

      break;

    case eEnd: {

      DVGui::info(m_str);

      delete Pd;

      Pd = 0;

    } break;

    default:

      assert(false);

    }

  }

  TThread::Message *clone() const override {

    return new ProgressBarMessager(*this);

  }

};

}  // namespace

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

LoadImagesPopup::LoadImagesPopup(FlipBook *flip)

    : FileBrowserPopup(tr("Load Images"), Options(WITH_APPLY_BUTTON),

                       tr("Append"), new QFrame(0))

    , m_flip(flip)

    , m_minFrame(0)

    , m_maxFrame(1000000)

    , m_step(1)

    , m_shrink(1) {

  QFrame *frameRangeFrame = (QFrame *)m_customWidget;

  frameRangeFrame->setObjectName("customFrame");

  frameRangeFrame->setFrameStyle(QFrame::StyledPanel);

  // frameRangeFrame->setFixedHeight(30);

  m_fromField   = new DVGui::LineEdit(this);

  m_toField     = new DVGui::LineEdit(this);

  m_stepField   = new DVGui::LineEdit("1", this);

  m_shrinkField = new DVGui::LineEdit("1", this);

  // Define the append/load filter types

  m_appendFilterTypes << "3gp"

                      << "mov"

                      << "jpg"

                      << "png"

                      << "tga"

                      << "tif"

                      << "tiff"

                      << "bmp"

                      << "sgi"

                      << "rgb"

                      << "nol";

#ifdef _WIN32

  m_appendFilterTypes << "avi";

#endif

  m_loadFilterTypes << "tlv"

                    << "pli" << m_appendFilterTypes;

  m_appendFilterTypes << "psd";

  // layout

  QHBoxLayout *frameRangeLayout = new QHBoxLayout();

  frameRangeLayout->setMargin(5);

  frameRangeLayout->setSpacing(5);

  {

    frameRangeLayout->addStretch(1);

    frameRangeLayout->addWidget(new QLabel(tr("From:")), 0);

    frameRangeLayout->addWidget(m_fromField, 0);

    frameRangeLayout->addSpacing(5);

    frameRangeLayout->addWidget(new QLabel(tr("To:")), 0);

    frameRangeLayout->addWidget(m_toField, 0);

    frameRangeLayout->addSpacing(10);

    frameRangeLayout->addWidget(new QLabel(tr("Step:")), 0);

    frameRangeLayout->addWidget(m_stepField, 0);

    frameRangeLayout->addSpacing(5);

    frameRangeLayout->addWidget(new QLabel(tr("Shrink:")));

    frameRangeLayout->addWidget(m_shrinkField, 0);

  }

  frameRangeFrame->setLayout(frameRangeLayout);

  // Make signal-slot connections

  bool ret = true;

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

                       SLOT(onEditingFinished()));

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

                       SLOT(onEditingFinished()));

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

                       SLOT(onEditingFinished()));

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

                       SLOT(onEditingFinished()));

  ret = ret && connect(this, SIGNAL(filePathClicked(const TFilePath &)),

                       SLOT(onFilePathClicked(const TFilePath &)));

  assert(ret);

  setOkText(tr("Load"));

  setWindowTitle(tr("Load / Append Images"));

}

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

void LoadImagesPopup::onEditingFinished() {

  int val;

  val    = m_fromField->text().toInt();

  m_from = (val < m_minFrame) ? m_minFrame : val;

  val    = m_toField->text().toInt();

  m_to   = (val > m_maxFrame) ? m_maxFrame : val;

  if (m_to < m_from) m_to = m_from;

  val      = m_stepField->text().toInt();

  m_step   = (val < 1) ? 1 : val;

  val      = m_shrinkField->text().toInt();

  m_shrink = (val < 1) ? 1 : val;

  m_fromField->setText(QString::number(m_from));

  m_toField->setText(QString::number(m_to));

  m_stepField->setText(QString::number(m_step));

  m_shrinkField->setText(QString::number(m_shrink));

}

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

bool LoadImagesPopup::execute() { return doLoad(false); }

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

/*! Append images with apply button

 */

bool LoadImagesPopup::executeApply() { return doLoad(true); }

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

bool LoadImagesPopup::doLoad(bool append) {

  if (m_selectedPaths.empty()) return false;

  ::viewFile(*m_selectedPaths.begin(), m_from, m_to, m_step, m_shrink, 0,

             m_flip, append);

  // register recent files

  std::set<tfilepath>::const_iterator pt;</tfilepath>

  for (pt = m_selectedPaths.begin(); pt != m_selectedPaths.end(); ++pt) {

    RecentFiles::instance()->addFilePath(

        toQString(

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

                (*pt))),

        RecentFiles::Flip);

  }

  return true;

}

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

void LoadImagesPopup::onFilePathClicked(const TFilePath &fp) {

  TLevel::Iterator it;

  TLevelP level;

  TLevelReaderP lr;

  if (fp == TFilePath()) goto clear;

  lr = TLevelReaderP(fp);

  if (!lr) goto clear;

  level = lr->loadInfo();

  if (!level || level->getFrameCount() == 0) goto clear;

  it   = level->begin();

  m_to = m_from = it->first.getNumber();

  for (; it != level->end(); ++it) m_to = it->first.getNumber();

  if (m_from == -2 && m_to == -2) m_from = m_to = 1;

  m_minFrame = m_from;

  m_maxFrame = m_to;

  m_fromField->setText(QString::number(m_from));

  m_toField->setText(QString::number(m_to));

  return;

clear:

  m_minFrame = 0;

  m_maxFrame = 10000000;

  m_fromField->setText("");

  m_toField->setText("");

}

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

SaveImagesPopup::SaveImagesPopup(FlipBook *flip)

    : FileBrowserPopup(tr("Save Flipbook Images")), m_flip(flip) {

  setOkText(tr("Save"));

}

bool SaveImagesPopup::execute() {

  if (m_selectedPaths.empty()) return false;

  return m_flip->doSaveImages(*m_selectedPaths.begin());

}

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

void FlipBook::loadImages() {

  if (!m_loadPopup) {

    m_loadPopup = new LoadImagesPopup(this);  //, frameRangeFrame);

    // move the initial folder to the project root

    m_loadPopup->setFolder(

        TProjectManager::instance()->getCurrentProjectPath().getParentDir());

  }

  m_loadPopup->show();

  m_loadPopup->raise();

  m_loadPopup->activateWindow();

}

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

bool FlipBook::canAppend() {

  // Images can be appended if:

  //  a) There is a name (in particular, an extension) representing currently

  //  held ones.

  //  b) This flipbook is not holding a preview (inappropriate and problematic).

  //  c) The level has no palette. Otherwise, appended images may have a

  //  different palette.

  return !m_levels.empty() && !m_previewedFx && !m_palette;

}

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

void FlipBook::saveImages() {

  if (!m_savePopup) m_savePopup = new SaveImagesPopup(this);

  // initialize the default path every time

  TOutputProperties *op = TApp::instance()

                              ->getCurrentScene()

                              ->getScene()

                              ->getProperties()

                              ->getOutputProperties();

  m_savePopup->setFolder(TApp::instance()

                             ->getCurrentScene()

                             ->getScene()

                             ->decodeFilePath(op->getPath())

                             .getParentDir());

  m_savePopup->setFilename(op->getPath().withFrame().withoutParentDir());

  m_savePopup->show();

  m_savePopup->raise();

  m_savePopup->activateWindow();

}

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

FlipBook::~FlipBook() {

  if (m_loadPopup) delete m_loadPopup;

  if (m_savePopup) delete m_savePopup;

}

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

bool FlipBook::doSaveImages(TFilePath fp) {

  QStringList formats;

  TLevelWriter::getSupportedFormats(formats, true);

  Tiio::Writer::getSupportedFormats(formats, true);

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

  TOutputProperties *outputSettings =

      scene->getProperties()->getOutputProperties();

  std::string ext = fp.getType();

  // Open a notice that the previewFx is rendered in 8bpc regardless of the

  // output settings.

  if (m_isPreviewFx && outputSettings->getRenderSettings().m_bpp == 64) {

    QString question =

        "Save previewed images :\nImages will be saved in 8 bit per channel "

        "with this command.\nDo you want to save images?";

    int ret =

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

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

  }

#ifdef _WIN32

  if (ext == "avi") {

    TPropertyGroup *props = outputSettings->getFileFormatProperties(ext);

    std::string codecName = props->getProperty(0)->getValueAsString();

    TDimension res        = scene->getCurrentCamera()->getRes();

    if (!AviCodecRestrictions::canWriteMovie(::to_wstring(codecName), res)) {

      QString msg(

          QObject::tr("The resolution of the output camera does not fit with "

                      "the options chosen for the output file format."));

      DVGui::warning(msg);

      return false;

    }

  }

#endif

  if (ext == "") {

    ext = outputSettings->getPath().getType();

    fp  = fp.withType(ext);

  }

  if (fp.getName() == "") {

    DVGui::warning(

        tr("The file name cannot be empty or contain any of the following "

           "characters:(new line)  \\ / : * ? \"  |"));

    return false;

  }

  if (!formats.contains(QString::fromStdString(ext))) {

    DVGui::warning(

        tr("It is not possible to save because the selected file format is not "

           "supported."));

    return false;

  }

  int from, to, step;

  m_flipConsole->getFrameRange(from, to, step);

  if (m_currentFrameToSave != 0) {

    DVGui::info("Already saving!");

    return true;

  }

  if (TFileType::getInfo(fp) == TFileType::RASTER_IMAGE || ext == "pct" ||

      ext == "pic" || ext == "pict")  // pct e' un formato"livello" (ha i

                                      // settings di quicktime) ma fatto di

                                      // diversi frames

    fp = fp.withFrame(TFrameId::EMPTY_FRAME);

  fp          = scene->decodeFilePath(fp);

  bool exists = TFileStatus(fp.getParentDir()).doesExist();

  if (!exists) {

    try {

      TFilePath parent = fp.getParentDir();

      TSystem::mkDir(parent);

      DvDirModel::instance()->refreshFolder(parent.getParentDir());

    } catch (TException &e) {

      DVGui::error("Cannot create " + toQString(fp.getParentDir()) + " : " +

                   QString(::to_string(e.getMessage()).c_str()));

      return false;

    } catch (...) {

      DVGui::error("Cannot create " + toQString(fp.getParentDir()));

      return false;

    }

  }

  if (TSystem::doesExistFileOrLevel(fp)) {

    QString question(tr("File %1 already exists.\nDo you want to overwrite it?")

                         .arg(toQString(fp)));

    int ret = DVGui::MsgBox(question, QObject::tr("Overwrite"),

                            QObject::tr("Cancel"));

    if (ret == 2) return false;

  }

  try {

    m_lw = TLevelWriterP(fp,

                         outputSettings->getFileFormatProperties(fp.getType()));

  } catch (...) {

    DVGui::error("It is not possible to save Flipbook content.");

    return false;

  }

  m_lw->setFrameRate(outputSettings->getFrameRate());

  m_currentFrameToSave = 1;

  ProgressBarMessager(eBegin, m_framesCount).sendBlocking();

  QTimer::singleShot(50, this, SLOT(saveImage()));

  return true;

}

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

void FlipBook::saveImage() {

  static int savedFrames = 0;

  assert(Pd);

  int from, to, step;

  m_flipConsole->getFrameRange(from, to, step);

  for (; m_currentFrameToSave <= m_framesCount; m_currentFrameToSave++) {

    ProgressBarMessager(eIncrement, m_currentFrameToSave).sendBlocking();

    if (!Pd) break;

    int actualFrame = from + (m_currentFrameToSave - 1) * step;

    TImageP img     = getCurrentImage(actualFrame);

    if (!img) continue;

    TImageWriterP writer = m_lw->getFrameWriter(TFrameId(actualFrame));

    bool failureOnSaving = false;

    if (!writer) continue;

    try {

      writer->save(img);

    } catch (...) {

      QString str(tr("It is not possible to save Flipbook content."));

      ProgressBarMessager(eEnd, 0, str).send();

      m_currentFrameToSave = 0;

      m_lw                 = TLevelWriterP();

      savedFrames          = 0;

      return;

    }

    savedFrames++;

    //		if (!m_pb->changeFraction(m_currentFrameToSave,

    // TApp::instance()->getCurrentXsheet()->getXsheet()->getFrameCount()))

    //			break;

    m_currentFrameToSave++;

    QTimer::singleShot(50, this, SLOT(saveImage()));

    return;

  }

  QString str = tr("Saved %1 frames out of %2 in %3")

                    .arg(std::to_string(savedFrames).c_str())

                    .arg(std::to_string(m_framesCount).c_str())

                    .arg(::to_string(m_lw->getFilePath()).c_str());

  if (!Pd) str = "Canceled! " + str;

  ProgressBarMessager(eEnd, 0, str).send();

  m_currentFrameToSave = 0;

  m_lw                 = TLevelWriterP();

  savedFrames          = 0;

}

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

void FlipBook::onButtonPressed(FlipConsole::EGadget button) {

  switch (button) {

  case FlipConsole::eSound:

    m_playSound = !m_playSound;

    break;

  case FlipConsole::eHisto:

    m_imageViewer->showHistogram();

    break;

  case FlipConsole::eSaveImg: {

    TRect loadbox = m_loadbox;

    m_loadbox     = TRect();

    TImageP img   = getCurrentImage(m_flipConsole->getCurrentFrame());

    m_loadbox     = loadbox;

    if (!img) {

      DVGui::warning(tr("There are no rendered images to save."));

      return;

    } else if ((TVectorImageP)img) {

      DVGui::warning(

          tr("It is not possible to take or compare snapshots for Toonz vector "

             "levels."));

      return;

    }

    TRasterImageP ri(img);

    TToonzImageP ti(img);

    TImageP clonedImg;

    if (ri)

      clonedImg = TRasterImageP(ri->getRaster()->clone());

    else {

      clonedImg = TToonzImageP(ti->getRaster()->clone(), ti->getSavebox());

      clonedImg->setPalette(ti->getPalette());

    }

    TImageCache::instance()->add(QString("TnzCompareImg"), clonedImg);

    // to update the histogram of compare snapshot image

    m_imageViewer->invalidateCompHisto();

    break;

  }

  case FlipConsole::eCompare:

    if (m_flipConsole->isChecked(FlipConsole::eCompare) &&

        (TVectorImageP)getCurrentImage(m_flipConsole->getCurrentFrame())) {

      DVGui::warning(

          tr("It is not possible to take or compare snapshots for Toonz vector "

             "levels."));

      // cancel the button pressing

      m_flipConsole->pressButton(FlipConsole::eCompare);

      return;

    }

    break;

  case FlipConsole::eSave:

    saveImages();

    break;

  default:

    break;

  }

}

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

// FlipBookPool

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

/*! \class FlipBookPool

                \brief The FlipBookPool class is used to store used flipbook

   viewers.

    Flipbooks are generally intended as temporary but friendly floating widgets,

    that gets displayed when a rendered scene or image needs to be shown.

    Since a user may require that the geometry of a flipbook is to be remembered

    between rendering tasks - perhaps even between different Toonz sessions -

    flipbooks are always stored for later use in a \b FlipBookPool class.

    This class implements the basical features to \b pop a flipbook from the

   pool

    or \b push a used one; plus, it provides the \b save and \b load functions

    for persistent storage between Toonz sessions.

    \sa FlipBook class.

*/

FlipBookPool::FlipBookPool() : m_overallFlipCount(0) {

  qRegisterMetaType<imagepainter::visualsettings>(</imagepainter::visualsettings>

      "ImagePainter::VisualSettings");

}

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

FlipBookPool::~FlipBookPool() {}

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

FlipBookPool *FlipBookPool::instance() {

  static FlipBookPool poolInstance;

  return &poolInstance;

}

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

void FlipBookPool::push(FlipBook *flipbook) {

  m_pool.insert(pair<int, *="" flipbook="">(flipbook->getPoolIndex(), flipbook));</int,>

}

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

//! Extracts the first unused flipbook from the flipbook pool.

//! If all known flipbooks are shown, allocates a new flipbook with the

//! first unused flipbook geometry in a geometry pool.

//! Again, if all recorded geometry are used by some existing flipbook, a

//! default geometry is used.

FlipBook *FlipBookPool::pop() {

  FlipBook *flipbook;

  TPanel *panel;