#include "linetestpane.h"
#ifdef LINETEST
#include "xsheetdragtool.h"
#include "toutputproperties.h"
#include "tapp.h"
#include "toutputproperties.h"
#include "toonz/tcolumnhandle.h"
#include "toonz/txshlevelhandle.h"
#include "toonz/toonzscene.h"
#include "toonz/sceneproperties.h"

#include <QThread>
#include <QStackedWidget>

using namespace DVGui;

//=============================================================================
// MixAudioThread
//-----------------------------------------------------------------------------

MixAudioThread::MixAudioThread(QObject *parent)
	: QThread(parent), m_abort(false), m_restart(false)
{
}

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

MixAudioThread::~MixAudioThread()
{
	m_mutex.lock();
	m_abort = true;
	m_condition.wakeOne();
	m_mutex.unlock();
	wait();
}

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

void MixAudioThread::run()
{
	forever
	{
		m_mutex.lock();
		int from = this->m_from;
		int to = this->m_to;
		m_mutex.unlock();

		if (m_abort)
			return;

		TXsheet::SoundProperties *prop = new TXsheet::SoundProperties();
		prop->m_fromFrame = from;
		prop->m_toFrame = to;
		m_computedBuffer = TApp::instance()->getCurrentXsheet()->getXsheet()->makeSound(prop);
		m_buffer = TSoundTrackP();
		if (m_computedBuffer)
			m_buffer = m_computedBuffer->clone();

		if (!m_restart && m_buffer)
			emit computedBuffer();

		m_mutex.lock();
		if (!m_restart)
			m_condition.wait(&m_mutex);
		m_restart = false;
		m_mutex.unlock();
	}
}

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

void MixAudioThread::computeBuffer(int fromFrame, int toFrame)
{
	QMutexLocker locker(&m_mutex);

	this->m_from = fromFrame;
	this->m_to = toFrame;

	if (!isRunning()) {
		start(QThread::NormalPriority);
	} else {
		m_restart = true;
		m_condition.wakeOne();
	}
}

//=============================================================================
// LineTestPane
//-----------------------------------------------------------------------------

LineTestPane::LineTestPane(QWidget *parent, Qt::WFlags flags)
	: TPanel(parent), m_flipConsole(0), m_keyFrameButton(0), m_mainTrack(0), m_startTrack(0), m_player(0), m_trackStartFrame(0), m_startPlayRange(-1), m_endPlayRange(0), m_bufferSize(0), m_nextBufferSize(0)
{
	bool ret = true;
	QFrame *hbox = new QFrame(this);
	hbox->setFrameStyle(QFrame::StyledPanel);
	hbox->setObjectName("OnePixelMarginFrame");

	QVBoxLayout *mainLayout = new QVBoxLayout(hbox);
	mainLayout->setMargin(0);
	mainLayout->setSpacing(0);

	//Viewer
	m_stackedWidget = new QStackedWidget(this);
	m_sceneViewer = new SceneViewer(this);
	m_stackedWidget->addWidget(m_sceneViewer);
	m_lineTestViewer = new LineTestViewer(this);
	m_stackedWidget->addWidget(m_lineTestViewer);

	mainLayout->addWidget(m_stackedWidget, Qt::AlignCenter);

	TApp *app = TApp::instance();
	m_keyFrameButton = new ViewerKeyframeNavigator(0, app->getCurrentFrame());
	m_keyFrameButton->setObjectHandle(app->getCurrentObject());
	m_keyFrameButton->setXsheetHandle(app->getCurrentXsheet());

	int buttons = FlipConsole::cFullConsole;

	buttons &= (~FlipConsole::eSound);
	buttons &= (~FlipConsole::eCheckBg);
	buttons &= (~FlipConsole::eWhiteBg);
	buttons &= (~FlipConsole::eBlackBg);
	buttons &= (~FlipConsole::eSave);
	buttons &= (~FlipConsole::eCompare);
	buttons &= (~FlipConsole::eSaveImg);
	buttons &= (~FlipConsole::eHisto);
	buttons &= (~FlipConsole::eCustomize);
	buttons &= (~FlipConsole::eMatte);
	buttons &= (~FlipConsole::eGRed);
	buttons &= (~FlipConsole::eGGreen);
	buttons &= (~FlipConsole::eGBlue);
	buttons &= (~FlipConsole::eRed);
	buttons &= (~FlipConsole::eGreen);
	buttons &= (~FlipConsole::eBlue);
	buttons &= (~FlipConsole::eDefineSubCamera);
	buttons &= (~FlipConsole::eDefineLoadBox);
	buttons &= (~FlipConsole::eUseLoadBox);

	m_flipConsole = new FlipConsole(mainLayout, buttons, false, m_keyFrameButton, "SceneViewerConsole");

	ret = ret && connect(m_sceneViewer, SIGNAL(onZoomChanged()), SLOT(changeWindowTitle()));
	ret = ret && connect(m_lineTestViewer, SIGNAL(onZoomChanged()), SLOT(changeWindowTitle()));

	ret = connect(m_flipConsole, SIGNAL(drawFrame(int, const ImagePainter::VisualSettings &)), this, SLOT(onDrawFrame(int, const ImagePainter::VisualSettings &)));
	ret = ret && connect(m_flipConsole, SIGNAL(playStateChanged(bool)), this, SLOT(onPlayStateChanged(bool)));
	ret = ret && connect(m_flipConsole, SIGNAL(buttonPressed(FlipConsole::EGadget)), m_lineTestViewer, SLOT(onButtonPressed(FlipConsole::EGadget)));
	ret = ret && connect(m_flipConsole, SIGNAL(buttonPressed(FlipConsole::EGadget)), m_sceneViewer, SLOT(onButtonPressed(FlipConsole::EGadget)));
	ret = ret && connect(m_flipConsole, SIGNAL(sliderReleased()), this, SLOT(onFlipSliderReleased()));

	m_flipConsole->setFrameRate(app->getCurrentScene()->getScene()->getProperties()->getOutputProperties()->getFrameRate());

	hbox->setLayout(mainLayout);

	setWidget(hbox);

	initializeTitleBar(getTitleBar());

	ret = ret && connect(&m_mixAudioThread, SIGNAL(computedBuffer()), this, SLOT(onComputedBuffer()), Qt::DirectConnection);

	ret = ret && connect(app->getCurrentScene(), SIGNAL(sceneSwitched()), this, SLOT(onSceneSwitched()));

	assert(ret);
	setCurrentViewType(0);
}

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

LineTestPane::~LineTestPane()
{
}

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

void LineTestPane::showEvent(QShowEvent *)
{
	TApp *app = TApp::instance();
	TFrameHandle *frameHandle = app->getCurrentFrame();
	TSceneHandle *sceneHandle = app->getCurrentScene();
	TXshLevelHandle *levelHandle = app->getCurrentLevel();
	TObjectHandle *objectHandle = app->getCurrentObject();
	TXsheetHandle *xshHandle = app->getCurrentXsheet();

	updateFrameRange();

	bool ret = true;

	ret = ret && connect(xshHandle, SIGNAL(xsheetChanged()), this, SLOT(onSceneChanged()));

	ret = ret && connect(sceneHandle, SIGNAL(sceneChanged()), this, SLOT(onSceneChanged()));
	ret = ret && connect(sceneHandle, SIGNAL(nameSceneChanged()), this, SLOT(changeWindowTitle()));

	ret = ret && connect(levelHandle, SIGNAL(xshLevelSwitched(TXshLevel *)), this, SLOT(onXshLevelSwitched(TXshLevel *)));
	ret = ret && connect(levelHandle, SIGNAL(xshLevelChanged()), this, SLOT(changeWindowTitle()));
	ret = ret && connect(levelHandle, SIGNAL(xshLevelTitleChanged()), this, SLOT(changeWindowTitle()));
	ret = ret && connect(levelHandle, SIGNAL(xshLevelChanged()), this, SLOT(updateFrameRange()));

	ret = ret && connect(frameHandle, SIGNAL(frameSwitched()), this, SLOT(changeWindowTitle()));
	ret = ret && connect(frameHandle, SIGNAL(frameSwitched()), this, SLOT(onFrameSwitched()));
	ret = ret && connect(frameHandle, SIGNAL(frameTypeChanged()), this, SLOT(onFrameTypeChanged()));

	assert(ret);

	//Aggiorno FPS al valore definito nel viewer corrente.
	m_flipConsole->setActive(true);
}

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

void LineTestPane::hideEvent(QHideEvent *)
{
	TApp *app = TApp::instance();
	TFrameHandle *frameHandle = app->getCurrentFrame();
	TSceneHandle *sceneHandle = app->getCurrentScene();
	TXshLevelHandle *levelHandle = app->getCurrentLevel();
	TObjectHandle *objectHandle = app->getCurrentObject();
	TXsheetHandle *xshHandle = app->getCurrentXsheet();

	disconnect(xshHandle, SIGNAL(xsheetChanged()), this, SLOT(onSceneChanged()));

	disconnect(sceneHandle, SIGNAL(sceneChanged()), this, SLOT(onSceneChanged()));
	disconnect(sceneHandle, SIGNAL(nameSceneChanged()), this, SLOT(changeWindowTitle()));

	disconnect(levelHandle, SIGNAL(xshLevelSwitched(TXshLevel *)), this, SLOT(onXshLevelSwitched(TXshLevel *)));
	disconnect(levelHandle, SIGNAL(xshLevelChanged()), this, SLOT(changeWindowTitle()));
	disconnect(levelHandle, SIGNAL(xshLevelTitleChanged()), this, SLOT(changeWindowTitle()));
	disconnect(levelHandle, SIGNAL(xshLevelChanged()), this, SLOT(updateFrameRange()));

	disconnect(frameHandle, SIGNAL(frameSwitched()), this, SLOT(changeWindowTitle()));
	disconnect(frameHandle, SIGNAL(frameSwitched()), this, SLOT(onFrameSwitched()));
	disconnect(frameHandle, SIGNAL(frameTypeChanged()), this, SLOT(onFrameTypeChanged()));

	m_flipConsole->setActive(false);
}

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

int LineTestPane::computeBufferSize(int frame)
{
	int bufferSize = 0;
	double time = 2.0;
	ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
	TOutputProperties *outputSettings = scene->getProperties()->getOutputProperties();
	int frameRate = outputSettings->getFrameRate();
	if (m_endPlayRange > m_startPlayRange) {
		int range = m_endPlayRange - m_startPlayRange;
		time = double(range) / double(frameRate);
		int minuts = tround(time / 60.0);
		if (minuts == 0)
			minuts = 1;
		while (time > 2.0 * minuts)
			time = time * 0.5;
	}
	bufferSize = tfloor(frameRate * time) + 1;
	//qDebug("BUFFER SIZE: %d", bufferSize);

	if (frame + bufferSize > m_endPlayRange) {
		bufferSize = m_endPlayRange - frame + 1;
		//qDebug("\n BUFFER SIZE: %d \n", bufferSize);
	}

	return bufferSize;
}

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

void LineTestPane::computeBuffer(int frame)
{
	int startFrame = m_trackStartFrame + m_bufferSize;
	if (startFrame >= m_endPlayRange) {
		//qDebug("\n OPS \n");
		return;
	}
	//qDebug("COMPUTE BUFFER SIZE AT FRAME: %d", startFrame);
	m_nextBufferSize = computeBufferSize(startFrame);
	//qDebug("start frame: %d, start next buffer size: %d", startFrame, m_nextBufferSize);
	m_mixAudioThread.computeBuffer(startFrame, startFrame + m_nextBufferSize);
}

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

void LineTestPane::initSound()
{
	m_mainTrack = 0;
	m_startTrack = 0;
	TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();
	TFrameHandle *frameHandle = TApp::instance()->getCurrentFrame();
	m_trackStartFrame = frameHandle->getFrame();

	m_startPlayRange = 0;
	m_endPlayRange = frameHandle->getMaxFrameIndex();
	int fromMarker, toMarker, step;
	if (XsheetGUI::getPlayRange(fromMarker, toMarker, step)) {
		m_startPlayRange = fromMarker;
		m_endPlayRange = toMarker;
	}

	m_bufferSize = computeBufferSize(m_trackStartFrame);
	//qDebug("initSound()");
	//qDebug("m_startPlayRange: %d", m_startPlayRange);
	//qDebug("m_endPlayRange: %d", m_endPlayRange);
	//qDebug("start frame: %d, start bufferSize: %d", m_trackStartFrame, m_bufferSize);

	if (xsh) {
		if (!m_player)
			m_player = new TSoundOutputDevice();
		// Compute the first seconds and then launch the thread to compute the next buffer
		TXsheet::SoundProperties *prop = new TXsheet::SoundProperties();
		prop->m_fromFrame = m_trackStartFrame;
		prop->m_toFrame = m_trackStartFrame + m_bufferSize;
		m_mainTrack = xsh->makeSound(prop);
		if (m_trackStartFrame == m_startPlayRange) {
			//qDebug("set start track");
			m_startTrack = m_mainTrack;
			m_startBufferSize = m_bufferSize;
		} else //compute start track (it's necessary to avoid async in loop)
		{
			m_startBufferSize = computeBufferSize(m_startPlayRange);
			TXsheet::SoundProperties *prop = new TXsheet::SoundProperties();
			prop->m_fromFrame = m_startPlayRange;
			prop->m_toFrame = m_startPlayRange + m_startBufferSize;
			m_startTrack = xsh->makeSound(prop);
		}
		computeBuffer(m_trackStartFrame);
	} else {
		m_mainTrack = 0;
		m_startTrack = 0;
	}
}

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

void LineTestPane::playSound()
{
	if (m_player && m_mainTrack) {
		try {
			int currentFrame = TApp::instance()->getCurrentFrame()->getFrame();
			double t0 = (double)(currentFrame - m_trackStartFrame) / (double)(m_mainTrack->getSampleRate());
			// Pay attention at don't call play everytime (there is a big leak otherwise !)
			double trackDuration = m_mainTrack->getDuration();
			//qDebug("trackDuration: %f", trackDuration);
			if (m_mainTrack && trackDuration != 0)
				if (trackDuration > t0)
					m_player->play(m_mainTrack, t0, trackDuration);
		} catch (TSoundDeviceException &e) {
		}
	}
}

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

void LineTestPane::initializeTitleBar(TPanelTitleBar *titleBar)
{
	bool ret = true;

	TPanelTitleBarButtonSet *viewModeButtonSet;
	viewModeButtonSet = new TPanelTitleBarButtonSet();
	int x = -100;
	int iconWidth = 17;
	TPanelTitleBarButton *button;

	m_cameraStandButton = new TPanelTitleBarButton(titleBar, ":Resources/standard.png",
												   ":Resources/standard_over.png", ":Resources/standard_on.png");
	m_cameraStandButton->setToolTip("Camera Stand View");
	x += 18 + iconWidth;
	titleBar->add(QPoint(x, 2), m_cameraStandButton);
	m_cameraStandButton->setButtonSet(viewModeButtonSet, 0);
	m_cameraStandButton->setPressed(true);

	m_previewButton = new TPanelTitleBarButton(titleBar, ":Resources/viewpreview.png",
											   ":Resources/viewpreview_over.png", ":Resources/viewpreview_on.png");
	m_previewButton->setToolTip(tr("Preview"));
	x += 5 + iconWidth;
	titleBar->add(QPoint(x, 2), m_previewButton);
	m_previewButton->setButtonSet(viewModeButtonSet, 1);

	ret = ret && connect(viewModeButtonSet, SIGNAL(selected(int)), this, SLOT(setCurrentViewType(int)));
	assert(ret);
}

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

void LineTestPane::onXshLevelSwitched(TXshLevel *)
{
	changeWindowTitle();
}

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

void LineTestPane::changeWindowTitle()
{
	TApp *app = TApp::instance();
	ToonzScene *scene = app->getCurrentScene()->getScene();
	if (!scene)
		return;
	int frame = app->getCurrentFrame()->getFrame();
	QString name;
	if (app->getCurrentFrame()->isEditingScene()) {
		QString sceneName = QString::fromStdWString(scene->getSceneName());
		if (sceneName.isEmpty())
			sceneName = tr("Untitled");
		if (app->getCurrentScene()->getDirtyFlag())
			sceneName += QString("*");
		name = tr("Scene: ") + sceneName;
		if (frame >= 0)
			name = name + tr("   ::   Frame: ") + tr(toString(frame + 1).c_str());
		int col = app->getCurrentColumn()->getColumnIndex();
		if (col < 0) {
			setWindowTitle(name);
			return;
		}
		TXsheet *xsh = app->getCurrentXsheet()->getXsheet();
		TXshCell cell = xsh->getCell(frame, col);
		if (cell.isEmpty()) {
			setWindowTitle(name);
			return;
		}
		assert(cell.m_level.getPointer());
		TFilePath fp(cell.m_level->getName());
		QString imageName = QString::fromStdWString(fp.withFrame(cell.m_frameId).getWideString());
		name = name + tr("   ::   Level: ") + imageName;
	} else {
		TXshLevel *level = app->getCurrentLevel()->getLevel();
		if (level) {
			TFilePath fp(level->getName());
			QString imageName = QString::fromStdWString(fp.withFrame(app->getCurrentFrame()->getFid()).getWideString());
			name = name + tr("Level: ") + imageName;
		}
	}
	if (m_stackedWidget->currentIndex() == 0) {
		TAffine aff = m_sceneViewer->getViewMatrix() * m_sceneViewer->getNormalZoomScale().inv();
		name = name + "  ::  Zoom : " + QString::number(tround(100.0 * sqrt(aff.det()))) + "%";
	} else {
		TAffine aff = m_lineTestViewer->getViewMatrix() * m_lineTestViewer->getNormalZoomScale().inv();
		name = name + "  ::  Zoom : " + QString::number(tround(100.0 * sqrt(aff.det()))) + "%";
	}

	setWindowTitle(name);
}

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

void LineTestPane::updateFrameRange()
{
	TApp *app = TApp::instance();
	TFrameHandle *fh = app->getCurrentFrame();
	int frameIndex = fh->getFrameIndex();
	int maxFrameIndex = fh->getMaxFrameIndex();
	m_flipConsole->setFrameRange(1, maxFrameIndex + 1, 1, frameIndex + 1);
}

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

void LineTestPane::updateFrameMarkers()
{
	int fromIndex, toIndex, dummy;
	XsheetGUI::getPlayRange(fromIndex, toIndex, dummy);
	TFrameHandle *fh = TApp::instance()->getCurrentFrame();
	if (fh->isEditingLevel()) {
		fromIndex = 0;
		toIndex = -1;
	}
	m_flipConsole->setMarkers(fromIndex, toIndex);
}

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

void LineTestPane::setCurrentViewType(int index)
{
	TFrameHandle *frameHandle = TApp::instance()->getCurrentFrame();
	if (index == 1 && frameHandle->getFrameType() == TFrameHandle::LevelFrame)
		frameHandle->setFrame(frameHandle->getFrameIndex());
	m_stackedWidget->setCurrentIndex(index);
	if (index == 0) {
		CommandManager::instance()->enable("MI_ViewTable", true);
		CommandManager::instance()->enable("MI_FieldGuide", true);
		CommandManager::instance()->enable("MI_SafeArea", true);
		CommandManager::instance()->enable("MI_RasterizePli", true);
		CommandManager::instance()->enable("MI_ViewColorcard", true);
		CommandManager::instance()->enable("MI_ViewCamera", true);
		m_flipConsole->enableButton(FlipConsole::eFilledRaster, false, false);
	} else {
		CommandManager::instance()->enable("MI_ViewTable", false);
		CommandManager::instance()->enable("MI_FieldGuide", false);
		CommandManager::instance()->enable("MI_SafeArea", false);
		CommandManager::instance()->enable("MI_RasterizePli", false);
		CommandManager::instance()->enable("MI_ViewColorcard", false);
		CommandManager::instance()->enable("MI_ViewCamera", false);
		if (m_flipConsole)
			m_flipConsole->enableButton(FlipConsole::eFilledRaster, true, false);
	}
	changeWindowTitle();
}

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

void LineTestPane::onDrawFrame(int frame, const ImagePainter::VisualSettings &settings)
{
	TApp *app = TApp::instance();
	TFrameHandle *frameHandle = app->getCurrentFrame();

	assert(frame >= 0);
	if (frame != frameHandle->getFrameIndex() + 1) {
		int oldFrame = frameHandle->getFrame();
		frameHandle->setCurrentFrame(frame);
		if (!m_mainTrack && !frameHandle->isPlaying() && !frameHandle->isEditingLevel() && oldFrame != frameHandle->getFrame())
			frameHandle->scrubXsheet(frame - 1, frame - 1, TApp::instance()->getCurrentXsheet()->getXsheet());

		//qDebug("frame: %d",frame);
		if (m_mainTrack && frameHandle->isPlaying() && !frameHandle->isEditingLevel()) {
			if (frame == m_startPlayRange + 1) {
				if (m_startTrack) {
					m_mainTrack = m_startTrack;
					m_trackStartFrame = frame;
					//qDebug("1. play at m_trackStartFrame: %d", m_trackStartFrame);
					playSound();

					m_bufferSize = m_startBufferSize;
					computeBuffer(frame);
				} else {
					//qDebug("2. play at m_trackStartFrame: %d", m_trackStartFrame);
					assert(0);
					initSound();
				}
			}
			int frameElapsed = frame - m_trackStartFrame - 1;
			if (frameElapsed >= (m_bufferSize)) {
				if (m_buffer)
					m_mainTrack = m_buffer->clone();

				m_trackStartFrame = frame;
				//qDebug("PLAY SOUND AT FRAME: %d", frame);
				playSound();

				//qDebug("3. play at m_trackStartFrame: %d", m_trackStartFrame);
				m_bufferSize = m_nextBufferSize;
				computeBuffer(frame);
			}
		}
	}
}

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

void LineTestPane::onComputedBuffer()
{
	m_buffer = TSoundTrackP();
	m_buffer = m_mixAudioThread.getBuffer();
}

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

void LineTestPane::onPlayStateChanged(bool value)
{
	TFrameHandle *frameHandle = TApp::instance()->getCurrentFrame();
	bool wasPlaying = frameHandle->isPlaying();
	frameHandle->setPlaying(value);
	if (value && !frameHandle->isEditingLevel()) {
		if (m_player && wasPlaying) {
			m_player->close();
			if (m_mainTrack)
				m_mainTrack = TSoundTrackP();
			if (m_startTrack)
				m_startTrack = TSoundTrackP();
			if (m_buffer)
				m_buffer = TSoundTrackP();
		}
		initSound();
		playSound();
	} else if (m_player) {
		m_player->close();
		if (m_mainTrack)
			m_mainTrack = TSoundTrackP();
		if (m_startTrack)
			m_startTrack = TSoundTrackP();
		if (m_buffer)
			m_buffer = TSoundTrackP();
	}
}

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

void LineTestPane::onSceneChanged()
{
	TApp *app = TApp::instance();
	ToonzScene *scene = app->getCurrentScene()->getScene();
	assert(scene);
	m_flipConsole->updateCurrentFPS(scene->getProperties()->getOutputProperties()->getFrameRate());

	updateFrameRange();
	updateFrameMarkers();
	changeWindowTitle();

	int frameIndex = app->getCurrentFrame()->getFrameIndex();
	if (m_keyFrameButton->getCurrentFrame() != frameIndex)
		m_keyFrameButton->setCurrentFrame(frameIndex);
}

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

void LineTestPane::onSceneSwitched()
{
	if (!isHidden())
		onSceneChanged();
	m_flipConsole->setFrameRate(TApp::instance()->getCurrentScene()->getScene()->getProperties()->getOutputProperties()->getFrameRate());
}

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

void LineTestPane::onFrameSwitched()
{
	int frameIndex = TApp::instance()->getCurrentFrame()->getFrameIndex();
	m_flipConsole->setCurrentFrame(frameIndex + 1);
	if (m_keyFrameButton->getCurrentFrame() != frameIndex)
		m_keyFrameButton->setCurrentFrame(frameIndex);
}

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

void LineTestPane::onFrameTypeChanged()
{
	if (TApp::instance()->getCurrentFrame()->getFrameType() == TFrameHandle::LevelFrame) {
		if (m_stackedWidget->currentIndex() != 0) {
			m_cameraStandButton->setPressed(true);
			m_previewButton->setPressed(false);
			setCurrentViewType(0);
		}
	}

	updateFrameRange();
	updateFrameMarkers();
}

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

void LineTestPane::onFlipSliderReleased()
{
	TApp::instance()->getCurrentXsheet()->getXsheet()->stopScrub();
}

#endif