KisAnimTimelineDocker Class Reference

Krita's Animation Timeline Docker. This is the GUI heart of Krita's traditional animation workflow, and is where artists can configure, edit, scrub and play their animation. More...

#include <KisAnimTimelineDocker.h>

Inheritance diagram for KisAnimTimelineDocker:

Classes
struct	Private

Public Slots
void	handleFrameRateChange ()
void	handleThemeChange ()
void	setAutoKey (bool value)
void	setImageAnimSettings ()
void	togglePlayback ()
void	updateFrameCache ()
void	updateFrameRegister ()
void	updatePlaybackStatistics ()

Public Member Functions
	KisAnimTimelineDocker ()
QString	observerName () override
void	setCanvas (KoCanvasBase *canvas) override
void	setPlaybackEngine (KisPlaybackEngine *playbackEngine)
void	setViewManager (KisViewManager *kisview) override
void	unsetCanvas () override
	~KisAnimTimelineDocker () override
Public Member Functions inherited from KisMainwindowObserver
	KisMainwindowObserver ()
	~KisMainwindowObserver () override
Public Member Functions inherited from KoCanvasObserverBase
	KoCanvasObserverBase ()
KoCanvasBase *	observedCanvas () const
void	setObservedCanvas (KoCanvasBase *canvas)
void	unsetObservedCanvas ()
virtual	~KoCanvasObserverBase ()

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members

Detailed Description

Krita's Animation Timeline Docker. This is the GUI heart of Krita's traditional animation workflow, and is where artists can configure, edit, scrub and play their animation.

Currently interacts with the TimelineFramesView/Model as well as the KisImageAnimationInterface. (TODO: Consider refactoring to streamline this interaction towards Docker -> AnimationPlayer -> ImageAnimInterface)

Definition at line 90 of file KisAnimTimelineDocker.h.

Constructor & Destructor Documentation

KisAnimTimelineDocker()

KisAnimTimelineDocker::KisAnimTimelineDocker

(

)

Definition at line 300 of file KisAnimTimelineDocker.cpp.

    : QDockWidget(i18n("Animation Timeline"))
    , m_d(new Private(this))
{
    setWidget(m_d->framesView);
 
    // Titlebar Widget..
    setTitleBarWidget(m_d->titlebar);
 
    connect(m_d->titlebar->btnOnionSkinsMenu, &QToolButton::released, [this](){
        if (m_d->mainWindow) {
            QDockWidget *docker = m_d->mainWindow->dockWidget("OnionSkinsDocker");
            if (docker) {
                docker->setVisible(!docker->isVisible());
            }
        }
    });
 
    {
        using namespace KisWidgetConnectionUtils;
        connectControl(m_d->titlebar->sbSpeed, &m_d->controlsModel, "playbackSpeedDenorm");
    }
 
    // Watch for KisPlaybackEngine changes and initialize current one..
    connect(KisPart::instance(), &KisPart::playbackEngineChanged, this, &KisAnimTimelineDocker::setPlaybackEngine);
    setPlaybackEngine(KisPart::instance()->playbackEngine());
 
    setEnabled(false);
}

References connect(), and m_d.

~KisAnimTimelineDocker()

KisAnimTimelineDocker::~KisAnimTimelineDocker ( )

override

Definition at line 330 of file KisAnimTimelineDocker.cpp.

{
}

Member Function Documentation

handleFrameRateChange

void KisAnimTimelineDocker::handleFrameRateChange ( )

slot

Definition at line 756 of file KisAnimTimelineDocker.cpp.

{
    if (!m_d->canvas || !m_d->canvas->image()) return;
 
    KisImageAnimationInterface *animInterface = m_d->canvas->image()->animationInterface();
 
    m_d->titlebar->sbFrameRate->setValue(animInterface->framerate());
}

References KisImage::animationInterface(), KisImageAnimationInterface::framerate(), KisImageAnimationInterface::image(), and m_d.

handleThemeChange

void KisAnimTimelineDocker::handleThemeChange ( )

slot

Definition at line 486 of file KisAnimTimelineDocker.cpp.

{
    if (m_d->framesView) {
        m_d->framesView->slotUpdateIcons();
    }
}

References m_d.

observerName()

QString KisAnimTimelineDocker::observerName ( )

inlineoverridevirtual

Reimplemented from KoCanvasObserverBase.

Definition at line 97 of file KisAnimTimelineDocker.h.

{ return "TimelineDocker"; }

setAutoKey

void KisAnimTimelineDocker::setAutoKey ( bool value )

slot

Definition at line 742 of file KisAnimTimelineDocker.cpp.

{
    {
        KisImageConfig cfg(false);
        if (value != cfg.autoKeyEnabled()) {
            cfg.setAutoKeyEnabled(value);
            const QIcon icon = cfg.autoKeyEnabled() ? KisIconUtils::loadIcon("auto-key-on") : KisIconUtils::loadIcon("auto-key-off");
            QAction* action = m_d->titlebar->btnAutoKey->defaultAction();
            action->setIcon(icon);
        }
    }
    KisImageConfigNotifier::instance()->notifyAutoKeyFrameConfigurationChanged();
}

References KisImageConfig::autoKeyEnabled(), KisImageConfigNotifier::instance(), KisIconUtils::loadIcon(), m_d, KisImageConfigNotifier::notifyAutoKeyFrameConfigurationChanged(), KisImageConfig::setAutoKeyEnabled(), and value().

setCanvas()

void KisAnimTimelineDocker::setCanvas ( KoCanvasBase * canvas )

overridevirtual

re-implement this method in your canvas observer. It will be called whenever a canvas becomes active. Note that you are responsible for not connecting more than one time to the signals of a canvas or any of the QObjects you can access through the canvas.

Implements KoCanvasObserverBase.

Definition at line 355 of file KisAnimTimelineDocker.cpp.

{
    if (m_d->canvas == canvas) return;
 
    if (m_d->framesModel->hasConnectionToCanvas()) {
        m_d->canvasConnections.clear();
        m_d->framesModel->setDummiesFacade(0, 0, 0);
        m_d->framesModel->setFrameCache(0);
        m_d->framesModel->setAnimationPlayer(0);
        m_d->framesModel->setDocument(0);
        m_d->framesModel->setNodeManipulationInterface(0);
    }
 
    // Deinitialize from previous canvas...
    if (m_d->canvas) { 
        m_d->canvas->disconnectCanvasObserver(this);
        m_d->canvas->animationState()->disconnect(this);
        m_d->titlebar->transport->setPlaying(false);
 
        m_d->titlebar->btnAudioMenu->setEnabled(false);
 
        if(m_d->canvas->image()) {
            m_d->canvas->image()->animationInterface()->disconnect(this);
            m_d->titlebar->sbStartFrame->disconnect(m_d->canvas->image()->animationInterface());
            m_d->titlebar->sbEndFrame->disconnect(m_d->canvas->image()->animationInterface());
            m_d->titlebar->sbFrameRate->disconnect(m_d->canvas->image()->animationInterface());
        }
    }
 
    m_d->canvas = dynamic_cast<KisCanvas2*>(canvas);
    setEnabled(m_d->canvas != 0);
    m_d->framesView->slotCanvasUpdate(m_d->canvas);
 
    // Reinitialize new canvas..
    if (m_d->canvas) {
        KisDocument *doc = static_cast<KisDocument*>(m_d->canvas->imageView()->document());
        KisShapeController *kritaShapeController = dynamic_cast<KisShapeController*>(doc->shapeController());
        m_d->framesModel->setDummiesFacade(kritaShapeController,
                                     m_d->canvas->image(),
                                     m_d->canvas->viewManager()->nodeManager()->nodeDisplayModeAdapter());
 
        m_d->framesModel->setDocument(doc);
 
        updateFrameCache();
 
        {   // Titlebar widgets...
            KisSignalsBlocker blocker(m_d->titlebar->sbStartFrame,
                                      m_d->titlebar->sbEndFrame,
                                      m_d->titlebar->sbFrameRate,
                                      m_d->titlebar->frameRegister);
 
            KisImageAnimationInterface *animinterface = m_d->canvas->image()->animationInterface();
            m_d->titlebar->sbStartFrame->setValue(animinterface->documentPlaybackRange().start());
            m_d->titlebar->sbEndFrame->setValue(animinterface->documentPlaybackRange().end());
            m_d->titlebar->sbFrameRate->setValue(animinterface->framerate());
            m_d->titlebar->frameRegister->setValue(animinterface->currentTime());
            
            m_d->titlebar->btnAudioMenu->setEnabled(true); // Menu is disabled until a canvas is loaded.
        }
 
        m_d->framesModel->setAnimationPlayer(m_d->canvas->animationState());
 
        m_d->framesModel->setNodeManipulationInterface(
            new NodeManagerInterface(m_d->canvas->viewManager()->nodeManager()));
 
        m_d->canvasConnections.addConnection(
            m_d->canvas->viewManager()->nodeManager(), SIGNAL(sigNodeActivated(KisNodeSP)),
            m_d->framesModel, SLOT(slotCurrentNodeChanged(KisNodeSP)));
 
        m_d->canvasConnections.addConnection(
            m_d->framesModel, SIGNAL(requestCurrentNodeChanged(KisNodeSP)),
            m_d->canvas->viewManager()->nodeManager(), SLOT(slotNonUiActivatedNode(KisNodeSP)));
 
        m_d->framesModel->slotCurrentNodeChanged(m_d->canvas->viewManager()->activeNode());
 
        m_d->canvasConnections.addConnection(
                    m_d->canvas->viewManager()->mainWindow(), SIGNAL(themeChanged()),
                    this, SLOT(handleThemeChange()));
 
        m_d->canvasConnections.addConnection(
                    m_d->canvas, SIGNAL(sigCanvasEngineChanged()),
                    this, SLOT(updateFrameCache()));
 
        m_d->titlebar->transport->setPlaying(m_d->canvas->animationState()->playbackState() == PlaybackState::PLAYING);
 
        m_d->titlebar->volumeSlider->setValue(m_d->framesModel->audioVolume() * 100.0);
 
        connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigFramerateChanged()), SLOT(handleFrameRateChange()));
 
        connect(m_d->titlebar->sbFrameRate, SIGNAL(valueChanged(int)), this, SLOT(setImageAnimSettings()));
        connect(m_d->titlebar->sbStartFrame, SIGNAL(valueChanged(int)), this, SLOT(setImageAnimSettings()));
        connect(m_d->titlebar->sbEndFrame, SIGNAL(valueChanged(int)), this, SLOT(setImageAnimSettings()));
 
        connect(m_d->canvas->image()->animationInterface(), &KisImageAnimationInterface::sigDocumentRangeChanged, this, [this]() {
            if (!m_d->canvas || !m_d->canvas->image()) return;
 
            KisImageAnimationInterface *animInterface = m_d->canvas->image()->animationInterface();
 
            int start = animInterface->documentPlaybackRange().start();
            int end = animInterface->documentPlaybackRange().end();
 
            m_d->titlebar->sbStartFrame->setValue(start);
            m_d->titlebar->sbEndFrame->setValue(end);
 
            //Auto zoom Timeline to new document playback range..
            KisConfig cfg(true);
            if (cfg.autoZoomTimelineToPlaybackRange()) {
                m_d->framesView->slotFitViewToFrameRange(0, end); // TODO: fit from start to end, instead of 0 to end.
            }
        });
 
        connect(m_d->canvas->animationState(), SIGNAL(sigFrameChanged()), this, SLOT(updateFrameRegister()));
        connect(m_d->canvas->animationState(), &KisCanvasAnimationState::sigPlaybackStateChanged, this, [this](PlaybackState state){
            m_d->titlebar->frameRegister->setDisabled(state == PlaybackState::PLAYING);
            if (state == PlaybackState::STOPPED) {
                updateFrameRegister();
            }
        });
        connect(m_d->canvas->animationState(), &KisCanvasAnimationState::sigPlaybackStateChanged, this, [this](PlaybackState state){
            m_d->titlebar->transport->setPlaying(state == PlaybackState::PLAYING);
        });
 
        connect(m_d->canvas->animationState(), &KisCanvasAnimationState::sigPlaybackStatisticsUpdated,
                this, &KisAnimTimelineDocker::updatePlaybackStatistics);
 
        connect(m_d->canvas->image()->animationInterface(), SIGNAL(sigUiTimeChanged(int)), this, SLOT(updateFrameRegister()));
 
        m_d->controlsModel.connectAnimationState(m_d->canvas->animationState());
    }
}

References KisImage::animationInterface(), Private::canvas, connect(), KisImageAnimationInterface::currentTime(), KisImageAnimationInterface::documentPlaybackRange(), KisTimeSpan::end(), KisImageAnimationInterface::framerate(), handleFrameRateChange(), handleThemeChange(), KisImageAnimationInterface::image(), KisDummiesFacadeBase::image(), m_d, KisNodeManager::nodeDisplayModeAdapter(), KisViewManager::nodeManager(), PLAYING, setImageAnimSettings(), KisDocument::shapeController, KisImageAnimationInterface::sigDocumentRangeChanged(), KisCanvasAnimationState::sigPlaybackStateChanged(), KisTimeSpan::start(), updateFrameCache(), updateFrameRegister(), and KisCanvas2::viewManager().

setImageAnimSettings

void KisAnimTimelineDocker::setImageAnimSettings ( )

slot

Definition at line 493 of file KisAnimTimelineDocker.cpp.

{
    if (!m_d->canvas || !m_d->canvas->image()) return;
 
    KisImageAnimSettingCommand::Settings settings = {
        m_d->titlebar->sbFrameRate->value(),
        m_d->titlebar->sbStartFrame->value(),
        m_d->titlebar->sbEndFrame->value()
    };
 
    KisImageAnimSettingCommand *undoCommand = new KisImageAnimSettingCommand(m_d->canvas->image()->animationInterface(), settings);
 
    //KisProcessingApplicator::applyCommand(undoCommand);
    QScopedPointer<KisProcessingApplicator> applicator(
        new KisProcessingApplicator(m_d->canvas->image(), 0, KisProcessingApplicator::NONE,
                                    KisImageSignalVector(),
                                    undoCommand->text(),
                                    0, undoCommand->id()));
    applicator->applyCommand(undoCommand);
    applicator->end();
}

References KisImageAnimSettingCommand::id(), m_d, KisProcessingApplicator::NONE, and KUndo2Command::text().

setPlaybackEngine()

void KisAnimTimelineDocker::setPlaybackEngine

(

KisPlaybackEngine *

playbackEngine

)

Definition at line 699 of file KisAnimTimelineDocker.cpp.

{
    if (!playbackEngine) return;
 
    // Connect transport controls..
    connect(m_d->titlebar->transport, SIGNAL(skipBack()), playbackEngine, SLOT(previousKeyframe()), Qt::UniqueConnection);
    connect(m_d->titlebar->transport, SIGNAL(back()), playbackEngine, SLOT(previousFrame()), Qt::UniqueConnection);
    connect(m_d->titlebar->transport, SIGNAL(stop()), playbackEngine, SLOT(stop()), Qt::UniqueConnection);
    connect(m_d->titlebar->transport, SIGNAL(playPause()), this, SLOT(togglePlayback()), Qt::UniqueConnection);
    connect(m_d->titlebar->transport, SIGNAL(forward()), playbackEngine, SLOT(nextFrame()), Qt::UniqueConnection);
    connect(m_d->titlebar->transport, SIGNAL(skipForward()), playbackEngine, SLOT(nextKeyframe()), Qt::UniqueConnection);
 
    connect(m_d->titlebar->frameRegister, SIGNAL(valueChanged(int)), playbackEngine, SLOT(seek(int)), Qt::UniqueConnection);
 
    m_d->controlsModel.connectPlaybackEngine(playbackEngine);
 
    m_d->playbackEngine = playbackEngine;
}

References connect(), m_d, and togglePlayback().

setViewManager()

void KisAnimTimelineDocker::setViewManager ( KisViewManager * kisview )

overridevirtual

Implements KisMainwindowObserver.

Definition at line 595 of file KisAnimTimelineDocker.cpp.

{
    m_d->mainWindow = view->mainWindow();
    KisActionManager *actionManager = view->actionManager();
    m_d->framesView->setActionManager(actionManager);
 
    KisAction *action = 0;
 
    KisAnimTimelineDockerTitlebar* titleBar = static_cast<KisAnimTimelineDockerTitlebar*>(titleBarWidget());
 
    action = actionManager->actionByName("add_blank_frame");
    titleBar->btnAddKeyframe->setDefaultAction(action);
    titleBar->btnAddKeyframe->setIconSize(QSize(22, 22));
 
    action = actionManager->actionByName("add_duplicate_frame");
    titleBar->btnDuplicateKeyframe->setDefaultAction(action);
    titleBar->btnDuplicateKeyframe->setIconSize(QSize(22, 22));
 
    action = actionManager->actionByName("remove_frames");
    titleBar->btnRemoveKeyframe->setDefaultAction(action);
    titleBar->btnRemoveKeyframe->setIconSize(QSize(22, 22));
 
    // Connect playback-related actions..
    action = actionManager->createAction("toggle_playback");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), this, SLOT(togglePlayback()));
 
    action = actionManager->createAction("stop_playback");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), m_d->playbackEngine, SLOT(stop()));
 
    action = actionManager->createAction("previous_frame");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), m_d->playbackEngine, SLOT(previousFrame()));
 
    action = actionManager->createAction("next_frame");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), m_d->playbackEngine, SLOT(nextFrame()));
 
    action = actionManager->createAction("previous_keyframe");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), m_d->playbackEngine, SLOT(previousKeyframe()));
 
    action = actionManager->createAction("next_keyframe");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), m_d->playbackEngine, SLOT(nextKeyframe()));
 
    action = actionManager->createAction("previous_matching_keyframe");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), m_d->playbackEngine, SLOT(previousMatchingKeyframe()));
 
    action = actionManager->createAction("next_matching_keyframe");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), m_d->playbackEngine, SLOT(nextMatchingKeyframe()));
 
    action = actionManager->createAction("previous_unfiltered_keyframe");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), m_d->playbackEngine, SLOT(previousUnfilteredKeyframe()));
 
    action = actionManager->createAction("next_unfiltered_keyframe");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, SIGNAL(triggered(bool)), m_d->playbackEngine, SLOT(nextUnfilteredKeyframe()));
 
    action = actionManager->createAction("first_frame");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, &KisAction::triggered, this, [this](bool){
       if (m_d->canvas) {
           m_d->playbackEngine->firstFrame();
       }
    });
 
    action = actionManager->createAction("last_frame");
    action->setActivationFlags(KisAction::ACTIVE_IMAGE);
    connect(action, &KisAction::triggered, this, [this](bool){
       if (m_d->canvas) {
           m_d->playbackEngine->lastFrame();
       }
    });
 
    {
        action = actionManager->createAction("auto_key");
        m_d->titlebar->btnAutoKey->setDefaultAction(action);
        m_d->titlebar->btnAutoKey->setIconSize(QSize(22, 22));
        connect(action, SIGNAL(triggered(bool)), SLOT(setAutoKey(bool)));
 
        KisImageConfig config(true);
        action->setChecked(config.autoKeyEnabled());
        action->setIcon(config.autoKeyEnabled() ? KisIconUtils::loadIcon("auto-key-on") : KisIconUtils::loadIcon("auto-key-off"));
 
        const bool autoKeyModeDuplicate = config.autoKeyModeDuplicate();
        m_d->titlebar->autoKeyBlank->setChecked(!autoKeyModeDuplicate);
        m_d->titlebar->autoKeyDuplicate->setChecked(autoKeyModeDuplicate);
    }
 
    {
        action = actionManager->createAction("drop_frames");
        m_d->titlebar->btnDropFrames->setDefaultAction(action);
        m_d->titlebar->btnDropFrames->setIconSize(QSize(22, 22));
 
        using namespace KisWidgetConnectionUtils;
        connectControl(action, &m_d->controlsModel, "dropFramesMode");
    }
}

References KisActionManager::actionByName(), KisViewManager::actionManager(), KisAction::ACTIVE_IMAGE, KisImageConfig::autoKeyEnabled(), KisImageConfig::autoKeyModeDuplicate(), KisAnimTimelineDockerTitlebar::btnAddKeyframe, KisAnimTimelineDockerTitlebar::btnDuplicateKeyframe, KisAnimTimelineDockerTitlebar::btnRemoveKeyframe, connect(), KisActionManager::createAction(), KisIconUtils::loadIcon(), m_d, KisViewManager::mainWindow(), KisAction::setActivationFlags(), setAutoKey(), and togglePlayback().

togglePlayback

void KisAnimTimelineDocker::togglePlayback ( )

slot

Definition at line 718 of file KisAnimTimelineDocker.cpp.

{
    m_d->playbackEngine->playPause();
 
    KisImageAnimationInterface *animInterface = m_d->canvas->image()->animationInterface();
    KisCanvasAnimationState *animState = m_d->canvas->animationState();
 
    if (!animInterface || !animState) return;
 
    if (animState->playbackState() == PlaybackState::PAUSED) {
        QModelIndexList selectedIndices = m_d->framesView->selectionModel()->selectedIndexes();
        QModelIndex currentIndex = m_d->framesView->currentIndex();
        const int pausedTime = animInterface->currentTime();
 
        QModelIndex pauseIndex = m_d->framesModel->index(currentIndex.row(), pausedTime);
 
        if (!pauseIndex.isValid()) return;
 
        if (!selectedIndices.contains(pauseIndex)) {
            m_d->framesView->setCurrentIndex(pauseIndex);
        }
    }
}

References KisImage::animationInterface(), KisImageAnimationInterface::currentTime(), KisImageAnimationInterface::image(), m_d, PAUSED, KisCanvasAnimationState::playbackState(), and KisPlaybackEngine::playPause().

unsetCanvas()

void KisAnimTimelineDocker::unsetCanvas ( )

overridevirtual

Re-implement to notify the observer that its canvas is no longer among the living. The daisies, it is pushing up. This means you don't have to disconnect, it's dead.

The old canvas should be deleted already, so if you stored a pointer to it, don't touch!

Note that currently there is a bug where in certain specific circumstances unsetCanvas can be called when it shouldn't, see for example KWStatisticsDocker for a workaround for this problem.

Implements KoCanvasObserverBase.

Definition at line 590 of file KisAnimTimelineDocker.cpp.

{
    setCanvas(0);
}

References setCanvas().

updateFrameCache

void KisAnimTimelineDocker::updateFrameCache ( )

slot

Definition at line 515 of file KisAnimTimelineDocker.cpp.

{
    m_d->framesModel->setFrameCache(m_d->canvas->frameCache());
}

References m_d.

updateFrameRegister

void KisAnimTimelineDocker::updateFrameRegister ( )

slot

Definition at line 520 of file KisAnimTimelineDocker.cpp.

{
    if (!m_d->canvas && !m_d->canvas->image()) {
        return;
    }
 
    const int frame = m_d->canvas->animationState()->displayProxy()->activeFrame();
 
    QSignalBlocker blocker(m_d->titlebar->frameRegister);
    m_d->titlebar->frameRegister->setValue(frame);
}

References m_d.

updatePlaybackStatistics

void KisAnimTimelineDocker::updatePlaybackStatistics ( )

slot

NOTE: we update stats on the action, but not on the button itself, so the stats will automatically propagate to all the buttons that use this action, including the one in the curves docker

Definition at line 532 of file KisAnimTimelineDocker.cpp.

{
    if (!m_d->playbackEngine) return;
 
    QString playbackEngineClass = m_d->playbackEngine->metaObject()->className();
 
    qreal effectiveFps = 0.0;
    qreal realFps = 0.0;
    qreal framesDropped = 0.0;
    bool isPlaying = false;
 
    {
        KisPlaybackEngine::PlaybackStats stats = m_d->playbackEngine->playbackStatistics();
        effectiveFps = stats.expectedFps;
        realFps = stats.realFps;
        framesDropped = stats.droppedFramesPortion;
        isPlaying = effectiveFps > 0.0;
    }
 
    KisConfig cfg(true);
    const bool shouldDropFrames = cfg.animationDropFrames();
 
    QAction *action = m_d->titlebar->btnDropFrames->defaultAction();
    const bool droppingFrames = framesDropped > 0.05;
    action->setIcon(KisIconUtils::loadIcon(droppingFrames ? "droppedframes" : "dropframe"));
 
    QString actionText;
    if (!isPlaying) {
        actionText = QString("%1 (%2)\n"
                             "%3\n"
                             "[PlaybackEngine: %4]")
            .arg(KisAnimUtils::dropFramesActionName)
            .arg(KritaUtils::toLocalizedOnOff(shouldDropFrames))
            .arg(i18n("Enable to preserve playback timing."))
            .arg(playbackEngineClass);
    } else {
        actionText = QString("%1 (%2)\n"
                       "%3\n"
                       "%4\n"
                       "%5\n"
                       "[PlaybackEngine: %6]")
            .arg(KisAnimUtils::dropFramesActionName)
            .arg(KritaUtils::toLocalizedOnOff(shouldDropFrames))
                         .arg(i18n("Effective FPS:\t%1", QString::number(effectiveFps, 'f', 1)))
            .arg(i18n("Real FPS:\t%1", QString::number(realFps, 'f', 1)))
            .arg(i18n("Frames dropped:\t%1\%", QString::number(framesDropped * 100, 'f', 1)))
            .arg(playbackEngineClass);
    }
 
    action->setToolTip(actionText);
}

References KisConfig::animationDropFrames(), KisAnimUtils::dropFramesActionName, KisPlaybackEngine::PlaybackStats::droppedFramesPortion, KisPlaybackEngine::PlaybackStats::expectedFps, KisIconUtils::loadIcon(), m_d, KisPlaybackEngine::PlaybackStats::realFps, and KritaUtils::toLocalizedOnOff().

Member Data Documentation

m_d

const QScopedPointer<Private> KisAnimTimelineDocker::m_d

private

Definition at line 119 of file KisAnimTimelineDocker.h.

---

The documentation for this class was generated from the following files:

• plugins/dockers/animation/KisAnimTimelineDocker.h
• plugins/dockers/animation/KisAnimTimelineDocker.cpp