razzaline/tahoma2d
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity
tahoma2d/toonz/sources/toonzqt/flipconsole.cpp

1904 lines
59 KiB
C++
Raw Normal View History

first commit
2016-03-19 06:57:51 +13:00
#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>
#include <QHBoxLayout>
#include <QToolBar>
#include <QLabel>
#include <QFrame>
#include <QSlider>
#include <QTimerEvent>
#include <QToolButton>
#include <QPainter>
#include <QMouseEvent>
#include <QIcon>
#include <QAction>
#include <QWidgetAction>
#include <QStyle>
#include <QStylePainter>
#include <QStyleOption>
#include <QStyleOptionFrameV3>
#include <QSettings>
#include <QPushButton>
#include <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;
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();
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);
action2->setData(QVariant(buttonMask2));
action2->setCheckable(true);
if (group) {
group->addAction(action1);
group->addAction(action2);
}
widget = new DoubleButton(action1, action2, this);
return m_playToolBar->addWidget(widget);
//m_playToolBar->addAction(action1);
//m_playToolBar->addAction(action2);
}
//-----------------------------------------------------------------------------
void FlipConsole::createOnOffButton(UINT buttonMask, const char *iconStr, const QString &tip, QActionGroup *group)
{
QIcon icon = createQIconOnOffPNG(iconStr);
QAction *action = new QAction(icon, tip, m_playToolBar);
action->setData(QVariant(buttonMask));
action->setCheckable(true);
if (group)
group->addAction(action);
m_playToolBar->addAction(action);
m_actions[(EGadget)buttonMask] = action;
}
//----------------------------------------------------------------------------------------------
void FlipConsole::addMenuItem(UINT id, const QString &text, QMenu *menu)
{
QAction *a = new QAction(text, menu);
a->setCheckable(true);
a->setChecked(id & m_customizeMask);
a->setData(QVariant(id));
menu->addAction(a);
}
//----------------------------------------------------------------------------------------------
void FlipConsole::onCustomizeButtonPressed(QAction *a)
{
UINT id = a->data().toUInt();
if (a->isChecked())
m_customizeMask = m_customizeMask | id;
else
m_customizeMask = m_customizeMask & (~id);
QSettings().setValue(m_customizeId, QString::number(m_customizeMask));
applyCustomizeMask();
}
//----------------------------------------------------------------------------------------------
void FlipConsole::applyCustomizeMask()
{
enableButton(eSave, m_customizeMask & eShowSave);
//if(m_saveSep)
// m_saveSep->setVisible(m_customizeMask&eShowSave);
enableButton(eSaveImg, m_customizeMask & eShowCompare);
enableButton(eCompare, m_customizeMask & eShowCompare);
if (m_compareSep)
m_compareSep->setVisible(m_customizeMask & eShowCompare);
enableButton(eDefineSubCamera, m_customizeMask & eShowDefineSubCamera);
enableButton(eDefineLoadBox, m_customizeMask & eShowDefineLoadBox);
enableButton(eUseLoadBox, m_customizeMask & eShowUseLoadBox);
if (m_subcamSep)
m_subcamSep->setVisible(
m_customizeMask & eShowDefineSubCamera ||
m_customizeMask & eShowDefineLoadBox ||
m_customizeMask & eShowUseLoadBox);
enableButton(eWhiteBg, m_customizeMask & eShowBg);
enableButton(eBlackBg, m_customizeMask & eShowBg);
enableButton(eCheckBg, m_customizeMask & eShowBg);
if (m_bgSep)
m_bgSep->setVisible(m_customizeMask & eShowBg);
if (m_fpsLabel && m_fpsSlider && m_fpsField) {
m_fpsLabel->setVisible(m_customizeMask & eShowFramerate);
m_fpsSlider->setVisible(m_customizeMask & eShowFramerate);
m_fpsField->setVisible(m_customizeMask & eShowFramerate);
}
enableButton(eFirst, m_customizeMask & eShowVcr);
enableButton(ePrev, m_customizeMask & eShowVcr);
enableButton(ePause, m_customizeMask & eShowVcr);
enableButton(ePlay, m_customizeMask & eShowVcr);
enableButton(eLoop, m_customizeMask & eShowVcr);
enableButton(eNext, m_customizeMask & eShowVcr);
enableButton(eLast, m_customizeMask & eShowVcr);
if (m_vcrSep)
m_vcrSep->setVisible(m_customizeMask & eShowVcr);
enableButton(eMatte, m_customizeMask & eShowcolorFilter);
enableButton(eHisto, m_customizeMask & eShowHisto);
if (m_histoSep)
m_histoSep->setVisible(m_customizeMask & eShowHisto);
if (m_doubleRedAction) {
m_doubleRedAction->setVisible(m_customizeMask & eShowcolorFilter);
m_doubleGreenAction->setVisible(m_customizeMask & eShowcolorFilter);
m_doubleBlueAction->setVisible(m_customizeMask & eShowcolorFilter);
} else {
enableButton(eRed, m_customizeMask & eShowcolorFilter);
enableButton(eGreen, m_customizeMask & eShowcolorFilter);
enableButton(eBlue, m_customizeMask & eShowcolorFilter);
}
if (m_colorFilterGroup)
m_colorFilterGroup->setVisible(m_customizeMask & eShowcolorFilter);
if (m_colorFilterSep)
m_colorFilterSep->setVisible(m_customizeMask & eShowcolorFilter);
if (m_customAction) {
bool visible = bool(m_customizeMask & eShowCustom);
m_customAction->setVisible(visible);
m_customSep->setVisible(visible);
}
enableButton(eFilledRaster, m_customizeMask & eShowFilledRaster);
if (m_filledRasterSep)
m_filledRasterSep->setVisible(m_customizeMask & eShowFilledRaster);
update();
}
//----------------------------------------------------------------------------------------------
void FlipConsole::createCustomizeMenu(bool withCustomWidget)
{
if (m_gadgetsMask & eCustomize) {
QIcon icon = createQIconPNG("options");
QToolButton *button = new QToolButton();
button->setIcon(icon);
button->setPopupMode(QToolButton::MenuButtonPopup);
button->setObjectName("flipCustomize");
button->setStyleSheet("#flipCustomize { background-color: transparent; } #flipCustomize::menu-button { background-color: transparent; image: none; width: 34px; } #flipCustomize::menu-arrow { image: none; }");
QMenu *menu = new QMenu();
button->setMenu(menu);
m_playToolBar->addWidget(button);
m_playToolBar->addSeparator();
if (m_gadgetsMask & eSave)
addMenuItem(eShowSave, tr("Save"), menu);
if (m_gadgetsMask & eSaveImg || m_gadgetsMask & eCompare)
addMenuItem(eShowCompare, tr("Snapshot"), menu);
if (m_gadgetsMask & eDefineSubCamera)
addMenuItem(eShowDefineSubCamera, tr("Define Sub-camera"), menu);
if (m_gadgetsMask & eDefineLoadBox)
addMenuItem(eShowDefineLoadBox, tr("Define Loading Box"), menu);
if (m_gadgetsMask & eUseLoadBox)
addMenuItem(eShowUseLoadBox, tr("Use Loading Box"), menu);
if (m_gadgetsMask & eWhiteBg || m_gadgetsMask & eBlackBg || m_gadgetsMask & eCheckBg)
addMenuItem(eShowBg, tr("Background Colors"), menu);
if (m_gadgetsMask & eRate)
addMenuItem(eShowFramerate, tr("Framerate"), menu);
addMenuItem(eShowVcr, tr("Playback Controls"), menu);
if ((m_gadgetsMask & eRed) || (m_gadgetsMask & eGreen) ||
(m_gadgetsMask & eBlue) || (m_gadgetsMask & eMatte))
addMenuItem(eShowcolorFilter, tr("Color Channels"), menu);
if (withCustomWidget)
addMenuItem(eShowCustom, tr("Set Key"), menu);
if (m_gadgetsMask & eHisto)
addMenuItem(eShowHisto, tr("Histogram"), menu);
if (m_gadgetsMask & eFilledRaster)
addMenuItem(eFilledRaster, tr("Display Areas as Filled"), menu);
bool ret = connect(menu, SIGNAL(triggered(QAction *)), this, SLOT(onCustomizeButtonPressed(QAction *)));
assert(ret);
}
}
//-----------------------------------------------------------------------------
void FlipConsole::createPlayToolBar(bool withCustomWidget)
{
bool ret = true;
m_playToolBar = new QToolBar(this);
m_playToolBar->setMovable(false);
m_playToolBar->setObjectName("FlipConsolePlayToolBar");
// m_playToolBar->setObjectName("chackableButtonToolBar");
//m_playToolBar->setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
createCustomizeMenu(withCustomWidget);
if (m_gadgetsMask & eSave) {
//just reuse the icon file named "savepalette"
createButton(eSave, "savepalette", tr("&Save Images"), false);
//m_saveSep = m_playToolBar->addSeparator();
}
// snapshot
bool separator = false;
if (m_gadgetsMask & eSaveImg) {
createButton(eSaveImg, "snapshot", tr("&Snapshot"), false);
separator = true;
}
if (m_gadgetsMask & eCompare) {
createButton(eCompare, "compare", tr("&Compare to Snapshot"), true);
separator = true;
}
if (separator)
m_compareSep = m_playToolBar->addSeparator();
// sub camera
separator = false;
if (m_gadgetsMask & eDefineSubCamera) {
createButton(eDefineSubCamera, "define_subcamera_preview", tr("&Define Sub-camera"), true);
separator = true;
}
if (m_gadgetsMask & eDefineLoadBox) {
createButton(eDefineLoadBox, "define_subcamera_preview", tr("&Define Loading Box"), true);
separator = true;
}
if (m_gadgetsMask & eUseLoadBox) {
createButton(eUseLoadBox, "use_subcamera_preview", tr("&Use Loading Box"), true);
separator = true;
}
if (separator)
m_subcamSep = m_playToolBar->addSeparator();
// preview BGs
QActionGroup *group = new QActionGroup(m_playToolBar);
if (m_gadgetsMask & eWhiteBg)
createOnOffButton(eWhiteBg, "preview_white", tr("&White Background"), group);
if (m_gadgetsMask & eBlackBg)
createOnOffButton(eBlackBg, "preview_black", tr("&Black Background"), group);
if (m_gadgetsMask & eCheckBg)
createOnOffButton(eCheckBg, "preview_checkboard", tr("&Checkered Background"), group);
if (m_gadgetsMask & eWhiteBg)
m_bgSep = m_playToolBar->addSeparator();
// VCR buttons
QActionGroup *playGroup = new QActionGroup(m_playToolBar);
if (m_gadgetsMask & eFirst)
createButton(eFirst, "framefirst", tr("&First Frame"), false);
if (m_gadgetsMask & ePrev)
createButton(ePrev, "frameprev", tr("&Previous Frame"), false);
if (m_gadgetsMask & ePause)
createCheckedButtonWithBorderImage(ePause, "pause", tr("Pause"), true, playGroup, "A_Flip_Pause");
if (m_gadgetsMask & ePlay)
createCheckedButtonWithBorderImage(ePlay, "play", tr("Play"), true, playGroup, "A_Flip_Play");
if (m_gadgetsMask & eLoop)
createCheckedButtonWithBorderImage(eLoop, "loop", tr("Loop"), true, playGroup, "A_Flip_Loop");
if (m_gadgetsMask & eNext)
createButton(eNext, "framenext", tr("&Next frame"), false);
if (m_gadgetsMask & eLast)
createButton(eLast, "framelast", tr("&Last Frame"), false);
// separator
if (m_gadgetsMask & ePlay)
m_vcrSep = m_playToolBar->addSeparator();
//Channel Selector
m_colorFilterGroup = new QActionGroup(m_playToolBar);
m_colorFilterGroup->setExclusive(false);
if ((m_gadgetsMask & eRed) && !(m_gadgetsMask & eGRed))
createButton(eRed, "channelred", tr("Red Channel"), true);
else if ((m_gadgetsMask & eRed) && (m_gadgetsMask & eGRed))
m_doubleRedAction = createDoubleButton(eRed, eGRed, "half_R", "half_bw", tr("Red Channel"), tr("Red Channel in Grayscale"), m_colorFilterGroup, m_doubleRed);
if ((m_gadgetsMask & eGreen) && !(m_gadgetsMask & eGGreen))
createButton(eGreen, "channelgreen", tr("Green Channel"), true);
else if ((m_gadgetsMask & eGreen) && (m_gadgetsMask & eGGreen))
m_doubleGreenAction = createDoubleButton(eGreen, eGGreen, "half_G", "half_bw", tr("Green Channel"), tr("Green Channel in Grayscale"), m_colorFilterGroup, m_doubleGreen);
if ((m_gadgetsMask & eBlue) && !(m_gadgetsMask & eGBlue))
createButton(eBlue, "channelblue", tr("Blue Channel"), true);
else if ((m_gadgetsMask & eBlue) && (m_gadgetsMask & eGBlue))
m_doubleBlueAction = createDoubleButton(eBlue, eGBlue, "half_B", "half_bw", tr("Blue Channel"), tr("Blue Channel in Grayscale"), m_colorFilterGroup, m_doubleBlue);
ret = ret && connect(m_colorFilterGroup, SIGNAL(triggered(QAction *)), this, SLOT(onButtonPressed(QAction *)));
if (m_gadgetsMask & eMatte)
createButton(eMatte, "channelmatte", tr("Alpha Channel"), true);
// separator
if (m_gadgetsMask & eRed || m_gadgetsMask & eGRed)
m_colorFilterSep = m_playToolBar->addSeparator();
// Sound & Histogram
if (m_gadgetsMask & eSound || m_gadgetsMask & eHisto) {
if (m_gadgetsMask & eSound) {
createButton(eSound, "sound", tr("&Soundtrack "), true);
m_soundSep = m_playToolBar->addSeparator();
}
if (m_gadgetsMask & eHisto) {
createButton(eHisto, "histograms", tr("&Histogram"), false);
m_histoSep = m_playToolBar->addSeparator();
}
}
if (m_gadgetsMask & eFilledRaster) {
createOnOffButton(eFilledRaster, "preview_white", tr("&Display Areas as Filled"), 0);
m_filledRasterSep = m_playToolBar->addSeparator();
}
//for all actions in this toolbar
ret = ret && connect(m_playToolBar, SIGNAL(actionTriggered(QAction *)), this, SLOT(onButtonPressed(QAction *)));
setChecked(ePause, true);
setChecked(eWhiteBg, FlipBookWhiteBgToggle);
setChecked(eBlackBg, FlipBookBlackBgToggle);
setChecked(eCheckBg, FlipBookCheckBgToggle);
assert(ret);
}
//-----------------------------------------------------------------------------
void FlipConsole::enableBlanks(bool state)
{
m_drawBlanksEnabled = state;
m_blankColor = TPixel::Transparent;
if (m_drawBlanksEnabled)
Preferences::instance()->getBlankValues(m_blanksCount, m_blankColor);
else {
m_blanksCount = 0;
m_blankColor = TPixel::Transparent;
}
}
//-----------------------------------------------------------------------------
/*! call consoleOwner->onDrawFrame() intead of emitting drawFrame signal
*/
void FlipConsole::showCurrentFrame()
{
m_consoleOwner->onDrawFrame(m_currentFrame, m_settings);
}
//-----------------------------------------------------------------------------
void FlipConsole::setChecked(UINT button, bool state)
{
int i;
if (m_playToolBar) {
QObjectList objectList = m_playToolBar->children();
for (i = 0; i < (int)objectList.size(); i++) {
QAction *action = dynamic_cast<QAction *>(objectList[i]);
if (!action) {
QToolButton *toolButton = dynamic_cast<QToolButton *>(objectList[i]);
if (!toolButton)
continue;
action = toolButton->defaultAction();
}
if (action && action->data().toUInt() == button) {
action->setChecked(state);
return;
}
}
}
if (m_colorFilterGroup) {
QList<QAction *> list = m_colorFilterGroup->actions();
for (i = 0; i < (int)list.size(); i++)
if (list[i]->data().toUInt() == button) {
list[i]->setChecked(state);
return;
}
}
}
//-----------------------------------------------------------------------------
bool FlipConsole::isChecked(UINT button) const
{
QList<QAction *> list;
int i;
if (m_playToolBar) {
list = m_playToolBar->actions();
for (i = 0; i < (int)list.size(); i++)
if (list[i]->data().toUInt() == button)
return list[i]->isChecked();
}
if (m_colorFilterGroup) {
list = m_colorFilterGroup->actions();
for (i = 0; i < (int)list.size(); i++)
if (list[i]->data().toUInt() == button)
return list[i]->isChecked();
}
return false;
}
//-----------------------------------------------------------------------------
void FlipConsole::pressLinkedConsoleButton(UINT button, FlipConsole *parent)
{
int i;
assert(parent);
for (i = 0; i < m_visibleConsoles.size(); i++) {
FlipConsole *console = m_visibleConsoles.at(i);
if (console->m_isLinkable && console != parent) {
console->setChecked(button, parent ? parent->isChecked(button) : true);
console->doButtonPressed(button);
}
}
}
//-----------------------------------------------------------------------------
void FlipConsole::onButtonPressed(int button)
{
// if(!isVisible()) return;
makeCurrent();
doButtonPressed(button);
if (m_areLinked)
pressLinkedConsoleButton(button, this);
}
//-----------------------------------------------------------------------------
void FlipConsole::pressButton(EGadget buttonId)
{
if (m_buttons.contains(buttonId)) {
//If you press "play" or "loop play" button while playing, which means "pause"
if (m_playbackExecutor.isRunning() && (buttonId == ePlay || buttonId == eLoop)) {
m_buttons[ePause]->click();
return;
}
m_buttons[buttonId]->click();
} else if (m_actions.contains(buttonId))
m_actions[buttonId]->trigger();
}
//-----------------------------------------------------------------------------
void FlipConsole::onLoadBox(bool isDefine)
{
int shrink, dummy;
Preferences::instance()->getViewValues(shrink, dummy);
if (shrink != 1) {
#ifdef WIN32
MessageBox(0, "Cannot use loading box with a shrink factor! ", "Warning", MB_OK);
#endif
setChecked(eUseLoadBox, false);
setChecked(eDefineLoadBox, false);
m_settings.m_useLoadbox = m_settings.m_defineLoadbox = false;
return;
}
if (isDefine)
m_settings.m_defineLoadbox = !m_settings.m_defineLoadbox;
else
m_settings.m_useLoadbox = !m_settings.m_useLoadbox;
if (m_settings.m_defineLoadbox && m_settings.m_useLoadbox) {
setChecked(isDefine ? eUseLoadBox : eDefineLoadBox, false);
if (isDefine)
m_settings.m_useLoadbox = false;
else
m_settings.m_defineLoadbox = false;
}
m_consoleOwner->onDrawFrame(m_currentFrame, m_settings);
return;
}
//-----------------------------------------------------------------------------
void FlipConsole::doButtonPressed(UINT button)
{
emit buttonPressed((FlipConsole::EGadget)button);
int from = m_from, to = m_to;
// When the level editing mode, ignore the preview frame range marker
if (m_markerFrom <= m_markerTo && m_frameHandle && m_frameHandle->isEditingScene())
from = m_markerFrom, to = m_markerTo;
bool linked = m_areLinked && m_isLinkable;
switch (button) {
case eFirst:
m_currentFrame = from;
CASE ePrev : m_currentFrame = (m_currentFrame - m_step < from) ? from : m_currentFrame - m_step;
CASE eNext : m_currentFrame = (m_currentFrame + m_step > to) ? to : m_currentFrame + m_step;
CASE eLast : m_currentFrame = to;
CASE ePlay : __OR eLoop:
{
//if ( isChecked(ePlay, false);
//setChecked(eLoop, false);
m_editCurrFrame->disconnect();
m_currFrameSlider->disconnect();
m_isPlay = (button == ePlay);
if (linked && m_isLinkedPlaying)
return;
if ((m_fps == 0 || m_framesCount == 0) && m_playbackExecutor.isRunning()) {
doButtonPressed(ePause);
if (m_fpsLabel)
m_fpsLabel->setText(tr(" FPS ") + QString::number(m_fps));
if (m_fpsField)
m_fpsField->setLineEditBackgroundColor(Qt::transparent);
return;
}
if (m_fpsLabel)
m_fpsLabel->setText(tr(" FPS ") + "/");
if (m_fpsField)
m_fpsField->setLineEditBackgroundColor(Qt::red);
m_playbackExecutor.resetFps(m_fps);
if (!m_playbackExecutor.isRunning())
m_playbackExecutor.start();
m_isLinkedPlaying = linked;
m_reverse = (m_fps < 0);
if (!linked) {
//if the play button pressed at the end frame, then go back to the start frame and play
if (m_currentFrame <= from || m_currentFrame >= to) //the first frame of the playback is drawn right now
m_currentFrame = m_reverse ? to : from;
m_settings.m_recomputeIfNeeded = true;
m_consoleOwner->onDrawFrame(m_currentFrame, m_settings);
}
emit playStateChanged(true);
return;
}
CASE ePause : m_isLinkedPlaying = false;
if (m_playbackExecutor.isRunning())
m_playbackExecutor.abort();
m_isPlay = false;
m_blanksToDraw = 0;
m_consoleOwner->swapBuffers();
m_consoleOwner->changeSwapBehavior(true);
if (m_settings.m_blankColor != TPixel::Transparent) {
m_settings.m_blankColor = TPixel::Transparent;
m_settings.m_recomputeIfNeeded = true;
m_consoleOwner->onDrawFrame(m_currentFrame, m_settings);
}
if (m_fpsLabel)
m_fpsLabel->setText(tr(" FPS "));
if (m_fpsField)
m_fpsField->setLineEditBackgroundColor(Qt::transparent);
//setChecked(ePlay, false);
//setChecked(eLoop, false);
connect(m_editCurrFrame, SIGNAL(editingFinished()), this, SLOT(OnSetCurrentFrame()));
connect(m_currFrameSlider, SIGNAL(flipSliderReleased()), this, SLOT(OnFrameSliderRelease()));
connect(m_currFrameSlider, SIGNAL(flipSliderPressed()), this, SLOT(OnFrameSliderPress()));
connect(m_currFrameSlider, SIGNAL(valueChanged(int)), this, SLOT(OnSetCurrentFrame(int)));
connect(m_currFrameSlider, SIGNAL(flipSliderReleased()), this, SLOT(onSliderRelease()));
emit playStateChanged(false);
return;
/*CASE eMatte:
if (isChecked(eMatte))
{
//setChecked(eRed, false);
//setChecked(eGreen, false);
//setChecked(eBlue, false);
setChecked(eGRed, false);
setChecked(eGGreen, false);
setChecked(eGBlue, false);
m_settings.m_colorMask = TRop::MChan;
}
else
m_settings.m_colorMask = 0;
if (m_doubleRed)
{
m_doubleRed->update();
m_doubleGreen->update();
m_doubleBlue->update();
}*/
CASE eGRed : __OR eGGreen : __OR eGBlue : __OR eRed : __OR eGreen : __OR eBlue : __OR eMatte:
{
if (button != eGRed)
setChecked(eGRed, false);
if (button != eGGreen)
setChecked(eGGreen, false);
if (button != eGBlue)
setChecked(eGBlue, false);
if (button == eGRed || button == eGGreen || button == eGBlue) {
m_settings.m_greytones = isChecked(button);
setChecked(eRed, false);
setChecked(eGreen, false);
setChecked(eBlue, false);
setChecked(eMatte, false);
} else
m_settings.m_greytones = false;
if (m_doubleRed) {
m_doubleRed->update();
m_doubleGreen->update();
m_doubleBlue->update();
}
int colorMask = 0;
if (isChecked(eRed) || isChecked(eGRed))
colorMask = colorMask | TRop::RChan;
if (isChecked(eGreen) || isChecked(eGGreen))
colorMask = colorMask | TRop::GChan;
if (isChecked(eBlue) || isChecked(eGBlue))
colorMask = colorMask | TRop::BChan;
if (isChecked(eMatte))
colorMask = colorMask | TRop::MChan;
if (colorMask == (TRop::RChan | TRop::GChan | TRop::BChan) ||
colorMask == (TRop::RChan | TRop::GChan | TRop::BChan | TRop::MChan))
m_settings.m_colorMask = 0;
else
m_settings.m_colorMask = colorMask;
}
CASE eSound :
//emit soundEnabled(isChecked(eSound));
CASE eWhiteBg : __OR eBlackBg : __OR eCheckBg : m_settings.m_bg = (EGadget)button;
FlipBookWhiteBgToggle = isChecked(eWhiteBg);
FlipBookBlackBgToggle = isChecked(eBlackBg);
FlipBookCheckBgToggle = isChecked(eCheckBg);
CASE FlipConsole::eCompare : m_settings.m_doCompare = !m_settings.m_doCompare;
CASE eHisto : CASE eSaveImg : CASE eSave :
//nothing to do
return;
CASE eDefineSubCamera :
//nothing to do
return;
CASE eDefineLoadBox : onLoadBox(true);
CASE eUseLoadBox : onLoadBox(false);
CASE eFilledRaster : return;
DEFAULT:
assert(false);
}
m_currFrameSlider->setValue(m_currentFrame);
m_editCurrFrame->setText(QString::number(m_currentFrame));
m_consoleOwner->onDrawFrame(m_currentFrame, m_settings);
}
//--------------------------------------------------------------------
QFrame *FlipConsole::createFrameSlider()
{
QFrame *frameSliderFrame = new QFrame(this);
m_editCurrFrame = new IntLineEdit(frameSliderFrame, m_currentFrame);
m_editCurrFrame->setToolTip(tr("Set the current frame"));
m_editCurrFrame->setFixedWidth(40);
m_currFrameSlider = new FlipSlider(frameSliderFrame);
m_currFrameSlider->setToolTip(tr("Drag to play the animation"));
m_currFrameSlider->setRange(0, 0);
m_currFrameSlider->setValue(0);
if (m_drawBlanksEnabled) {
m_enableBlankFrameButton = new QPushButton(this);
m_enableBlankFrameButton->setCheckable(true);
m_enableBlankFrameButton->setChecked(true);
m_enableBlankFrameButton->setFixedHeight(24);
m_enableBlankFrameButton->setFixedWidth(66);
m_enableBlankFrameButton->setObjectName("enableBlankFrameButton");
}
//layout
QHBoxLayout *frameSliderLayout = new QHBoxLayout();
frameSliderLayout->setSpacing(5);
frameSliderLayout->setMargin(2);
{
frameSliderLayout->addWidget(m_editCurrFrame, 0);
frameSliderLayout->addWidget(m_currFrameSlider, 1);
if (m_drawBlanksEnabled)
frameSliderLayout->addWidget(m_enableBlankFrameButton, 0);
}
frameSliderFrame->setLayout(frameSliderLayout);
connect(m_editCurrFrame, SIGNAL(editingFinished()),
this, SLOT(OnSetCurrentFrame()));
connect(m_currFrameSlider, SIGNAL(valueChanged(int)),
this, SLOT(OnSetCurrentFrame(int)));
connect(m_currFrameSlider, SIGNAL(flipSliderReleased()),
this, SLOT(OnFrameSliderRelease()));
return frameSliderFrame;
}
//--------------------------------------------------------------------
QFrame *FlipConsole::createFpsSlider()
{
QFrame *fpsSliderFrame = new QFrame(this);
//frame per second
m_fpsLabel = new QLabel(QString(" FPS -- /"), fpsSliderFrame);
m_fpsSlider = new QScrollBar(Qt::Horizontal, fpsSliderFrame);
m_fpsField = new IntLineEdit(fpsSliderFrame, m_fps, -60, 60);
m_fpsField->setFixedWidth(40);
m_fpsLabel->setMinimumWidth(m_fpsLabel->fontMetrics().width("_FPS_24___"));
m_fpsLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
m_fpsSlider->setObjectName("ViewerFpsSlider");
m_fpsSlider->setRange(-60, 60);
m_fpsSlider->setValue(m_fps);
m_fpsSlider->setToolTip(tr("Set the playback frame rate"));
m_fpsSlider->setContextMenuPolicy(Qt::NoContextMenu);
QHBoxLayout *hLay = new QHBoxLayout();
hLay->setSpacing(0);
hLay->setMargin(0);
{
hLay->addWidget(m_fpsLabel, 0);
hLay->addWidget(m_fpsField, 0);
hLay->addWidget(m_fpsSlider, 1);
}
fpsSliderFrame->setLayout(hLay);
connect(m_fpsSlider, SIGNAL(valueChanged(int)), this, SLOT(setCurrentFPS(int)));
connect(m_fpsField, SIGNAL(editingFinished()), this, SLOT(onFPSEdited()));
return fpsSliderFrame;
}
//--------------------------------------------------------------------
void FlipConsole::onFPSEdited(void)
{
// this will emit fpsSlider->ValueChanged as well
m_fpsSlider->setValue(m_fpsField->getValue());
}
//--------------------------------------------------------------------
void FlipConsole::setFrameRange(int from, int to, int step, int current)
{
if (from != m_from || to != m_to || step != m_step) {
m_from = from;
m_to = to;
m_step = step;
m_to -= (m_to - m_from) % m_step;
m_framesCount = (m_to - m_from) / m_step + 1;
m_currFrameSlider->blockSignals(true);
//m_currFrameSlider->setRange(0, m_framesCount-1);
m_currFrameSlider->setRange(m_from, m_to);
m_currFrameSlider->setSingleStep(m_step);
m_currFrameSlider->blockSignals(false);
}
if (m_playbackExecutor.isRunning() || m_isLinkedPlaying) //if in playing mode, the slider and the frame field are already set in the timer!
return;
// limit the current frame in the range from-to
if (current < from)
current = from;
else if (current > to)
current = to;
m_currFrameSlider->blockSignals(true);
setCurrentFrame(current);
m_currFrameSlider->blockSignals(false);
}
//--------------------------------------------------------------------
void FlipConsole::incrementCurrentFrame(int delta)
{
m_currentFrame = m_currentFrame + delta;
if (m_currentFrame < m_from)
m_currentFrame += m_to - m_from + 1;
else if (m_currentFrame > m_to)
m_currentFrame -= m_to - m_from + 1;
m_editCurrFrame->setText(QString::number(m_currentFrame));
m_currFrameSlider->setValue(m_currentFrame);
m_consoleOwner->onDrawFrame(m_currentFrame, m_settings);
}
//--------------------------------------------------------------------
void FlipConsole::OnSetCurrentFrame()
{
int newFrame = m_editCurrFrame->text().toInt();
if (m_step > 1) {
newFrame -= ((newFrame - m_from) % m_step);
m_editCurrFrame->setText(QString::number(newFrame));
}
int i, deltaFrame = newFrame - m_currentFrame;
if (m_framesCount == 0)
m_editCurrFrame->setText(QString::number(1));
if (m_framesCount == 0 || newFrame == m_currentFrame || newFrame == 0)
return;
if (newFrame > m_to) {
m_editCurrFrame->setText(QString::number(m_currentFrame));
return;
}
m_currentFrame = newFrame;
m_currFrameSlider->setValue(m_currentFrame);
m_consoleOwner->onDrawFrame(m_currentFrame, m_settings);
if (m_areLinked)
for (i = 0; i < m_visibleConsoles.size(); i++) {
FlipConsole *console = m_visibleConsoles.at(i);
if (console->m_isLinkable && console != this)
console->incrementCurrentFrame(deltaFrame);
}
}
//--------------------------------------------------------------------
void FlipConsole::onSliderRelease()
{
emit sliderReleased();
}
//--------------------------------------------------------------------
void FlipConsole::OnFrameSliderRelease()
{
m_settings.m_recomputeIfNeeded = true;
m_currentFrame = -1;
OnSetCurrentFrame();
}
void FlipConsole::OnFrameSliderPress()
{
m_settings.m_recomputeIfNeeded = false;
}
//---------------------
//----------------------------------
void FlipConsole::OnSetCurrentFrame(int index)
{
if (m_framesCount == 0)
return;
if (index == m_currentFrame)
return;
int deltaFrame = index - m_currentFrame;
m_currentFrame = index;
assert(m_currentFrame <= m_to);
m_editCurrFrame->setText(QString::number(m_currentFrame));
m_consoleOwner->onDrawFrame(m_currentFrame, m_settings);
if (m_areLinked)
for (int i = 0; i < m_visibleConsoles.size(); i++) {
FlipConsole *console = m_visibleConsoles.at(i);
if (console->m_isLinkable && console != this)
console->incrementCurrentFrame(deltaFrame);
}
}
//--------------------------------------------------------------------
void FlipConsole::setCurrentFrame(int frame, bool forceResetting)
{
m_currentFrame = (frame == -1) ? m_from : frame;
if ((m_playbackExecutor.isRunning() || m_isLinkedPlaying) && !forceResetting) //if in playing mode, the slider and the frame field are already set in the timer!
return;
m_editCurrFrame->setValue(m_currentFrame);
m_currFrameSlider->setValue(m_currentFrame);
}
//--------------------------------------------------------------------
void FlipConsole::enableProgressBar(bool enable)
{
m_currFrameSlider->setProgressBarEnabled(enable);
}
//--------------------------------------------------------------------
void FlipConsole::setProgressBarStatus(const std::vector<UCHAR> *pbStatus)
{
m_currFrameSlider->setProgressBarStatus(pbStatus);
}
//--------------------------------------------------------------------
const std::vector<UCHAR> *FlipConsole::getProgressBarStatus() const
{
return m_currFrameSlider->getProgressBarStatus();
}
//--------------------------------------------------------------------
void FlipConsole::onPreferenceChanged()
{
if (m_drawBlanksEnabled) {
Preferences::instance()->getBlankValues(m_blanksCount, m_blankColor);
if (m_blanksCount == 0) {
if (m_enableBlankFrameButton->isVisible())
m_enableBlankFrameButton->hide();
} else {
if (m_enableBlankFrameButton->isHidden())
m_enableBlankFrameButton->show();
QString buttonText = QString("+%1 Blank").arg(m_blanksCount);
if (m_blanksCount > 1)
buttonText += "s";
m_enableBlankFrameButton->setText(buttonText);
//--- use white text for dark color and vice versa
QString textColor;
QString dimmedTextColor;
int val = (int)m_blankColor.r * 30 +
(int)m_blankColor.g * 59 +
(int)m_blankColor.b * 11;
if (val < 12800) {
textColor = QString("white");
dimmedTextColor = QString("rgb(200,200,200)");
} else {
textColor = QString("black");
dimmedTextColor = QString("rgb(55,55,55)");
}
int dc = 150;
QColor lightBevel(tmin(m_blankColor.r + dc, 255),
tmin(m_blankColor.g + dc, 255),
tmin(m_blankColor.b + dc, 255));
QColor darkBevel(tmax(m_blankColor.r - dc, 0),
tmax(m_blankColor.g - dc, 0),
tmax(m_blankColor.b - dc, 0));
m_enableBlankFrameButton->setStyleSheet(
QString("#enableBlankFrameButton{ \
background-color: transparent; \
padding: 2px;\
font-weight: bold; \
font-size: 12px; \
color: %11;\
border-style: inset; \
border-left-color: rgb(%5,%6,%7); \
border-top-color: rgb(%5,%6,%7); \
border-right-color: rgb(%8,%9,%10); \
border-bottom-color: rgb(%8,%9,%10); \
border-width: 2px; \
border-radius: 3px; \
} \
#enableBlankFrameButton:checked { \
background-color: rgb(%1,%2,%3); \
color: %4; \
border-style: outset; \
border-left-color: rgb(%8,%9,%10); \
border-top-color: rgb(%8,%9,%10); \
border-right-color: rgb(%5,%6,%7); \
border-bottom-color: rgb(%5,%6,%7); \
} ")
.arg(m_blankColor.r)
.arg(m_blankColor.g)
.arg(m_blankColor.b)
.arg(textColor)
.arg(lightBevel.red())
.arg(lightBevel.green())
.arg(lightBevel.blue())
.arg(darkBevel.red())
.arg(darkBevel.green())
.arg(darkBevel.blue())
.arg(dimmedTextColor));
m_enableBlankFrameButton->update();
}
}
}
//====================================================================
class FlipConsoleActionsCreator : AuxActionsCreator
{
void createToggleAction(
QObject *parent,
const char *cmdId,
const char *name,
int buttonId)
{
QAction *action = new QAction(name, parent);
action->setData(QVariant(buttonId));
CommandManager::instance()->define(cmdId, MiscCommandType, "", action);
}
public:
void createActions(QObject *parent)
{
/*createToggleAction(parent, "A_Flip_Play", "Play", FlipConsole::ePlay);
createToggleAction(parent, "A_Flip_Pause", "Pause", FlipConsole::ePause);
createToggleAction(parent, "A_Flip_Loop", "Loop", FlipConsole::eLoop);*/
}
} flipConsoleActionsCreator;
//--------------------------------------------------------------------
Reference in a new issue Copy permalink