diff --git a/libs/ui/KisPart.cpp b/libs/ui/KisPart.cpp
index c375c4900b..bfffa47e12 100644
--- a/libs/ui/KisPart.cpp
+++ b/libs/ui/KisPart.cpp
@@ -1,580 +1,590 @@
 /* This file is part of the KDE project
  * Copyright (C) 1998-1999 Torben Weis       <weis@kde.org>
  * Copyright (C) 2000-2005 David Faure       <faure@kde.org>
  * Copyright (C) 2007-2008 Thorsten Zachmann <zachmann@kde.org>
  * Copyright (C) 2010-2012 Boudewijn Rempt   <boud@valdyas.org>
  * Copyright (C) 2011 Inge Wallin            <ingwa@kogmbh.com>
  * Copyright (C) 2015 Michael Abrahams       <miabraha@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisPart.h"
 
 #include "KoProgressProxy.h"
 #include <KoCanvasController.h>
 #include <KoCanvasControllerWidget.h>
 #include <KoColorSpaceEngine.h>
 #include <KoCanvasBase.h>
 #include <KoToolManager.h>
 #include <KoShapeControllerBase.h>
 #include <KoResourceServerProvider.h>
 #include <kis_icon.h>
 
 #include "KisApplication.h"
 #include "KisMainWindow.h"
 #include "KisDocument.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "KisImportExportManager.h"
 
 #include <kis_debug.h>
 #include <KoResourcePaths.h>
 #include <KoDialog.h>
 #include <kdesktopfile.h>
 #include <QMessageBox>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <QKeySequence>
 
 #include <QDialog>
 #include <QApplication>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QGlobalStatic>
 #include <KisMimeDatabase.h>
 #include <dialogs/KisSessionManagerDialog.h>
 
 #include "kis_config.h"
 #include "kis_shape_controller.h"
 #include "KisResourceServerProvider.h"
 #include "kis_animation_cache_populator.h"
+#include "kis_image_animation_interface.h"
+#include "kis_time_range.h"
 #include "kis_idle_watcher.h"
 #include "kis_image.h"
 #include "KisOpenPane.h"
 
 #include "kis_color_manager.h"
 
 #include "kis_action.h"
 #include "kis_action_registry.h"
 #include "KisSessionResource.h"
 #include "KisBusyWaitBroker.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 
 Q_GLOBAL_STATIC(KisPart, s_instance)
 
 
 class Q_DECL_HIDDEN KisPart::Private
 {
 public:
     Private(KisPart *_part)
         : part(_part)
         , idleWatcher(2500)
         , animationCachePopulator(_part)
     {
     }
 
     ~Private()
     {
     }
 
     KisPart *part;
 
     QList<QPointer<KisView> > views;
     QList<QPointer<KisMainWindow> > mainWindows;
     QList<QPointer<KisDocument> > documents;
     KActionCollection *actionCollection{0};
     KisIdleWatcher idleWatcher;
     KisAnimationCachePopulator animationCachePopulator;
 
     KisSessionResource *currentSession = nullptr;
     bool closingSession{false};
     QScopedPointer<KisSessionManagerDialog> sessionManager;
 
     bool queryCloseDocument(KisDocument *document) {
         Q_FOREACH(auto view, views) {
             if (view && view->isVisible() && view->document() == document) {
                 return view->queryClose();
             }
         }
 
         return true;
     }
 };
 
 
 KisPart* KisPart::instance()
 {
     return s_instance;
 }
 
 namespace {
 void busyWaitWithFeedback(KisImageSP image)
 {
     const int busyWaitDelay = 1000;
     KisDelayedSaveDialog dialog(image, KisDelayedSaveDialog::ForcedDialog, busyWaitDelay, KisPart::instance()->currentMainwindow());
     dialog.blockIfImageIsBusy();
 }
 }
 
 KisPart::KisPart()
     : d(new Private(this))
 {
     // Preload all the resources in the background
     Q_UNUSED(KoResourceServerProvider::instance());
     Q_UNUSED(KisResourceServerProvider::instance());
     Q_UNUSED(KisColorManager::instance());
 
     connect(this, SIGNAL(documentOpened(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(this, SIGNAL(documentClosed(QString)),
             this, SLOT(updateIdleWatcherConnections()));
 
     connect(KisActionRegistry::instance(), SIGNAL(shortcutsUpdated()),
             this, SLOT(updateShortcuts()));
     connect(&d->idleWatcher, SIGNAL(startedIdleMode()),
             &d->animationCachePopulator, SLOT(slotRequestRegeneration()));
 
 
     d->animationCachePopulator.slotRequestRegeneration();
     KisBusyWaitBroker::instance()->setFeedbackCallback(&busyWaitWithFeedback);
 }
 
 KisPart::~KisPart()
 {
     while (!d->documents.isEmpty()) {
         delete d->documents.takeFirst();
     }
 
     while (!d->views.isEmpty()) {
         delete d->views.takeFirst();
     }
 
     while (!d->mainWindows.isEmpty()) {
         delete d->mainWindows.takeFirst();
     }
 
     delete d;
 }
 
 void KisPart::updateIdleWatcherConnections()
 {
     QVector<KisImageSP> images;
 
     Q_FOREACH (QPointer<KisDocument> document, documents()) {
         if (document->image()) {
             images << document->image();
         }
     }
 
     d->idleWatcher.setTrackedImages(images);
 }
 
 void KisPart::addDocument(KisDocument *document)
 {
     //dbgUI << "Adding document to part list" << document;
     Q_ASSERT(document);
     if (!d->documents.contains(document)) {
         d->documents.append(document);
         emit documentOpened('/'+objectName());
         emit sigDocumentAdded(document);
         connect(document, SIGNAL(sigSavingFinished()), SLOT(slotDocumentSaved()));
     }
 }
 
 QList<QPointer<KisDocument> > KisPart::documents() const
 {
     return d->documents;
 }
 
 KisDocument *KisPart::createDocument() const
 {
     KisDocument *doc = new KisDocument();
     return doc;
 }
 
 
 int KisPart::documentCount() const
 {
     return d->documents.size();
 }
 
 void KisPart::removeDocument(KisDocument *document)
 {
     d->documents.removeAll(document);
     emit documentClosed('/'+objectName());
     emit sigDocumentRemoved(document->url().toLocalFile());
     document->deleteLater();
 }
 
 KisMainWindow *KisPart::createMainWindow(QUuid id)
 {
     KisMainWindow *mw = new KisMainWindow(id);
     dbgUI <<"mainWindow" << (void*)mw << "added to view" << this;
     d->mainWindows.append(mw);
     emit sigWindowAdded(mw);
     return mw;
 }
 
 KisView *KisPart::createView(KisDocument *document,
                              KisViewManager *viewManager,
                              QWidget *parent)
 {
     // If creating the canvas fails, record this and disable OpenGL next time
     KisConfig cfg(false);
     KConfigGroup grp( KSharedConfig::openConfig(), "crashprevention");
     if (grp.readEntry("CreatingCanvas", false)) {
         cfg.disableOpenGL();
     }
     if (cfg.canvasState() == "OPENGL_FAILED") {
         cfg.disableOpenGL();
     }
     grp.writeEntry("CreatingCanvas", true);
     grp.sync();
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
     KisView *view = new KisView(document,  viewManager, parent);
     QApplication::restoreOverrideCursor();
 
     // Record successful canvas creation
     grp.writeEntry("CreatingCanvas", false);
     grp.sync();
 
     addView(view);
 
     return view;
 }
 
 void KisPart::addView(KisView *view)
 {
     if (!view)
         return;
 
     if (!d->views.contains(view)) {
         d->views.append(view);
     }
 
     emit sigViewAdded(view);
 }
 
 void KisPart::removeView(KisView *view)
 {
     if (!view) return;
 
     /**
      * HACK ALERT: we check here explicitly if the document (or main
      *             window), is saving the stuff. If we close the
      *             document *before* the saving is completed, a crash
      *             will happen.
      */
     KIS_ASSERT_RECOVER_RETURN(!view->mainWindow()->hackIsSaving());
 
     emit sigViewRemoved(view);
 
     QPointer<KisDocument> doc = view->document();
     d->views.removeAll(view);
 
     if (doc) {
         bool found = false;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->document() == doc) {
                 found = true;
                 break;
             }
         }
         if (!found) {
             removeDocument(doc);
         }
     }
 }
 
 QList<QPointer<KisView> > KisPart::views() const
 {
     return d->views;
 }
 
 int KisPart::viewCount(KisDocument *doc) const
 {
     if (!doc) {
         return d->views.count();
     }
     else {
         int count = 0;
         Q_FOREACH (QPointer<KisView> view, d->views) {
             if (view && view->isVisible() && view->document() == doc) {
                 count++;
             }
         }
         return count;
     }
 }
 
 bool KisPart::closingSession() const
 {
     return d->closingSession;
 }
 
 bool KisPart::exists()
 {
     return s_instance.exists();
 }
 
 bool KisPart::closeSession(bool keepWindows)
 {
     d->closingSession = true;
 
     Q_FOREACH(auto document, d->documents) {
         if (!d->queryCloseDocument(document.data())) {
             d->closingSession = false;
             return false;
         }
     }
 
     if (d->currentSession) {
         KisConfig kisCfg(false);
         if (kisCfg.saveSessionOnQuit(false)) {
 
             d->currentSession->storeCurrentWindows();
             d->currentSession->save();
 
             KConfigGroup cfg = KSharedConfig::openConfig()->group("session");
             cfg.writeEntry("previousSession", d->currentSession->name());
         }
 
         d->currentSession = nullptr;
     }
 
     if (!keepWindows) {
         Q_FOREACH (auto window, d->mainWindows) {
             window->close();
         }
 
         if (d->sessionManager) {
             d->sessionManager->close();
         }
     }
 
     d->closingSession = false;
     return true;
 }
 
 void KisPart::slotDocumentSaved()
 {
     KisDocument *doc = qobject_cast<KisDocument*>(sender());
     emit sigDocumentSaved(doc->url().toLocalFile());
 }
 
 void KisPart::removeMainWindow(KisMainWindow *mainWindow)
 {
     dbgUI <<"mainWindow" << (void*)mainWindow <<"removed from doc" << this;
     if (mainWindow) {
         d->mainWindows.removeAll(mainWindow);
     }
 }
 
 const QList<QPointer<KisMainWindow> > &KisPart::mainWindows() const
 {
     return d->mainWindows;
 }
 
 int KisPart::mainwindowCount() const
 {
     return d->mainWindows.count();
 }
 
 
 KisMainWindow *KisPart::currentMainwindow() const
 {
     QWidget *widget = qApp->activeWindow();
     KisMainWindow *mainWindow = qobject_cast<KisMainWindow*>(widget);
     while (!mainWindow && widget) {
         widget = widget->parentWidget();
         mainWindow = qobject_cast<KisMainWindow*>(widget);
     }
 
     if (!mainWindow && mainWindows().size() > 0) {
         mainWindow = mainWindows().first();
     }
     return mainWindow;
 
 }
 
 KisMainWindow * KisPart::windowById(QUuid id) const
 {
     Q_FOREACH(QPointer<KisMainWindow> mainWindow, d->mainWindows) {
         if (mainWindow->id() == id) {
             return mainWindow;
         }
     }
 
     return nullptr;
 }
 
 KisIdleWatcher* KisPart::idleWatcher() const
 {
     return &d->idleWatcher;
 }
 
 KisAnimationCachePopulator* KisPart::cachePopulator() const
 {
     return &d->animationCachePopulator;
 }
 
+void KisPart::prioritizeFrameForCache(KisImageSP image, int frame) {
+    KisImageAnimationInterface* animInterface = image->animationInterface();
+    KIS_SAFE_ASSERT_RECOVER_RETURN(animInterface->fullClipRange().contains(frame));
+
+    d->animationCachePopulator.appendPriorityFrame(frame);
+
+}
+
 void KisPart::openExistingFile(const QUrl &url)
 {
     // TODO: refactor out this method!
 
     KisMainWindow *mw = currentMainwindow();
     KIS_SAFE_ASSERT_RECOVER_RETURN(mw);
 
     mw->openDocument(url, KisMainWindow::None);
 }
 
 void KisPart::updateShortcuts()
 {
     // Update any non-UI actionCollections.  That includes:
     // Now update the UI actions.
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         KActionCollection *ac = mainWindow->actionCollection();
 
         ac->updateShortcuts();
 
         // Loop through mainWindow->actionCollections() to modify tooltips
         // so that they list shortcuts at the end in parentheses
         Q_FOREACH ( QAction* action, ac->actions())
         {
             // Remove any existing suffixes from the tooltips.
             // Note this regexp starts with a space, e.g. " (Ctrl-a)"
             QString strippedTooltip = action->toolTip().remove(QRegExp("\\s\\(.*\\)"));
 
             // Now update the tooltips with the new shortcut info.
             if (action->shortcut() == QKeySequence(0))
                 action->setToolTip(strippedTooltip);
             else
                 action->setToolTip( strippedTooltip + " (" + action->shortcut().toString() + ")");
         }
     }
 }
 
 void KisPart::openTemplate(const QUrl &url)
 {
     qApp->setOverrideCursor(Qt::BusyCursor);
     KisDocument *document = createDocument();
 
     bool ok = document->loadNativeFormat(url.toLocalFile());
     document->setModified(false);
     document->undoStack()->clear();
 
     if (ok) {
         QString mimeType = KisMimeDatabase::mimeTypeForFile(url.toLocalFile());
         // in case this is a open document template remove the -template from the end
         mimeType.remove( QRegExp( "-template$" ) );
         document->setMimeTypeAfterLoading(mimeType);
         document->resetURL();
         document->setReadWrite(true);
     }
     else {
         if (document->errorMessage().isEmpty()) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1", document->localFilePath()));
         }
         else {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not create document from template\n%1\nReason: %2", document->localFilePath(), document->errorMessage()));
         }
         delete document;
         return;
     }
     addDocument(document);
 
     KisMainWindow *mw = currentMainwindow();
     mw->addViewAndNotifyLoadingCompleted(document);
 
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
 
     }
 
     qApp->restoreOverrideCursor();
 }
 
 void KisPart::addRecentURLToAllMainWindows(QUrl url, QUrl oldUrl)
 {
     // Add to recent actions list in our mainWindows
     Q_FOREACH (KisMainWindow *mainWindow, d->mainWindows) {
         mainWindow->addRecentURL(url, oldUrl);
     }
 }
 
 
 void KisPart::startCustomDocument(KisDocument* doc)
 {
     addDocument(doc);
     KisMainWindow *mw = currentMainwindow();
     KisOpenPane *pane = qobject_cast<KisOpenPane*>(sender());
     if (pane) {
         pane->hide();
         pane->deleteLater();
     }
     mw->addViewAndNotifyLoadingCompleted(doc);
 
 }
 
 KisInputManager* KisPart::currentInputManager()
 {
     KisMainWindow *mw = currentMainwindow();
     KisViewManager *manager = mw ? mw->viewManager() : 0;
     return manager ? manager->inputManager() : 0;
 }
 
 void KisPart::showSessionManager()
 {
     if (d->sessionManager.isNull()) {
         d->sessionManager.reset(new KisSessionManagerDialog());
     }
 
     d->sessionManager->show();
     d->sessionManager->activateWindow();
 }
 
 void KisPart::startBlankSession()
 {
     KisMainWindow *window = createMainWindow();
     window->initializeGeometry();
     window->show();
 
 }
 
 bool KisPart::restoreSession(const QString &sessionName)
 {
     if (sessionName.isNull()) return false;
 
     KoResourceServer<KisSessionResource> * rserver = KisResourceServerProvider::instance()->sessionServer();
     auto *session = rserver->resourceByName(sessionName);
     if (!session || !session->valid()) return false;
 
     session->restore();
 
     return true;
 }
 
 void KisPart::setCurrentSession(KisSessionResource *session)
 {
     d->currentSession = session;
 }
diff --git a/libs/ui/KisPart.h b/libs/ui/KisPart.h
index 333a1f169d..845df6fa8b 100644
--- a/libs/ui/KisPart.h
+++ b/libs/ui/KisPart.h
@@ -1,281 +1,289 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2005 David Faure  <faure@kde.org>
    Copyright (C) 2007 Thorsten Zachmann <zachmann@kde.org>
    Copyright (C) 2010 Boudewijn Rempt   <boud@valdyas.org>
    Copyright (C) 2015 Michael Abrahams  <miabraha@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #ifndef KIS_PART_H
 #define KIS_PART_H
 
 #include <QList>
 #include <QPointer>
 #include <QUrl>
 #include <QUuid>
 
 #include "kritaui_export.h"
 #include <KConfigCore/kconfiggroup.h>
 #include <KoConfig.h>
 #include <KisMainWindow.h>
 
 namespace KIO {
 }
 
 class KisAction;
 class KisDocument;
 class KisView;
 class KisDocument;
 class KisIdleWatcher;
 class KisAnimationCachePopulator;
 class KisSessionResource;
 
 /**
  * KisPart a singleton class which provides the main entry point to the application.
  * Krita supports multiple documents, multiple main windows, and multiple
  * components.  KisPart manages these resources and provides them to the rest of
  * Krita.  It manages lists of Actions and shortcuts as well.
  *
  * The terminology comes from KParts, which is a system allowing one KDE app
  * to be run from inside another, like pressing F4 inside dophin to run konsole.
  *
  * Needless to say, KisPart hasn't got much to do with KParts anymore.
  */
 class KRITAUI_EXPORT KisPart : public QObject
 {
     Q_OBJECT
 
 public:
 
     static KisPart *instance();
 
     /**
      * Constructor.
      *
      * @param parent may be another KisDocument, or anything else.
      *        Usually passed by KPluginFactory::create.
      */
     explicit KisPart();
 
     /**
      *  Destructor.
      *
      * The destructor does not delete any attached KisView objects and it does not
      * delete the attached widget as returned by widget().
      */
     ~KisPart() override;
 
     // ----------------- Document management -----------------
 
     /**
      * create an empty document. The document is not automatically registered with the part.
      */
     KisDocument *createDocument() const;
 
     /**
      * Add the specified document to the list of documents this KisPart manages.
      */
     void addDocument(KisDocument *document);
 
     /**
      * @return a list of all documents this part manages
      */
     QList<QPointer<KisDocument> > documents() const;
 
     /**
      * @return number of documents this part manages.
      */
     int documentCount() const;
 
     void removeDocument(KisDocument *document);
 
     // ----------------- MainWindow management -----------------
 
 
     /**
      * Create a new main window.
      */
     KisMainWindow *createMainWindow(QUuid id = QUuid());
 
     /**
      * Removes a main window from the list of managed windows.
      *
      * This is called by the MainWindow after it finishes its shutdown routine.
      */
     void removeMainWindow(KisMainWindow *mainWindow);
 
     /**
      * @return the list of main windows.
      */
     const QList<QPointer<KisMainWindow> >& mainWindows() const;
 
     /**
      * @return the number of shells for the main window
      */
     int mainwindowCount() const;
 
     void addRecentURLToAllMainWindows(QUrl url, QUrl oldUrl = QUrl());
 
     /**
      * @return the currently active main window.
      */
     KisMainWindow *currentMainwindow() const;
 
     KisMainWindow *windowById(QUuid id) const;
 
     /**
      * @return the application-wide KisIdleWatcher.
      */
     KisIdleWatcher *idleWatcher() const;
 
+    // ----------------- Cache Populator Management -----------------
     /**
      * @return the application-wide AnimationCachePopulator.
      */
     KisAnimationCachePopulator *cachePopulator() const;
 
+    /**
+     * Adds a frame time index to a priority stack, which should be
+     * cached immediately and irregardless of whether it is the
+     * the currently occupied frame.
+     */
+    void prioritizeFrameForCache(KisImageSP image, int frame);
+
 public Q_SLOTS:
 
     /**
      * This slot loads an existing file.
      * @param url the file to load
      */
     void openExistingFile(const QUrl &url);
 
     /**
      * This slot loads a template and deletes the sender.
      * @param url the template to load
      */
     void openTemplate(const QUrl &url);
 
 
     /**
      * @brief startCustomDocument adds the given document to the document list and deletes the sender()
      * @param doc
      */
     void startCustomDocument(KisDocument *doc);
 
 private Q_SLOTS:
 
     void updateIdleWatcherConnections();
 
     void updateShortcuts();
 
 Q_SIGNALS:
     /**
      * emitted when a new document is opened. (for the idle watcher)
      */
     void documentOpened(const QString &ref);
 
     /**
      * emitted when an old document is closed. (for the idle watcher)
      */
     void documentClosed(const QString &ref);
 
     // These signals are for libkis or sketch
     void sigViewAdded(KisView *view);
     void sigViewRemoved(KisView *view);
     void sigDocumentAdded(KisDocument *document);
     void sigDocumentSaved(const QString &url);
     void sigDocumentRemoved(const QString &filename);
     void sigWindowAdded(KisMainWindow *window);
 
 public:
 
     KisInputManager *currentInputManager();
 
     //------------------ View management ------------------
 
     /**
      * Create a new view for the document. The view is added to the list of
      * views, and if the document wasn't known yet, it's registered as well.
      */
     KisView *createView(KisDocument *document,
                         KisViewManager *viewManager,
                         QWidget *parent);
 
     /**
      * Adds a view to the document. If the part doesn't know yet about
      * the document, it is registered.
      *
      * This calls KisView::updateReadWrite to tell the new view
      * whether the document is readonly or not.
      */
     void addView(KisView *view);
 
     /**
      * Removes a view of the document.
      */
     void removeView(KisView *view);
 
     /**
      * @return a list of views this document is displayed in
      */
     QList<QPointer<KisView> > views() const;
 
     /**
      * @return number of views this document is displayed in
      */
     int viewCount(KisDocument *doc) const;
 
     //------------------ Session management ------------------
 
     void showSessionManager();
 
     void startBlankSession();
 
     /**
      * Restores a saved session by name
      */
     bool restoreSession(const QString &sessionName);
 
     void setCurrentSession(KisSessionResource *session);
 
     /**
      * Attempts to save the session and close all windows.
      * This may involve asking the user to save open files.
      * @return false, if closing was cancelled by the user
      */
     bool closeSession(bool keepWindows = false);
 
     /**
      * Are we in the process of closing the application through closeSession().
      */
     bool closingSession() const;
 
     /**
      * This function returns true if the instance has already been initialized,
      * false otherwise. This to prevent premature initialization that causes crash
      * on android see `1fbb25506a`
      * @see QGlobalStatic::exists()
      */
     static bool exists();
 
 private Q_SLOTS:
 
     void slotDocumentSaved();
 
 private:
 
     Q_DISABLE_COPY(KisPart)
 
     class Private;
     Private *const d;
 
 };
 
 #endif
diff --git a/libs/ui/kis_animation_cache_populator.cpp b/libs/ui/kis_animation_cache_populator.cpp
index c730a52d09..50f8bd75b8 100644
--- a/libs/ui/kis_animation_cache_populator.cpp
+++ b/libs/ui/kis_animation_cache_populator.cpp
@@ -1,317 +1,332 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_animation_cache_populator.h"
 
 #include <functional>
 
 #include <QTimer>
 #include <QMutex>
 #include <QtConcurrent>
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "KisPart.h"
 #include "KisDocument.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_canvas2.h"
 #include "kis_time_range.h"
 #include "kis_animation_frame_cache.h"
 #include "kis_update_info.h"
 #include "kis_signal_auto_connection.h"
 #include "kis_idle_watcher.h"
 #include "KisViewManager.h"
 #include "kis_node_manager.h"
 #include "kis_keyframe_channel.h"
 
 #include "KisAsyncAnimationCacheRenderer.h"
 #include "dialogs/KisAsyncAnimationCacheRenderDialog.h"
 
 
 struct KisAnimationCachePopulator::Private
 {
     KisAnimationCachePopulator *q;
     KisPart *part;
 
     QTimer timer;
 
     /**
      * Counts up the number of subsequent times Krita has been detected idle.
      */
     int idleCounter;
+    QStack<int> priorityFrames;
     static const int IDLE_COUNT_THRESHOLD = 4;
     static const int IDLE_CHECK_INTERVAL = 500;
     static const int BETWEEN_FRAMES_INTERVAL = 10;
 
     int requestedFrame;
     KisAnimationFrameCacheSP requestCache;
     KisOpenGLUpdateInfoSP requestInfo;
     KisSignalAutoConnectionsStore imageRequestConnections;
 
     QFutureWatcher<void> infoConversionWatcher;
 
     KisAsyncAnimationCacheRenderer regenerator;
     bool calculateAnimationCacheInBackground = true;
 
 
 
     enum State {
         NotWaitingForAnything,
         WaitingForIdle,
         WaitingForFrame,
         BetweenFrames
     };
     State state;
 
     Private(KisAnimationCachePopulator *_q, KisPart *_part)
         : q(_q),
           part(_part),
           idleCounter(0),
+          priorityFrames(),
           requestedFrame(-1),
           state(WaitingForIdle)
     {
         timer.setSingleShot(true);
     }
 
     void timerTimeout() {
         switch (state) {
         case WaitingForIdle:
         case BetweenFrames:
             generateIfIdle();
             break;
         case WaitingForFrame:
             KIS_ASSERT_RECOVER_NOOP(0 && "WaitingForFrame cannot have a timeout. Just skip this message and report a bug");
             break;
         case NotWaitingForAnything:
             KIS_ASSERT_RECOVER_NOOP(0 && "NotWaitingForAnything cannot have a timeout. Just skip this message and report a bug");
             break;
         }
     }
 
     void generateIfIdle()
     {
         if (part->idleWatcher()->isIdle()) {
             idleCounter++;
 
             if (idleCounter >= IDLE_COUNT_THRESHOLD) {
                 if (!tryRequestGeneration()) {
                     enterState(NotWaitingForAnything);
                 }
                 return;
             }
         } else {
             idleCounter = 0;
         }
 
         enterState(WaitingForIdle);
     }
 
 
     bool tryRequestGeneration()
     {
         // Prioritize the active document
         KisAnimationFrameCacheSP activeDocumentCache = KisAnimationFrameCacheSP(0);
 
         KisMainWindow *activeWindow = part->currentMainwindow();
         if (activeWindow && activeWindow->activeView()) {
             KisCanvas2 *activeCanvas = activeWindow->activeView()->canvasBase();
 
             if (activeCanvas && activeCanvas->frameCache()) {
                 activeDocumentCache = activeCanvas->frameCache();
 
                 // Let's skip frames affected by changes to the active node (on the active document)
                 // This avoids constant invalidation and regeneration while drawing
                 KisNodeSP activeNode = activeCanvas->viewManager()->nodeManager()->activeNode();
                 KisTimeRange skipRange;
                 if (activeNode) {
-                    int currentTime = activeCanvas->currentImage()->animationInterface()->currentUITime();
+                    const int currentTime = activeCanvas->currentImage()->animationInterface()->currentUITime();
 
                     if (!activeNode->keyframeChannels().isEmpty()) {
-                        Q_FOREACH (const KisKeyframeChannel *channel, activeNode->keyframeChannels()) {
-                            skipRange |= channel->affectedFrames(currentTime);
+                        if (priorityFrames.count() == 0 || currentTime != priorityFrames.top()) {
+                            Q_FOREACH (const KisKeyframeChannel *channel, activeNode->keyframeChannels()) {
+                                skipRange |= channel->affectedFrames(currentTime);
+                            }
                         }
                     } else {
                         skipRange = KisTimeRange::infinite(0);
                     }
                 }
 
                 bool requested = tryRequestGeneration(activeDocumentCache, skipRange);
                 if (requested) return true;
             }
         }
 
         QList<KisAnimationFrameCache*> caches = KisAnimationFrameCache::caches();
         KisAnimationFrameCache *cache;
         Q_FOREACH (cache, caches) {
             if (cache == activeDocumentCache.data()) {
                 // We already handled this one...
                 continue;
             }
 
             bool requested = tryRequestGeneration(cache, KisTimeRange());
             if (requested) return true;
         }
 
         return false;
     }
 
     bool tryRequestGeneration(KisAnimationFrameCacheSP cache, KisTimeRange skipRange)
     {
         KisImageSP image = cache->image();
         if (!image) return false;
 
         KisImageAnimationInterface *animation = image->animationInterface();
         KisTimeRange currentRange = animation->fullClipRange();
 
-        const int frame = KisAsyncAnimationCacheRenderDialog::calcFirstDirtyFrame(cache, currentRange, skipRange);
+        const bool hasPriorityFrame = priorityFrames.count() > 0;
+        const int frame = hasPriorityFrame ? priorityFrames.top() : KisAsyncAnimationCacheRenderDialog::calcFirstDirtyFrame(cache, currentRange, skipRange);
 
         if (frame >= 0) {
-            return regenerate(cache, frame);
+            bool waiting = !regenerate(cache, frame);
+            if (hasPriorityFrame && !waiting) {
+                priorityFrames.pop();
+            }
+            return waiting;
         }
 
         return false;
     }
 
     bool regenerate(KisAnimationFrameCacheSP cache, int frame)
     {
         if (state == WaitingForFrame) {
             // Already busy, deny request
             return false;
         }
 
         /**
          * We should enter the state before the frame is
          * requested. Otherwise the signal may come earlier than we
          * enter it.
          */
         enterState(WaitingForFrame);
 
         regenerator.setFrameCache(cache);
 
         // if we ever decide to add ROI to background cache
         // regeneration, it should be added here :)
         regenerator.startFrameRegeneration(cache->image(), frame);
 
         return true;
     }
 
     QString debugStateToString(State newState) {
         QString str = "<unknown>";
 
         switch (newState) {
         case WaitingForIdle:
             str = "WaitingForIdle";
             break;
         case WaitingForFrame:
             str = "WaitingForFrame";
             break;
         case NotWaitingForAnything:
             str = "NotWaitingForAnything";
             break;
         case BetweenFrames:
             str = "BetweenFrames";
             break;
         }
 
         return str;
     }
 
     void enterState(State newState)
     {
         //ENTER_FUNCTION() << debugStateToString(state) << "->" << debugStateToString(newState);
 
         state = newState;
         int timerTimeout = -1;
 
         switch (state) {
         case WaitingForIdle:
             timerTimeout = IDLE_CHECK_INTERVAL;
             break;
         case WaitingForFrame:
             // the timeout is handled by the regenerator now
             timerTimeout = -1;
             break;
         case NotWaitingForAnything:
             // frame conversion cannot be cancelled,
             // so there is no timeout
             timerTimeout = -1;
             break;
         case BetweenFrames:
             timerTimeout = BETWEEN_FRAMES_INTERVAL;
             break;
         }
 
         if (timerTimeout >= 0) {
             timer.start(timerTimeout);
         } else {
             timer.stop();
         }
     }
 };
 
 KisAnimationCachePopulator::KisAnimationCachePopulator(KisPart *part)
     : m_d(new Private(this, part))
 {
     connect(&m_d->timer, SIGNAL(timeout()), this, SLOT(slotTimer()));
 
     connect(&m_d->regenerator, SIGNAL(sigFrameCancelled(int)), SLOT(slotRegeneratorFrameCancelled()));
     connect(&m_d->regenerator, SIGNAL(sigFrameCompleted(int)), SLOT(slotRegeneratorFrameReady()));
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     slotConfigChanged();
 }
 
 KisAnimationCachePopulator::~KisAnimationCachePopulator()
 {}
 
 bool KisAnimationCachePopulator::regenerate(KisAnimationFrameCacheSP cache, int frame)
 {
     return m_d->regenerate(cache, frame);
 }
 
+void KisAnimationCachePopulator::appendPriorityFrame(int frameIndex)
+{
+    m_d->priorityFrames.append(frameIndex);
+    m_d->enterState(Private::WaitingForIdle);
+}
+
 void KisAnimationCachePopulator::slotTimer()
 {
     m_d->timerTimeout();
 }
 
 void KisAnimationCachePopulator::slotRequestRegeneration()
 {
     // skip if the user forbade background regeneration
     if (!m_d->calculateAnimationCacheInBackground) return;
 
     m_d->enterState(Private::WaitingForIdle);
 }
 
 void KisAnimationCachePopulator::slotRegeneratorFrameCancelled()
 {
     KIS_ASSERT_RECOVER_RETURN(m_d->state == Private::WaitingForFrame);
     m_d->enterState(Private::NotWaitingForAnything);
 }
 
 void KisAnimationCachePopulator::slotRegeneratorFrameReady()
 {
     m_d->enterState(Private::BetweenFrames);
 }
 
 void KisAnimationCachePopulator::slotConfigChanged()
 {
     KisConfig cfg(true);
     m_d->calculateAnimationCacheInBackground = cfg.calculateAnimationCacheInBackground();
     QTimer::singleShot(1000, this, SLOT(slotRequestRegeneration()));
 }
diff --git a/libs/ui/kis_animation_cache_populator.h b/libs/ui/kis_animation_cache_populator.h
index 4900d36d3c..fa4cc89ab0 100644
--- a/libs/ui/kis_animation_cache_populator.h
+++ b/libs/ui/kis_animation_cache_populator.h
@@ -1,58 +1,59 @@
 /*
  *  Copyright (c) 2015 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_ANIMATION_CACHE_POPULATOR_H
 #define KIS_ANIMATION_CACHE_POPULATOR_H
 
 #include <QObject>
 #include "kis_types.h"
 
 class KisPart;
 
 class KisAnimationCachePopulator : public QObject
 {
     Q_OBJECT
 
 public:
     KisAnimationCachePopulator(KisPart *part);
     ~KisAnimationCachePopulator() override;
 
     /**
      * Request generation of given frame. The request will
      * be ignored if the populator is already requesting a frame.
      * @return true if generation requested, false if busy
      */
     bool regenerate(KisAnimationFrameCacheSP cache, int frame);
+    void appendPriorityFrame(int frameIndex);
 
 public Q_SLOTS:
     void slotRequestRegeneration();
 
 private Q_SLOTS:
     void slotTimer();
 
     void slotRegeneratorFrameCancelled();
     void slotRegeneratorFrameReady();
 
     void slotConfigChanged();
 
 private:
     struct Private;
     QScopedPointer<Private> m_d;
 };
 
 #endif
diff --git a/plugins/dockers/animation/kis_time_based_item_model.cpp b/plugins/dockers/animation/kis_time_based_item_model.cpp
index 38f429ecf3..7fe0fa950a 100644
--- a/plugins/dockers/animation/kis_time_based_item_model.cpp
+++ b/plugins/dockers/animation/kis_time_based_item_model.cpp
@@ -1,516 +1,524 @@
 /*
  *  Copyright (c) 2016 Jouni Pentikäinen <joupent@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_time_based_item_model.h"
 
 #include <QPointer>
 #include <kis_config.h>
 
 #include "kis_animation_frame_cache.h"
 #include "kis_animation_player.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_time_range.h"
 #include "kis_animation_utils.h"
 #include "kis_keyframe_channel.h"
 #include "kis_processing_applicator.h"
 #include "KisImageBarrierLockerWithFeedback.h"
 #include "commands_new/kis_switch_current_time_command.h"
 #include "kis_command_utils.h"
+#include "KisPart.h"
+#include "kis_animation_cache_populator.h"
 
 struct KisTimeBasedItemModel::Private
 {
     Private()
         : animationPlayer(0)
         , numFramesOverride(0)
         , activeFrameIndex(0)
         , scrubInProgress(false)
         , scrubStartFrame(-1)
     {}
 
     KisImageWSP image;
     KisAnimationFrameCacheWSP framesCache;
     QPointer<KisAnimationPlayer> animationPlayer;
 
     QVector<bool> cachedFrames;
 
     int numFramesOverride;
     int activeFrameIndex;
 
     bool scrubInProgress;
     int scrubStartFrame;
 
     QScopedPointer<KisSignalCompressorWithParam<int> > scrubbingCompressor;
 
     int baseNumFrames() const {
 
         auto imageSP = image.toStrongRef();
         if (!imageSP) return 0;
 
         KisImageAnimationInterface *i = imageSP->animationInterface();
         if (!i) return 1;
 
         return i->totalLength();
     }
 
     int effectiveNumFrames() const {
         if (image.isNull()) return 0;
 
         return qMax(baseNumFrames(), numFramesOverride);
     }
 
     int framesPerSecond() {
         return image->animationInterface()->framerate();
     }
 };
 
 KisTimeBasedItemModel::KisTimeBasedItemModel(QObject *parent)
     : QAbstractTableModel(parent)
     , m_d(new Private())
 {
     KisConfig cfg(true);
 
     using namespace std::placeholders;
     std::function<void (int)> callback(
         std::bind(&KisTimeBasedItemModel::slotInternalScrubPreviewRequested, this, _1));
 
     m_d->scrubbingCompressor.reset(
         new KisSignalCompressorWithParam<int>(cfg.scrubbingUpdatesDelay(), callback, KisSignalCompressor::FIRST_ACTIVE));
 }
 
 KisTimeBasedItemModel::~KisTimeBasedItemModel()
 {}
 
 void KisTimeBasedItemModel::setImage(KisImageWSP image)
 {
     KisImageWSP oldImage = m_d->image;
 
     m_d->image = image;
 
     if (image) {
         KisImageAnimationInterface *ai = image->animationInterface();
 
         slotCurrentTimeChanged(ai->currentUITime());
 
         connect(ai, SIGNAL(sigFramerateChanged()), SLOT(slotFramerateChanged()));
         connect(ai, SIGNAL(sigUiTimeChanged(int)), SLOT(slotCurrentTimeChanged(int)));
     }
 
     if (image != oldImage) {
         beginResetModel();
         endResetModel();
     }
 }
 
 void KisTimeBasedItemModel::setFrameCache(KisAnimationFrameCacheSP cache)
 {
     if (KisAnimationFrameCacheSP(m_d->framesCache) == cache) return;
 
     if (m_d->framesCache) {
         m_d->framesCache->disconnect(this);
     }
 
     m_d->framesCache = cache;
 
     if (m_d->framesCache) {
         connect(m_d->framesCache, SIGNAL(changed()), SLOT(slotCacheChanged()));
     }
 }
 
 void KisTimeBasedItemModel::setAnimationPlayer(KisAnimationPlayer *player)
 {
     if (m_d->animationPlayer == player) return;
 
     if (m_d->animationPlayer) {
         m_d->animationPlayer->disconnect(this);
     }
 
     m_d->animationPlayer = player;
 
     if (m_d->animationPlayer) {
         connect(m_d->animationPlayer, SIGNAL(sigPlaybackStopped()), SLOT(slotPlaybackStopped()));
         connect(m_d->animationPlayer, SIGNAL(sigFrameChanged()), SLOT(slotPlaybackFrameChanged()));
     }
 }
 
 void KisTimeBasedItemModel::setLastVisibleFrame(int time)
 {
     const int growThreshold = m_d->effectiveNumFrames() - 3;
     const int growValue = time + 8;
 
     const int shrinkThreshold = m_d->effectiveNumFrames() - 12;
     const int shrinkValue = qMax(m_d->baseNumFrames(), qMin(growValue, shrinkThreshold));
     const bool canShrink = m_d->effectiveNumFrames() > m_d->baseNumFrames();
 
     if (time >= growThreshold) {
         beginInsertColumns(QModelIndex(), m_d->effectiveNumFrames(), growValue - 1);
         m_d->numFramesOverride = growValue;
         endInsertColumns();
     } else if (time < shrinkThreshold && canShrink) {
         beginRemoveColumns(QModelIndex(), shrinkValue, m_d->effectiveNumFrames() - 1);
         m_d->numFramesOverride = shrinkValue;
         endRemoveColumns();
     }
 }
 
 int KisTimeBasedItemModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return m_d->effectiveNumFrames();
 }
 
 QVariant KisTimeBasedItemModel::data(const QModelIndex &index, int role) const
 {
     switch (role) {
     case ActiveFrameRole: {
         return index.column() == m_d->activeFrameIndex;
     }
     }
 
     return QVariant();
 }
 
 bool KisTimeBasedItemModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid()) return false;
 
     switch (role) {
     case ActiveFrameRole: {
         setHeaderData(index.column(), Qt::Horizontal, value, role);
         break;
     }
     }
 
     return false;
 }
 
 QVariant KisTimeBasedItemModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal) {
         switch (role) {
         case ActiveFrameRole:
             return section == m_d->activeFrameIndex;
         case FrameCachedRole:
             return m_d->cachedFrames.size() > section ? m_d->cachedFrames[section] : false;
         case FramesPerSecondRole:
             return m_d->framesPerSecond();
         }
     }
 
     return QVariant();
 }
 
 bool KisTimeBasedItemModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
 {
     if (orientation == Qt::Horizontal) {
         switch (role) {
         case ActiveFrameRole:
             if (value.toBool() &&
                 section != m_d->activeFrameIndex) {
 
                 int prevFrame = m_d->activeFrameIndex;
                 m_d->activeFrameIndex = section;
 
                 scrubTo(m_d->activeFrameIndex, m_d->scrubInProgress);
 
                 /**
                  * Optimization Hack Alert:
                  *
                  * ideally, we should emit all four signals, but... The
                  * point is this code is used in a tight loop during
                  * playback, so it should run as fast as possible. To tell
                  * the story short, commenting out these three lines makes
                  * playback run 15% faster ;)
                  */
 
                 if (m_d->scrubInProgress) {
                     //emit dataChanged(this->index(0, prevFrame), this->index(rowCount() - 1, prevFrame));
                     emit dataChanged(this->index(0, m_d->activeFrameIndex), this->index(rowCount() - 1, m_d->activeFrameIndex));
                     //emit headerDataChanged (Qt::Horizontal, prevFrame, prevFrame);
                     //emit headerDataChanged (Qt::Horizontal, m_d->activeFrameIndex, m_d->activeFrameIndex);
                 } else {
                     emit dataChanged(this->index(0, prevFrame), this->index(rowCount() - 1, prevFrame));
                     emit dataChanged(this->index(0, m_d->activeFrameIndex), this->index(rowCount() - 1, m_d->activeFrameIndex));
                     emit headerDataChanged (Qt::Horizontal, prevFrame, prevFrame);
                     emit headerDataChanged (Qt::Horizontal, m_d->activeFrameIndex, m_d->activeFrameIndex);
                 }
             }
         }
     }
 
     return false;
 }
 
 bool KisTimeBasedItemModel::removeFrames(const QModelIndexList &indexes)
 {
     KisAnimationUtils::FrameItemList frameItems;
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             int time = index.column();
             Q_FOREACH(KisKeyframeChannel *channel, channelsAt(index)) {
                 if (channel->keyframeAt(time)) {
                     frameItems << KisAnimationUtils::FrameItem(channel->node(), channel->id(), index.column());
                 }
             }
         }
     }
 
     if (frameItems.isEmpty()) return false;
 
     KisAnimationUtils::removeKeyframes(m_d->image, frameItems);
 
     return true;
 }
 
 KUndo2Command* KisTimeBasedItemModel::createOffsetFramesCommand(QModelIndexList srcIndexes,
                                                                 const QPoint &offset,
                                                                 bool copyFrames,
                                                                 bool moveEmptyFrames,
                                                                 KUndo2Command *parentCommand)
 {
     if (srcIndexes.isEmpty()) return 0;
     if (offset.isNull()) return 0;
 
     KisAnimationUtils::sortPointsForSafeMove(&srcIndexes, offset);
 
     KisAnimationUtils::FrameItemList srcFrameItems;
     KisAnimationUtils::FrameItemList dstFrameItems;
 
     Q_FOREACH (const QModelIndex &srcIndex, srcIndexes) {
         QModelIndex dstIndex = index(
                 srcIndex.row() + offset.y(),
                 srcIndex.column() + offset.x());
 
         KisNodeSP srcNode = nodeAt(srcIndex);
         KisNodeSP dstNode = nodeAt(dstIndex);
         if (!srcNode || !dstNode) return 0;
 
         Q_FOREACH(KisKeyframeChannel *channel, channelsAt(srcIndex)) {
             if (moveEmptyFrames || channel->keyframeAt(srcIndex.column())) {
                 srcFrameItems << KisAnimationUtils::FrameItem(srcNode, channel->id(), srcIndex.column());
                 dstFrameItems << KisAnimationUtils::FrameItem(dstNode, channel->id(), dstIndex.column());
             }
         }
     }
 
     KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(srcFrameItems.size() == dstFrameItems.size(), 0);
     if (srcFrameItems.isEmpty()) return 0;
 
     return
         KisAnimationUtils::createMoveKeyframesCommand(srcFrameItems,
                                                       dstFrameItems,
                                                       copyFrames,
                                                       moveEmptyFrames,
                                                       parentCommand);
 }
 
 bool KisTimeBasedItemModel::removeFramesAndOffset(QModelIndexList indicesToRemove)
 {
     if (indicesToRemove.isEmpty()) return true;
 
     std::sort(indicesToRemove.begin(), indicesToRemove.end(),
               [] (const QModelIndex &lhs, const QModelIndex &rhs) {
                   return lhs.column() > rhs.column();
               });
 
     const int minColumn = indicesToRemove.last().column();
 
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Remove frame and shift", "Remove %1 frames and shift", indicesToRemove.size()));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         Q_FOREACH (const QModelIndex &index, indicesToRemove) {
             QModelIndexList indicesToOffset;
             for (int column = index.column() + 1; column < columnCount(); column++) {
                 indicesToOffset << this->index(index.row(), column);
             }
             createOffsetFramesCommand(indicesToOffset, QPoint(-1, 0), false, true, parentCommand);
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = minColumn;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime,
                                         parentCommand);
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand,
                                                     KisStrokeJobData::BARRIER,
                                                     KisStrokeJobData::EXCLUSIVE);
     return true;
 }
 
 bool KisTimeBasedItemModel::mirrorFrames(QModelIndexList indexes)
 {
     QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18n("Mirror Frames")));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QMap<int, QModelIndexList> rowsList;
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             rowsList[index.row()].append(index);
         }
 
 
         Q_FOREACH (int row, rowsList.keys()) {
             QModelIndexList &list = rowsList[row];
 
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!list.isEmpty(), false);
 
             std::sort(list.begin(), list.end(),
                 [] (const QModelIndex &lhs, const QModelIndex &rhs) {
                     return lhs.column() < rhs.column();
                 });
 
             auto srcIt = list.begin();
             auto dstIt = list.end();
 
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(srcIt != dstIt, false);
             --dstIt;
 
             QList<KisKeyframeChannel*> channels = channelsAt(*srcIt).values();
 
             while (srcIt < dstIt) {
                 Q_FOREACH (KisKeyframeChannel *channel, channels) {
                     channel->swapFrames(srcIt->column(), dstIt->column(), parentCommand.data());
                 }
 
                 srcIt++;
                 dstIt--;
             }
         }
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image,
                                                     new KisCommandUtils::SkipFirstRedoWrapper(parentCommand.take()),
                                                     KisStrokeJobData::BARRIER,
                                                     KisStrokeJobData::EXCLUSIVE);
     return true;
 }
 
 void KisTimeBasedItemModel::slotInternalScrubPreviewRequested(int time)
 {
     if (m_d->animationPlayer && !m_d->animationPlayer->isPlaying()) {
         m_d->animationPlayer->displayFrame(time);
     }
 }
 
 void KisTimeBasedItemModel::setScrubState(bool active)
 {
     if (!m_d->scrubInProgress && active) {
+        const int currentFrame = m_d->image->animationInterface()->currentUITime();
+        const bool hasCurrentFrameInCache = m_d->framesCache->frameStatus(currentFrame) == KisAnimationFrameCache::Cached;
+        if(!hasCurrentFrameInCache) {
+            KisPart::instance()->prioritizeFrameForCache(m_d->image, currentFrame);
+        }
+
         m_d->scrubStartFrame = m_d->activeFrameIndex;
         m_d->scrubInProgress = true;
     }
 
     if (m_d->scrubInProgress && !active) {
 
         m_d->scrubInProgress = false;
 
         if (m_d->scrubStartFrame >= 0 &&
             m_d->scrubStartFrame != m_d->activeFrameIndex) {
 
             scrubTo(m_d->activeFrameIndex, false);
         }
 
         m_d->scrubStartFrame = -1;
     }
 }
 
 void KisTimeBasedItemModel::scrubTo(int time, bool preview)
 {
     if (m_d->animationPlayer && m_d->animationPlayer->isPlaying()) return;
 
     KIS_ASSERT_RECOVER_RETURN(m_d->image);
 
     if (preview) {
         if (m_d->animationPlayer) {
             m_d->scrubbingCompressor->start(time);
         }
     } else {
         m_d->image->animationInterface()->requestTimeSwitchWithUndo(time);
     }
 }
 
 void KisTimeBasedItemModel::slotFramerateChanged()
 {
     emit headerDataChanged(Qt::Horizontal, 0, columnCount() - 1);
 }
 
 void KisTimeBasedItemModel::slotCurrentTimeChanged(int time)
 {
     if (time != m_d->activeFrameIndex) {
         setHeaderData(time, Qt::Horizontal, true, ActiveFrameRole);
     }
 }
 
 void KisTimeBasedItemModel::slotCacheChanged()
 {
     const int numFrames = columnCount();
     m_d->cachedFrames.resize(numFrames);
 
     for (int i = 0; i < numFrames; i++) {
         m_d->cachedFrames[i] =
             m_d->framesCache->frameStatus(i) == KisAnimationFrameCache::Cached;
     }
 
     emit headerDataChanged(Qt::Horizontal, 0, numFrames);
 }
 
 
 void KisTimeBasedItemModel::slotPlaybackFrameChanged()
 {
     if (!m_d->animationPlayer->isPlaying()) return;
     setData(index(0, m_d->animationPlayer->currentTime()), true, ActiveFrameRole);
 }
 
 void KisTimeBasedItemModel::slotPlaybackStopped()
 {
     setData(index(0, m_d->image->animationInterface()->currentUITime()), true, ActiveFrameRole);
 }
 
 void KisTimeBasedItemModel::setPlaybackRange(const KisTimeRange &range)
 {
     if (m_d->image.isNull()) return;
 
     KisImageAnimationInterface *i = m_d->image->animationInterface();
     i->setPlaybackRange(range);
 }
 
 bool KisTimeBasedItemModel::isPlaybackActive() const
 {
     return m_d->animationPlayer && m_d->animationPlayer->isPlaying();
 }
 
 int KisTimeBasedItemModel::currentTime() const
 {
     return m_d->image->animationInterface()->currentUITime();
 }
 
 KisImageWSP KisTimeBasedItemModel::image() const
 {
     return m_d->image;
 }