#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"

// 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);

}

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

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.

	TStopWatch timer;

	timer.start();

	TUINT32 timeResolution = 250; // Use a sufficient sampling resolution (currently 1/4 sec).

								  // Fps calculation is made once per sample.

	int fps = m_fps, currSample = 0;

	TUINT32 playedFramesCount = 0;

	TUINT32 loadedInstant, nextSampleInstant = timeResolution;

	TUINT32 sampleTotalLoadingTime = 0;

	TUINT32 lastFrameCounts[4] = {0, 0, 0, 0};	// Keep the last 4 'played frames' counts.

	TUINT32 lastSampleInstants[4] = {0, 0, 0, 0}; // Same for the last sampling instants

	TUINT32 lastLoadingTimes[4] = {0, 0, 0, 0};   // Same for total sample loading times

	double targetFrameTime = 1000.0 / abs(m_fps); // User-required time between frames

	TUINT32 emissionInstant = 0;   // Effective instant in which loading is invoked

	double emissionInstantD = 0.0; // Double precision version of the above

	double lastLoadingTime = 0.0; // Mean frame loading time in the last sample

	while (!m_abort) {

		emissionInstant = timer.getTotalTime();

		// Draw the next frame

		emit nextFrame(fps); // Show the next frame, telling

							 // currently measured fps

		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 ---------

		++playedFramesCount;

		loadedInstant = timer.getTotalTime();

		sampleTotalLoadingTime += (loadedInstant - emissionInstant);

		// Recalculate data only after the specified time resolution has passed.

		if (loadedInstant > nextSampleInstant) {

			// Sampling instant. Perform calculations.

			// Store values

			TUINT32 framesCount = playedFramesCount - lastFrameCounts[currSample];

			TUINT32 elapsedTime = loadedInstant - lastSampleInstants[currSample];

			double loadingTime = (sampleTotalLoadingTime - lastLoadingTimes[currSample]) / (double)framesCount;

			lastFrameCounts[currSample] = playedFramesCount;

			lastSampleInstants[currSample] = loadedInstant;

			lastLoadingTimes[currSample] = sampleTotalLoadingTime;

			currSample = (currSample + 1) % 4;

			nextSampleInstant = loadedInstant + timeResolution;

			// Rebuild current fps

			fps = troundp((1000 * framesCount) / (double)elapsedTime);

			targetFrameTime = 1000.0 / abs(m_fps); // m_fps could have changed...

			// In case the playback is too slow to keep the required pace, reset the emission timeline.

			// Otherwise, it should be kept as the difference needs to be compensated to get the required fps.

			if ((int)emissionInstant - (int)emissionInstantD > 20) // Reset beyond, say, 20 msecs tolerance.

				emissionInstantD = (double)loadedInstant - loadingTime;

			else

				emissionInstantD += lastLoadingTime - loadingTime; // Otherwise, just adapt to the new loading time

			lastLoadingTime = loadingTime;

		}

		// Calculate the new emission instant

		emissionInstant = tmax((int)(emissionInstantD += targetFrameTime), 0);

		// Sleep until the next emission instant has been reached

		while (timer.getTotalTime() < emissionInstant)

			msleep(1);

	}

	m_abort = false;

}

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

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,

	eShowHowMany = 0x1000

};

FlipConsole::FlipConsole(QVBoxLayout *mainLayout,

						 UINT gadgetsMask,

						 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_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_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 == 0)

		return;

	//mainLayout->setMargin(1);

	//mainLayout->setSpacing(0);

	//create toolbars other than frame slider

	if (m_gadgetsMask & (~eFrames)) {

		createPlayToolBar(customWidget != 0);

		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 (m_gadgetsMask & eRate) {

				QFrame *fpsSliderFrame = createFpsSlider();

				hLayout->addWidget(fpsSliderFrame, 1);

			}

		}

		m_playToolBarContainer->setLayout(hLayout);

		mainLayout->addWidget(m_playToolBarContainer);

	}

	// create frame slider

	if (m_gadgetsMask & eFrames) {

		m_frameSliderFrame = createFrameSlider();

		mainLayout->addWidget(m_frameSliderFrame);

	}

	if (customWidget) {

		m_customAction = m_playToolBar->addWidget(customWidget);

		m_customSep = m_playToolBar->addSeparator();

	}

	applyCustomizeMask();

	bool ret = connect(&m_playbackExecutor, SIGNAL(nextFrame(int)), this, SLOT(onNextFrame(int)), Qt::BlockingQueuedConnection);

	assert(ret);

	//parent->setLayout(mainLayout);

}

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

void FlipConsole::showHideAllParts(bool isShow)

{

	m_playToolBarContainer->setVisible(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 21

#define LY 17

class DoubleButton : 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);

	}

	void setEnabledSecondButton(bool state)

	{

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

			m_secondAction->trigger();

		m_enabled = state;

		update();

	}

protected:

	void paintEvent(QPaintEvent *e)

	{

		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)

	{

		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)

	{

		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)

	{

		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 defined(MACOSX) //on mac, the sound playback in flip is broken..

	if (button == eSound)

		enable = false;

#endif

	if (!m_playToolBar)

		return;

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

	int i;

	for (i = 0; i < (int)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);

		CASE eGGreen : if (m_doubleGreen)

						   m_doubleGreen->setEnabledSecondButton(enable);

		CASE eGBlue : if (m_doubleBlue)

						  m_doubleBlue->setEnabledSecondButton(enable);

		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)

{

	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);

		m_settings.m_drawBlankFrame = false;

		return true;

	}

	m_blanksToDraw = 0;

	return false;

}

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

void FlipConsole::onNextFrame(int fps)

{

	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();

		m_reverse = reverse;

	} else

		playNextFrame();

	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);

	}

}

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

void FlipConsole::playNextFrame()

{

	int from = m_from, to = m_to;

	if (m_markerFrom <= m_markerTo)

		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))

			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);

}

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

void FlipConsole::updateCurrentFPS(int val)

{

	setCurrentFPS(val);

	m_fpsSlider->setValue(m_fps);

}

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

void FlipConsole::setFrameRate(int val)

{

	if (!m_fpsSlider)

		return;

	m_fpsSlider->setValue(val);

	setCurrentFPS(val);

}

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

void FlipConsole::setCurrentFPS(bool dragging)

{

	setCurrentFPS(m_fpsField->getValue());

	m_fpsSlider->setValue(m_fps);

}

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

void FlipConsole::setCurrentFPS(int val)

{

	if (m_fps == val)

		return;

	if (val == 0)

		val = 1;

	m_fps = val;

	m_fpsField->setValue(m_fps);

	if (m_playbackExecutor.isRunning() || m_isLinkedPlaying)

		m_reverse = (val < 0);

	if (m_fpsLabel)

		m_fpsLabel->setText(tr(" FPS "));

	if (m_fpsField)

		m_fpsField->setLineEditBackgroundColor(Qt::transparent);

	m_playbackExecutor.resetFps(m_fps);

}

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

void FlipConsole::createButton(UINT buttonMask, const char *iconStr, const QString &tip, bool checkable, QActionGroup *group)

{

	QIcon icon = createQIconPNG(iconStr);

	QAction *action = new QAction(icon, tip, m_playToolBar);

	action->setData(QVariant(buttonMask));

	action->setCheckable(checkable);

	if (group)

		group->addAction(action);

	m_actions[(EGadget)buttonMask] = action;

	m_playToolBar->addAction(action);

}

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

QAction *FlipConsole::createCheckedButtonWithBorderImage(UINT buttonMask, const char *iconStr, const QString &tip, bool checkable, QActionGroup *group, const char *cmdId)

{

	QIcon icon = createQIconPNG(iconStr);

	QWidgetAction *action = new QWidgetAction(m_playToolBar);

	action->setIcon(icon);

	action->setToolTip(tip);

	action->setData(QVariant(buttonMask));

	action->setCheckable(checkable);

	if (group)

		group->addAction(action);

	QToolButton *button = new QToolButton(m_playToolBar);

	button->setDefaultAction(action);

	m_buttons[(EGadget)buttonMask] = button;

	if (cmdId) {

		QAction *a = CommandManager::instance()->getAction(cmdId);

		if (a)

			button->addAction(a);

	}

	action->setDefaultWidget(button);

	button->setObjectName("chackableButtonWithImageBorder");

	connect(button, SIGNAL(triggered(QAction *)), this, SLOT(onButtonPressed(QAction *)));

	//connect(action, SIGNAL(toggled(bool)), button, SLOT(setChecked(bool)));

	m_playToolBar->addAction(action);

	return action;

}

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

QAction *FlipConsole::createDoubleButton(UINT buttonMask1, UINT buttonMask2,

										 const char *iconStr1, const char *iconStr2,

										 const QString &tip1, const QString &tip2,

										 QActionGroup *group, DoubleButton *&widget)

{

	QAction *action1 = new QAction(createQIconPNG(iconStr1), tip1, m_playToolBar);

	QAction *action2 = new QAction(createQIconPNG(iconStr2), tip2, m_playToolBar);

	m_actions[(EGadget)buttonMask1] = action1;

	m_actions[(EGadget)buttonMask2] = action2;

	action1->setData(QVariant(buttonMask1));

	action1->setCheckable(true);