#include "toonzqt/flipconsole.h"

// TnzQt includes

#include "toonzqt/menubarcommand.h"

#include "toonzqt/dvscrollwidget.h"

#include "toonzqt/gutil.h"

#include "toonzqt/flipconsoleowner.h"

// TnzLib includes

#include "toonz/preferences.h"

#include "toonz/tframehandle.h"

// TnzBase includes

#include "tenv.h"

// TnzCore includes

#include "tconvert.h"

#include "timagecache.h"

#include "trop.h"

#include "../toonz/tapp.h"

#include <time.h></time.h>

// Qt includes

#include <qvboxlayout></qvboxlayout>

#include <qhboxlayout></qhboxlayout>

#include <qtoolbar></qtoolbar>

#include <qlabel></qlabel>

#include <qframe></qframe>

#include <qslider></qslider>

#include <qtimerevent></qtimerevent>

#include <qtoolbutton></qtoolbutton>

#include <qpainter></qpainter>

#include <qmouseevent></qmouseevent>

#include <qicon></qicon>

#include <qaction></qaction>

#include <qwidgetaction></qwidgetaction>

#include <qstyle></qstyle>

#include <qstylepainter></qstylepainter>

#include <qstyleoption></qstyleoption>

#include <qstyleoptionframev3></qstyleoptionframev3>

#include <qsettings></qsettings>

#include <qpushbutton></qpushbutton>

#include <qscrollbar></qscrollbar>

using namespace DVGui;

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

//    Preliminary stuff - local namespace

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

TEnv::IntVar FlipBookWhiteBgToggle("FlipBookWhiteBgToggle", 1);

TEnv::IntVar FlipBookBlackBgToggle("FlipBookBlackBgToggle", 0);

TEnv::IntVar FlipBookCheckBgToggle("FlipBookCheckBgToggle", 0);

namespace {

// Please refer to the "qss/standard/standard.qss" file for explanations of the

// following properties.

int PBHeight;

QImage PBOverlay;

QImage PBMarker;

int PBColorMarginLeft   = 0;

int PBColorMarginTop    = 0;

int PBColorMarginRight  = 0;

int PBColorMarginBottom = 0;

int PBMarkerMarginLeft  = 0;

int PBMarkerMarginRight = 0;

QColor PBBaseColor       = QColor(235, 235, 235);

QColor PBNotStartedColor = QColor(210, 40, 40);

QColor PBStartedColor    = QColor(220, 160, 160);

QColor PBFinishedColor   = QColor(235, 235, 235);

}  // namespace

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

int FlipSlider::getPBHeight() const { return PBHeight; }

void FlipSlider::setPBHeight(int height) {

  setFixedHeight(height);

  PBHeight = height;

}

QImage FlipSlider::getPBOverlay() const { return PBOverlay; }

void FlipSlider::setPBOverlay(const QImage &img) { PBOverlay = img; }

QImage FlipSlider::getPBMarker() const { return PBMarker; }

void FlipSlider::setPBMarker(const QImage &img) { PBMarker = img; }

int FlipSlider::getPBColorMarginLeft() const { return PBColorMarginLeft; }

void FlipSlider::setPBColorMarginLeft(int margin) {

  PBColorMarginLeft = margin;

}

int FlipSlider::getPBColorMarginTop() const { return PBColorMarginTop; }

void FlipSlider::setPBColorMarginTop(int margin) { PBColorMarginTop = margin; }

int FlipSlider::getPBColorMarginRight() const { return PBColorMarginRight; }

void FlipSlider::setPBColorMarginRight(int margin) {

  PBColorMarginRight = margin;

}

int FlipSlider::getPBColorMarginBottom() const { return PBColorMarginBottom; }

void FlipSlider::setPBColorMarginBottom(int margin) {

  PBColorMarginBottom = margin;

}

int FlipSlider::getPBMarkerMarginLeft() const { return PBMarkerMarginLeft; }

void FlipSlider::setPBMarkerMarginLeft(int margin) {

  PBMarkerMarginLeft = margin;

}

int FlipSlider::getPBMarkerMarginRight() const { return PBMarkerMarginRight; }

void FlipSlider::setPBMarkerMarginRight(int margin) {

  PBMarkerMarginRight = margin;

}

QColor FlipSlider::getBaseColor() const { return PBBaseColor; }

void FlipSlider::setBaseColor(const QColor &color) { PBBaseColor = color; }

QColor FlipSlider::getNotStartedColor() const { return PBNotStartedColor; }

void FlipSlider::setNotStartedColor(const QColor &color) {

  PBNotStartedColor = color;

}

QColor FlipSlider::getStartedColor() const { return PBStartedColor; }

void FlipSlider::setStartedColor(const QColor &color) {

  PBStartedColor = color;

}

QColor FlipSlider::getFinishedColor() const { return PBFinishedColor; }

void FlipSlider::setFinishedColor(const QColor &color) {

  PBFinishedColor = color;

}

FlipConsole *FlipConsole::m_currentConsole = 0;

QList<flipconsole *=""> FlipConsole::m_visibleConsoles;</flipconsole>

bool FlipConsole::m_isLinkedPlaying = false;

bool FlipConsole::m_areLinked       = false;

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

PlaybackExecutor::PlaybackExecutor() : m_fps(25), m_abort(false) {}

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

void PlaybackExecutor::resetFps(int fps) { m_fps = fps; }

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

void PlaybackExecutor::run() {

  // (Daniele)

  // We'll build the fps considering an interval of roughly 1 second (the last

  // one). However, the fps should be sampled at a faster rate. Each sample is

  // taken at 1/4 second, and the last 4 samples data are stored to keep trace

  // of the last second of playback.

  m_timer.start();

  qint64 timeResolution =

      250 * 1000000;  // Use a sufficient sampling resolution (currently 1/4

                      // sec). Fps calculation is made once per sample.

  int fps = m_fps, currSample = 0;

  qint64 playedFramesCount = 0;

  qint64 nextSampleInstant = timeResolution;

  qint64 lastFrameCounts[4]    = {0, 0, 0,

                                  0};  // Keep the last 4 'played frames' counts.

  qint64 lastSampleInstants[4] = {0, 0, 0,

                                  0};  // Same for the last sampling instants

  qint64 targetFrameTime =

      1000000000 / (qint64)abs(m_fps);  // User-required time between frames

  qint64 emissionInstant = 0;  // starting instant in which rendering is invoked

  qint64 avgSwapTime     = 0;  // average time for swapping buffers

  qint64 shortTermDelayAdjuster =

      0;  // accumurate recent errors and adjust in short term

  while (!m_abort) {

    emissionInstant = m_timer.nsecsElapsed();

    if (emissionInstant > nextSampleInstant) {

      // Fps calculation

      qint64 framesCount = playedFramesCount - lastFrameCounts[currSample];

      qint64 elapsedTime = emissionInstant - lastSampleInstants[currSample];

      fps                = troundp((long double)(1000000000 * framesCount) /

                                   (long double)elapsedTime);

      targetFrameTime =

          1000000000 / (qint64)abs(m_fps);  // m_fps could have changed...

      // estimate time for swapping buffers

      qint64 avgSwapTimeD = (elapsedTime / framesCount) - targetFrameTime;

      if (avgSwapTime - avgSwapTimeD >

          20000000)  // Reset beyond, say, 20 msecs tolerance.

        avgSwapTime = avgSwapTimeD;

      else

        avgSwapTime += avgSwapTimeD;

      avgSwapTime = std::min(targetFrameTime, std::max(avgSwapTime, (qint64)0));

      // prepare for the next sampling

      lastFrameCounts[currSample]    = playedFramesCount;

      lastSampleInstants[currSample] = emissionInstant;

      currSample                     = (currSample + 1) % 4;

      nextSampleInstant              = emissionInstant + timeResolution;

    }

    // draw the next frame

    if (playedFramesCount) {

      qint64 delayAdjust = shortTermDelayAdjuster / 4;

      qint64 targetInstant =

          emissionInstant + targetFrameTime - avgSwapTime - delayAdjust;

      targetInstant = std::max(targetInstant, emissionInstant);

      shortTermDelayAdjuster -= delayAdjust;

      // Show the next frame, telling currently measured fps

      // For the Flipbook, the wait time will be inserted at the end of paintGL

      // in order to achieve precise playback

      emit nextFrame(fps, &m_timer, targetInstant);

      // Playing on Viewer / Combo Viewer will advance the current frame.

      // Calling qApp->processEvents() on drawing frame causes repaint of other

      // panels which slows playback. Therefore in Viewer / Combo Viewer panels

      // it just calls update() and necessary wait will be inserted here.

      qint64 currentInstant = m_timer.nsecsElapsed();

      while (currentInstant < targetInstant) {

        currentInstant = m_timer.nsecsElapsed();

      }

      if (FlipConsole::m_areLinked) {

        // In case there are linked consoles, update them too.

        // Their load time must be included in the fps calculation.

        int i, consolesCount = FlipConsole::m_visibleConsoles.size();

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

          FlipConsole *console = FlipConsole::m_visibleConsoles.at(i);

          if (console->isLinkable() && console != FlipConsole::m_currentConsole)

            console->playbackExecutor().emitNextFrame(m_fps < 0 ? -fps : fps);

        }

      }

    }

    //-------- Each nextFrame() blocks until the frame has been shown ---------

    // accumurate error and slightly adjust waiting time for subsequent frames

    qint64 delay = m_timer.nsecsElapsed() - emissionInstant - targetFrameTime;

    // just ignore a large error

    if (delay < targetFrameTime) shortTermDelayAdjuster += delay;

    ++playedFramesCount;

  }

  m_abort = false;

  m_timer.invalidate();

}

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

FlipSlider::FlipSlider(QWidget *parent)

    : QAbstractSlider(parent), m_enabled(false), m_progressBarStatus(0) {

  setObjectName("FlipSlider");

  setOrientation(Qt::Horizontal);

  setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);

}

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

void FlipSlider::paintEvent(QPaintEvent *ev) {

  QPainter p(this);

  // Draw the progress status colorbar

  QRect sliderRect(QPoint(), size());

  QRect colorRect(sliderRect.adjusted(PBMarkerMarginLeft, PBColorMarginTop,

                                      -PBMarkerMarginRight,

                                      -PBColorMarginBottom));

  int val, maxValuePlusStep = maximum() + singleStep();

  int colorWidth = colorRect.width(), colorHeight = colorRect.height();

  p.setPen(Qt::NoPen);

  int currPos = PBColorMarginLeft, nextPos;

  // paint the base of slider

  if (m_enabled && m_progressBarStatus && !m_progressBarStatus->empty()) {

    unsigned int i, pbStatusSize = m_progressBarStatus->size();

    for (i = 0, val = minimum() + singleStep(); i < pbStatusSize;

         ++i, val += singleStep()) {

      nextPos = sliderPositionFromValue(minimum(), maxValuePlusStep, val,

                                        colorWidth) +

                PBMarkerMarginLeft;

      if (i == pbStatusSize - 1) nextPos += PBMarkerMarginRight;

      p.fillRect(currPos, PBColorMarginTop, nextPos - currPos, colorHeight,

                 ((*m_progressBarStatus)[i] == PBFrameStarted) ? PBStartedColor

                 : ((*m_progressBarStatus)[i] == PBFrameFinished)

                     ? PBFinishedColor

                     : PBNotStartedColor);

      currPos = nextPos;

    }

    // Draw frames outside the pb

    if (val < maximum())

      p.fillRect(currPos, PBColorMarginTop,

                 width() - PBColorMarginRight - currPos, colorHeight,

                 PBNotStartedColor);

  } else

    p.fillRect(PBColorMarginLeft, PBColorMarginTop,

               sliderRect.width() - PBColorMarginLeft - PBColorMarginRight,

               colorHeight, PBBaseColor);

  // Draw the PB Overlay

  int overlayInnerWidth =

      PBOverlay.width() - PBColorMarginLeft - PBColorMarginRight;

  int markerInnerWidth =

      PBMarker.width() - PBMarkerMarginLeft - PBMarkerMarginRight;

  p.drawImage(QRect(0, 0, PBColorMarginLeft, height()), PBOverlay,

              QRect(0, 0, PBColorMarginLeft, PBOverlay.height()));

  p.drawImage(

      QRect(PBColorMarginLeft, 0,

            sliderRect.width() - PBColorMarginLeft - PBColorMarginRight,

            height()),

      PBOverlay,

      QRect(PBColorMarginLeft, 0, overlayInnerWidth, PBOverlay.height()));

  p.drawImage(

      QRect(width() - PBColorMarginRight, 0, PBColorMarginRight, height()),

      PBOverlay,

      QRect(PBOverlay.width() - PBColorMarginRight, 0, PBColorMarginRight,

            PBOverlay.height()));

  // Draw the position marker

  currPos = sliderPositionFromValue(minimum(), maxValuePlusStep, value(),

                                    colorWidth) +

            PBMarkerMarginLeft;

  nextPos = sliderPositionFromValue(minimum(), maxValuePlusStep,

                                    value() + singleStep(), colorWidth) +

            PBMarkerMarginLeft;

  p.drawImage(

      QRect(currPos - PBMarkerMarginLeft, 0, PBMarkerMarginLeft, height()),

      PBMarker, QRect(0, 0, PBMarkerMarginLeft, PBMarker.height()));

  p.drawImage(

      QRect(currPos, 0, nextPos - currPos, height()), PBMarker,

      QRect(PBMarkerMarginLeft, 0, markerInnerWidth, PBMarker.height()));

  p.drawImage(QRect(nextPos, 0, PBMarkerMarginRight, height()), PBMarker,

              QRect(PBMarker.width() - PBMarkerMarginRight, 0,

                    PBMarkerMarginRight, PBMarker.height()));

}

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

inline int FlipSlider::sliderPositionFromValue(int min, int max, int val,

                                               int span) {

  return tceil(span * ((val - min) / (double)(max - min)));

}

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

inline int FlipSlider::sliderValueFromPosition(int min, int max, int step,

                                               int pos, int span) {

  int colorBarPos     = pos - PBColorMarginLeft;

  int colorSpan       = span - PBColorMarginLeft - PBColorMarginRight;

  int tempRelativePos = (max - min + step) * (colorBarPos / (double)colorSpan);

  return min + (tempRelativePos - tempRelativePos % step);

}

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

inline int FlipSlider::pageStepVal(int val) {

  return tcrop(value() + pageStep() * tsign(val - value()), minimum(),

               maximum());

}

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

// Mouse Press behaviour:

//  a) If middle button, just put frame to cursor position

//  b) If left button, and cursor on current frame pos, do like (a)

//  c) If left button, and cursor NOT on curr.. perform a page up/down on

//     the side of cursor pos

void FlipSlider::mousePressEvent(QMouseEvent *me) {

  emit flipSliderPressed();

  int cursorValue = sliderValueFromPosition(minimum(), maximum(), singleStep(),

                                            me->pos().x(), width());

  if (me->button() == Qt::MidButton)

    if (cursorValue == value())

      setSliderDown(true);

    else {

      // Move the page step

      setValue(pageStepVal(cursorValue));

    }

  else if (me->button() == Qt::LeftButton && cursorValue != value())

    setValue(cursorValue);

}

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

void FlipSlider::mouseMoveEvent(QMouseEvent *me) {

  if (isSliderDown() || me->buttons() & Qt::LeftButton) {

    int cursorValue = sliderValueFromPosition(

        minimum(), maximum(), singleStep(), me->pos().x(), width());

    setValue(cursorValue);

  }

}

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

void FlipSlider::mouseReleaseEvent(QMouseEvent *me) {

  setSliderDown(false);

  emit flipSliderReleased();

}

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

enum {

  eShowCompare         = 0x001,

  eShowBg              = 0x002,

  eShowFramerate       = 0x004,

  eShowVcr             = 0x008,

  eShowcolorFilter     = 0x010,

  eShowCustom          = 0x020,

  eShowHisto           = 0x040,

  eShowSave            = 0x080,

  eShowDefineSubCamera = 0x100,

  eShowFilledRaster    = 0x200,

  eShowDefineLoadBox   = 0x400,

  eShowUseLoadBox      = 0x800,

  eShowViewerControls  = 0x1000,

  eShowSound           = 0x2000,

  eShowLocator         = 0x4000,

  eShowHowMany         = 0x8000

};

FlipConsole::FlipConsole(QVBoxLayout *mainLayout, std::vector<int> gadgetsMask,</int>

                         bool isLinkable, QWidget *customWidget,

                         const QString &customizeId,

                         FlipConsoleOwner *consoleOwner, bool enableBlanks)

    : m_gadgetsMask(gadgetsMask)

    , m_from(1)

    , m_to(1)

    , m_step(1)

    , m_currentFrame(1)

    , m_framesCount(1)

    , m_settings()

    , m_fps(24)

    , m_sceneFps(24)

    , m_isPlay(false)

    , m_reverse(false)

    , m_doubleRed(0)

    , m_doubleGreen(0)

    , m_doubleBlue(0)

    , m_doubleRedAction(0)

    , m_doubleGreenAction(0)

    , m_doubleBlueAction(0)

    , m_fpsSlider(0)

    , m_markerFrom(0)

    , m_markerTo(-1)

    , m_playbackExecutor()

    , m_drawBlanksEnabled(enableBlanks)

    , m_blanksCount(0)

    , m_blankColor(TPixel::Transparent)

    , m_blanksToDraw(0)

    , m_isLinkable(isLinkable)

    , m_customAction(0)

    , m_customizeMask(eShowHowMany - 1)

    , m_fpsLabelAction(0)

    , m_fpsSliderAction(0)

    , m_fpsFieldAction(0)

    , m_fpsField(0)

    , m_customizeId(customizeId)

    , m_histoSep(0)

    , m_filledRasterSep(0)

    , m_viewerSep(0)

    , m_bgSep(0)

    , m_vcrSep(0)

    , m_compareSep(0)

    , m_saveSep(0)

    , m_colorFilterSep(0)

    , m_subcamSep(0)

    , m_playToolBar(0)

    , m_colorFilterGroup(0)

    , m_fpsLabel(0)

    , m_consoleOwner(consoleOwner)

    , m_enableBlankFrameButton(0) {

  QString s = QSettings().value(m_customizeId).toString();

  if (s != "") m_customizeMask = s.toUInt();

  if (m_gadgetsMask.size() == 0) return;

  // mainLayout->setMargin(1);

  // mainLayout->setSpacing(0);

  // create toolbars other than frame slider

  if (hasButton(m_gadgetsMask, eFrames)) {

    createPlayToolBar(customWidget);

    m_playToolBarContainer = new ToolBarContainer();

    QHBoxLayout *hLayout = new QHBoxLayout;

    hLayout->setMargin(0);

    hLayout->setSpacing(0);

    hLayout->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);

    {

      DvScrollWidget *scrollableContainer = new DvScrollWidget;

      scrollableContainer->setWidget(m_playToolBar);

      hLayout->addWidget(scrollableContainer);

      // show fps

      if (hasButton(m_gadgetsMask, eRate)) {

        QFrame *fpsSliderFrame = createFpsSlider();

        hLayout->addWidget(fpsSliderFrame, 1);

      }

    }

    m_playToolBarContainer->setLayout(hLayout);

    mainLayout->addWidget(m_playToolBarContainer);

  }

  // create frame slider

  if (hasButton(m_gadgetsMask, eFrames)) {

    m_frameSliderFrame = createFrameSlider();

    mainLayout->addWidget(m_frameSliderFrame);

  }

  applyCustomizeMask();

  bool ret = connect(&m_playbackExecutor,

                     SIGNAL(nextFrame(int, QElapsedTimer *, qint64)), this,

                     SLOT(onNextFrame(int, QElapsedTimer *, qint64)),

                     Qt::BlockingQueuedConnection);

  assert(ret);

  // parent->setLayout(mainLayout);

}

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

void FlipConsole::showHideAllParts(bool isShow) {

  m_playToolBarContainer->setVisible(isShow);

  m_frameSliderFrame->setVisible(isShow);

}

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

void FlipConsole::showHidePlaybar(bool isShow) {

  m_playToolBarContainer->setVisible(isShow);

}

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

void FlipConsole::showHideFrameSlider(bool isShow) {

  m_frameSliderFrame->setVisible(isShow);

}

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

void showEvent(QShowEvent *);

void hideEvent(QHideEvent *);

void FlipConsole::makeCurrent() {

  if (m_currentConsole == this) return;

  int i = m_visibleConsoles.indexOf(this);

  if (i >= 0) m_visibleConsoles.takeAt(i);

  m_visibleConsoles.append(this);

  m_currentConsole = this;

}

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

void FlipConsole::setActive(bool active) {

  if (active)

    makeCurrent();

  else {

    pressButton(ePause);

    int i = m_visibleConsoles.indexOf(this);

    if (i >= 0) m_visibleConsoles.takeAt(i);

    if (m_currentConsole == this) {

      if (!m_visibleConsoles.empty())

        m_currentConsole = m_visibleConsoles.last();

      else

        m_currentConsole = 0;

    }

  }

}

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

#define LX 22

#define LY 22

class DoubleButton final : public QToolButton {

  QAction *m_firstAction, *m_secondAction;

  QIcon::Mode m_firstMode, m_secondMode;

  QIcon::State m_firstState, m_secondState;

  bool m_enabled;

public:

  DoubleButton(QAction *firstAction, QAction *secondAction, QWidget *parent = 0)

      : QToolButton(parent)

      , m_firstAction(firstAction)

      , m_secondAction(secondAction)

      , m_firstMode(QIcon::Normal)

      , m_secondMode(QIcon::Normal)

      , m_firstState(QIcon::Off)

      , m_secondState(QIcon::Off)

      , m_enabled(true) {

    setFixedSize(LX, LY);

    setMouseTracking(true);

    setObjectName("flipDoubleButton");

  }

  void setEnabledSecondButton(bool state) {

    if (!state && m_secondAction->isChecked()) m_secondAction->trigger();

    m_enabled = state;

    update();

  }

protected:

  void paintEvent(QPaintEvent *e) override {

    QPainter p(this);

    p.drawPixmap(0, 0,

                 m_firstAction->icon().pixmap(

                     QSize(LX, LY / 2),

                     m_firstAction->isChecked() ? QIcon::Normal : m_firstMode,

                     m_firstAction->isChecked() ? QIcon::On : m_firstState));

    QIcon::Mode mode =

        m_enabled ? (m_secondAction->isChecked() ? QIcon::Normal : m_secondMode)

                  : QIcon::Disabled;

    QIcon::State state =

        m_enabled ? (m_secondAction->isChecked() ? QIcon::On : m_secondState)

                  : QIcon::Off;

    p.drawPixmap(0, LY / 2 + 1,

                 m_secondAction->icon().pixmap(QSize(LX, LY / 2), mode, state));

  }

  void mousePressEvent(QMouseEvent *e) override {

    QRect firstActionRect(0, 0, LX, LY / 2);

    QRect secondActionRect(0, LY / 2 + 1, LX, LY / 2);

    QPoint pos = e->pos();

    if (firstActionRect.contains(pos)) {

      m_firstAction->trigger();

    } else {

      if (m_enabled) m_secondAction->trigger();

    }

    update();

  }

  void mouseMoveEvent(QMouseEvent *e) override {

    QPoint pos = e->pos();

    QRect firstActionRect(0, 0, LX, LY / 2);

    QRect secondActionRect(0, LY / 2 + 1, LX, LY / 2);

    m_firstState  = QIcon::Off;

    m_secondState = QIcon::Off;

    m_firstMode   = QIcon::Normal;

    m_secondMode  = QIcon::Normal;

    if (firstActionRect.contains(pos)) {

      m_firstMode = QIcon::Active;

      setToolTip(m_firstAction->toolTip());

    } else if (secondActionRect.contains(pos) && m_enabled) {

      m_secondMode = QIcon::Active;

      setToolTip(m_secondAction->toolTip());

    }

    update();

  }

  void leaveEvent(QEvent *e) override {

    m_firstMode   = QIcon::Normal;

    m_firstState  = QIcon::Off;

    m_secondMode  = QIcon::Normal;

    m_secondState = QIcon::Off;

    update();

    QToolButton::leaveEvent(e);

  }

};

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

void FlipConsole::enableButton(UINT button, bool enable, bool doShowHide) {

  if (!m_playToolBar) return;

  QList<qaction *=""> list = m_playToolBar->actions();</qaction>

  for (size_t i = 0; i < list.size(); i++)

    if (list[i]->data().toUInt() == button) {

      if (button == eSound) {

        if (doShowHide) {

          m_soundSep->setVisible(enable);

        } else {

          m_soundSep->setEnabled(enable);

        }

      }

      if (button == eHisto) {

        if (doShowHide) {

          m_histoSep->setVisible(enable && m_customizeMask & eShowHisto);

        } else {

          m_histoSep->setEnabled(enable);

        }

      }

      if (doShowHide) {

        list[i]->setVisible(enable);

      } else {

        list[i]->setEnabled(enable);

      }

      if (!enable && list[i]->isChecked()) pressButton((EGadget)button);

      return;

    }

  // double buttons are special, they are not accessible directly from the

  // playtoolbar...

  switch ((EGadget)button) {

  case eGRed:

    if (m_doubleRed) m_doubleRed->setEnabledSecondButton(enable);

    break;

  case eGGreen:

    if (m_doubleGreen) m_doubleGreen->setEnabledSecondButton(enable);

    break;

  case eGBlue:

    if (m_doubleBlue) m_doubleBlue->setEnabledSecondButton(enable);

    break;

  default:

    break;

  }

}

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

void FlipConsole::toggleLinked() {

  m_areLinked = !m_areLinked;

  int i;

  FlipConsole *playingConsole = 0;

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

    playingConsole = m_visibleConsoles.at(i);

    if (playingConsole->m_isLinkable &&

        playingConsole->m_playbackExecutor.isRunning())

      break;

  }

  if (i == m_visibleConsoles.size()) return;

  // if we are here, flip is playing!

  m_isLinkedPlaying = m_areLinked;

  int button =

      m_areLinked ? (playingConsole->m_isPlay ? ePlay : eLoop) : ePause;

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

    FlipConsole *console = m_visibleConsoles.at(i);

    if (console->m_isLinkable && console != playingConsole) {

      console->setChecked(button, true);

      console->doButtonPressed(button);

    }

  }

}

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

bool FlipConsole::drawBlanks(int from, int to, QElapsedTimer *timer,

                             qint64 target) {

  if (m_blanksCount == 0 || m_isPlay || m_framesCount <= 1) return false;

  // enable blanks only when the blank button is pressed

  if (m_enableBlankFrameButton && !m_enableBlankFrameButton->isChecked())

    return false;

  if (m_blanksToDraw > 1 ||

      (m_blanksToDraw == 0 &&

       ((m_reverse && m_currentFrame - m_step < from) ||

        (!m_reverse && m_currentFrame + m_step >

                           to))))  // we are on the last frame of the loop

  {

    m_blanksToDraw = (m_blanksToDraw == 0 ? m_blanksCount : m_blanksToDraw - 1);

    m_settings.m_blankColor     = m_blankColor;

    m_settings.m_drawBlankFrame = true;

    m_consoleOwner->onDrawFrame(from, m_settings, timer, target);

    m_settings.m_drawBlankFrame = false;

    return true;

  }

  m_blanksToDraw = 0;

  return false;

}

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

void FlipConsole::onNextFrame(int fps, QElapsedTimer *timer,

                              qint64 targetInstant) {

  if (playbackExecutor().isAborted()) return;

  if (fps < 0)  // can be negative only if is a linked console; it means that

                // the master console is playing backward

  {

    bool reverse = m_reverse;

    m_reverse    = true;

    fps          = -fps;

    playNextFrame(timer, targetInstant);

    m_reverse = reverse;

  } else

    playNextFrame(timer, targetInstant);

  if (fps == -1) return;

  if (m_fpsLabel)

    m_fpsLabel->setText(tr(" FPS ") + QString::number(fps * tsign(m_fps)) +

                        "/");

  if (m_fpsField) {

    if (fps == abs(m_fps))

      m_fpsField->setLineEditBackgroundColor(Qt::green);

    else

      m_fpsField->setLineEditBackgroundColor(Qt::red);

  }

  if (m_stopAt > 0 && m_currentFrame >= m_stopAt) {

    doButtonPressed(ePause);

    m_stopAt = -1;

  }

}

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

void FlipConsole::playNextFrame(QElapsedTimer *timer, qint64 targetInstant) {

  int from = m_from, to = m_to;

  if (m_markerFrom <= m_markerTo && m_stopAt == -1)

    from = m_markerFrom, to = m_markerTo;

  if (m_framesCount == 0 ||

      (m_isPlay && m_currentFrame == (m_reverse ? from : to))) {

    doButtonPressed(ePause);

    setChecked(m_isPlay ? ePlay : eLoop, false);

    setChecked(ePause, true);

    if (Preferences::instance()->rewindAfterPlaybackEnabled())

      m_currentFrame = (m_reverse ? to : from);

    emit playStateChanged(false);

  } else {

    if (drawBlanks(from, to, timer, targetInstant)) return;

    if (m_reverse)

      m_currentFrame =

          ((m_currentFrame - m_step < from) ? to : m_currentFrame - m_step);

    else

      m_currentFrame =

          ((m_currentFrame + m_step > to) ? from : m_currentFrame + m_step);

  }

  m_currFrameSlider->setValue(m_currentFrame);

  m_editCurrFrame->setText(QString::number(m_currentFrame));

  m_settings.m_blankColor        = TPixel::Transparent;

  m_settings.m_recomputeIfNeeded = true;

  m_consoleOwner->onDrawFrame(m_currentFrame, m_settings, timer, targetInstant);

}

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

void FlipConsole::updateCurrentFPS(int val) {

  setCurrentFPS(val);

  m_fpsSlider->setValue(m_fps);

}

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

void FlipConsole::setFrameRate(int val, bool forceUpdate) {

  if (m_sceneFps != val || forceUpdate) {

    if (!m_fpsSlider) return;

    m_fpsSlider->setValue(val);

    setCurrentFPS(val);

  }

  m_sceneFps = val;

}

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