diff --git a/plugins/dockers/animation/CMakeLists.txt b/plugins/dockers/animation/CMakeLists.txt
index dac45e43ba..a0b4b4beb4 100644
--- a/plugins/dockers/animation/CMakeLists.txt
+++ b/plugins/dockers/animation/CMakeLists.txt
@@ -1,55 +1,56 @@
 if (NOT WIN32 AND NOT APPLE)
     add_subdirectory(tests)
 endif()
 
 set(KRITA_ANIMATIONDOCKER_SOURCES
     animation_dockers.cpp
     animation_docker.cpp
     timeline_docker.cpp
     onion_skins_docker.cpp
 
     timeline_layers_header.cpp
     timeline_ruler_header.cpp
 
     kis_time_based_item_model.cpp
     timeline_frames_model.cpp
     timeline_frames_view.cpp
     timeline_frames_item_delegate.cpp
 
     timeline_frames_index_converter.cpp
     timeline_node_list_keeper.cpp
 
     timeline_color_scheme.cpp
+    timeline_insert_keyframe_dialog.cpp
 
     kis_draggable_tool_button.cpp
     kis_zoom_button.cpp
     kis_animation_utils.cpp
     kis_custom_modifiers_catcher.cpp
 
     kis_equalizer_column.cpp
     kis_equalizer_slider.cpp
     kis_equalizer_button.cpp
     kis_equalizer_widget.cpp
 
     kis_animation_curve_docker.cpp
     kis_animation_curves_model.cpp
     kis_animation_curves_view.cpp
     kis_animation_curves_value_ruler.cpp
     kis_animation_curves_keyframe_delegate.cpp
     kis_animation_curve_channel_list_model.cpp
     kis_animation_curve_channel_list_delegate.cpp
 )
 
 ki18n_wrap_ui(KRITA_ANIMATIONDOCKER_SOURCES
     wdg_animation.ui
     onion_skins_docker.ui
     wdg_animation_curves.ui
 )
 
 add_library(kritaanimationdocker MODULE ${KRITA_ANIMATIONDOCKER_SOURCES})
 
 generate_export_header(kritaanimationdocker BASE_NAME kritaanimationdocker EXPORT_MACRO_NAME KRITAANIMATIONDOCKER_EXPORT)
 target_link_libraries(kritaanimationdocker kritaui kritawidgets)
 install(TARGETS kritaanimationdocker  DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
 
 
diff --git a/plugins/dockers/animation/timeline_frames_model.cpp b/plugins/dockers/animation/timeline_frames_model.cpp
index 98fb169b6a..51029baa49 100644
--- a/plugins/dockers/animation/timeline_frames_model.cpp
+++ b/plugins/dockers/animation/timeline_frames_model.cpp
@@ -1,979 +1,978 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@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 "timeline_frames_model.h"
 #include <QFont>
 #include <QSize>
 #include <QColor>
 #include <QMimeData>
 #include <QPointer>
 #include <KoResourceModel.h>
 
 #include "kis_layer.h"
 #include "kis_config.h"
 
 #include "kis_global.h"
 #include "kis_debug.h"
 #include "kis_image.h"
 #include "kis_image_animation_interface.h"
 #include "kis_undo_adapter.h"
 #include "kis_node_dummies_graph.h"
 #include "kis_dummies_facade_base.h"
 #include "kis_signal_compressor.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_keyframe_channel.h"
 #include "kundo2command.h"
 #include "kis_post_execution_undo_adapter.h"
 #include <commands/kis_node_property_list_command.h>
 #include <commands_new/kis_switch_current_time_command.h>
 
 #include "kis_animation_utils.h"
 #include "timeline_color_scheme.h"
 #include "kis_node_model.h"
 #include "kis_projection_leaf.h"
 #include "kis_time_range.h"
 
 #include "kis_node_view_color_scheme.h"
 #include "krita_utils.h"
 #include <QApplication>
 #include "kis_processing_applicator.h"
 #include <KisImageBarrierLockerWithFeedback.h>
 #include "kis_node_uuid_info.h"
 
 
 struct TimelineFramesModel::Private
 {
     Private()
         : activeLayerIndex(0),
           dummiesFacade(0),
           needFinishInsertRows(false),
           needFinishRemoveRows(false),
           updateTimer(200, KisSignalCompressor::FIRST_INACTIVE),
           parentOfRemovedNode(0)
     {}
 
     int activeLayerIndex;
 
     QPointer<KisDummiesFacadeBase> dummiesFacade;
     KisImageWSP image;
     bool needFinishInsertRows;
     bool needFinishRemoveRows;
 
     QList<KisNodeDummy*> updateQueue;
     KisSignalCompressor updateTimer;
 
     KisNodeDummy* parentOfRemovedNode;
     QScopedPointer<TimelineNodeListKeeper> converter;
 
     QScopedPointer<NodeManipulationInterface> nodeInterface;
 
     QPersistentModelIndex lastClickedIndex;
 
     QVariant layerName(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
         return dummy->node()->name();
     }
 
     bool layerEditable(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return true;
         return dummy->node()->visible() && !dummy->node()->userLocked();
     }
 
     bool frameExists(int row, int column) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         return (primaryChannel && primaryChannel->keyframeAt(column));
     }
 
     bool frameHasContent(int row, int column) {
 
         KisNodeDummy *dummy = converter->dummyFromRow(row);
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return false;
 
         // first check if we are a key frame
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return false;
 
         return frame->hasContent();
     }
 
     bool specialKeyframeExists(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
         Q_FOREACH(KisKeyframeChannel *channel, dummy->node()->keyframeChannels()) {
             if (channel->id() != KisKeyframeChannel::Content.id() && channel->keyframeAt(column)) {
                 return true;
             }
         }
         return false;
     }
 
     int frameColorLabel(int row, int column) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return -1;
 
         KisKeyframeSP frame = primaryChannel->activeKeyframeAt(column);
         if (!frame) return -1;
 
         return frame->colorLabel();
     }
 
     void setFrameColorLabel(int row, int column, int color) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return;
 
         KisKeyframeChannel *primaryChannel = dummy->node()->getKeyframeChannel(KisKeyframeChannel::Content.id());
         if (!primaryChannel) return;
 
         KisKeyframeSP frame = primaryChannel->keyframeAt(column);
         if (!frame) return;
 
         frame->setColorLabel(color);
     }
 
     int layerColorLabel(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return -1;
         return dummy->node()->colorLabelIndex();
     }
 
     QVariant layerProperties(int row) const {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return QVariant();
 
         PropertyList props = dummy->node()->sectionModelProperties();
         return QVariant::fromValue(props);
     }
 
     bool setLayerProperties(int row, PropertyList props) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisNodePropertyListCommand::setNodePropertiesNoUndo(dummy->node(), image, props);
         return true;
     }
 
     bool addKeyframe(int row, int column, bool copy) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         KisNodeSP node = dummy->node();
         if (!KisAnimationUtils::supportsContentFrames(node)) return false;
 
         KisAnimationUtils::createKeyframeLazy(image, node, KisKeyframeChannel::Content.id(), column, copy);
         return true;
     }
 
     bool addNewLayer(int row) {
         Q_UNUSED(row);
 
         if (nodeInterface) {
             KisLayerSP layer = nodeInterface->addPaintLayer();
             layer->setUseInTimeline(true);
         }
 
         return true;
     }
 
     bool removeLayer(int row) {
         KisNodeDummy *dummy = converter->dummyFromRow(row);
         if (!dummy) return false;
 
         if (nodeInterface) {
             nodeInterface->removeNode(dummy->node());
         }
 
         return true;
     }
 };
 
 TimelineFramesModel::TimelineFramesModel(QObject *parent)
     : ModelWithExternalNotifications(parent),
       m_d(new Private)
 {
     connect(&m_d->updateTimer, SIGNAL(timeout()), SLOT(processUpdateQueue()));
 }
 
 TimelineFramesModel::~TimelineFramesModel()
 {
 }
 
 bool TimelineFramesModel::hasConnectionToCanvas() const
 {
     return m_d->dummiesFacade;
 }
 
 void TimelineFramesModel::setNodeManipulationInterface(NodeManipulationInterface *iface)
 {
     m_d->nodeInterface.reset(iface);
 }
 
 KisNodeSP TimelineFramesModel::nodeAt(QModelIndex index) const
 {
     /**
      * The dummy might not exist because the user could (quickly) change
      * active layer and the list of the nodes in m_d->converter will change.
      */
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
     return dummy ? dummy->node() : 0;
 }
 
 QMap<QString, KisKeyframeChannel*> TimelineFramesModel::channelsAt(QModelIndex index) const
 {
     KisNodeDummy *srcDummy = m_d->converter->dummyFromRow(index.row());
     return srcDummy->node()->keyframeChannels();
 }
 
 void TimelineFramesModel::setDummiesFacade(KisDummiesFacadeBase *dummiesFacade, KisImageSP image)
 {
     KisDummiesFacadeBase *oldDummiesFacade = m_d->dummiesFacade;
 
     if (m_d->dummiesFacade && m_d->image) {
         m_d->image->animationInterface()->disconnect(this);
         m_d->image->disconnect(this);
         m_d->dummiesFacade->disconnect(this);
     }
 
     m_d->image = image;
     KisTimeBasedItemModel::setImage(image);
 
     m_d->dummiesFacade = dummiesFacade;
     m_d->converter.reset();
 
     if (m_d->dummiesFacade) {
         m_d->converter.reset(new TimelineNodeListKeeper(this, m_d->dummiesFacade));
         connect(m_d->dummiesFacade, SIGNAL(sigDummyChanged(KisNodeDummy*)),
                 SLOT(slotDummyChanged(KisNodeDummy*)));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigFullClipRangeChanged()), SIGNAL(sigInfiniteTimelineUpdateNeeded()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioChannelChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image->animationInterface(),
                 SIGNAL(sigAudioVolumeChanged()), SIGNAL(sigAudioChannelChanged()));
         connect(m_d->image, SIGNAL(sigImageModified()), SLOT(slotImageContentChanged()));
     }
 
     if (m_d->dummiesFacade != oldDummiesFacade) {
         beginResetModel();
         endResetModel();
     }
 
     if (m_d->dummiesFacade) {
         emit sigInfiniteTimelineUpdateNeeded();
         emit sigAudioChannelChanged();
     }
 }
 
 void TimelineFramesModel::slotDummyChanged(KisNodeDummy *dummy)
 {
     if (!m_d->updateQueue.contains(dummy)) {
         m_d->updateQueue.append(dummy);
     }
     m_d->updateTimer.start();
 }
 
 void TimelineFramesModel::slotImageContentChanged()
 {
     if (m_d->activeLayerIndex < 0) return;
 
     KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
     if (!dummy) return;
 
     slotDummyChanged(dummy);
 }
 
 void TimelineFramesModel::processUpdateQueue()
 {
     Q_FOREACH (KisNodeDummy *dummy, m_d->updateQueue) {
         int row = m_d->converter->rowForDummy(dummy);
 
         if (row >= 0) {
             emit headerDataChanged (Qt::Vertical, row, row);
             emit dataChanged(this->index(row, 0), this->index(row, columnCount() - 1));
         }
     }
     m_d->updateQueue.clear();
 }
 
 void TimelineFramesModel::slotCurrentNodeChanged(KisNodeSP node)
 {
     if (!node) {
         m_d->activeLayerIndex = -1;
         return;
     }
 
     KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(node);
     if (!dummy) {
         // It's perfectly normal that dummyForNode returns 0; that happens
         // when views get activated while Krita is closing down.
         return;
     }
 
     m_d->converter->updateActiveDummy(dummy);
 
     const int row = m_d->converter->rowForDummy(dummy);
     if (row < 0) {
         qWarning() << "WARNING: TimelineFramesModel::slotCurrentNodeChanged: node not found!";
     }
 
     if (row >= 0 && m_d->activeLayerIndex != row) {
         setData(index(row, 0), true, ActiveLayerRole);
     }
 }
 
 int TimelineFramesModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     if(!m_d->dummiesFacade) return 0;
 
     return m_d->converter->rowCount();
 }
 
 QVariant TimelineFramesModel::data(const QModelIndex &index, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     switch (role) {
     case ActiveLayerRole: {
         return index.row() == m_d->activeLayerIndex;
     }
     case FrameEditableRole: {
         return m_d->layerEditable(index.row());
     }
     case FrameHasContent: {
         return m_d->frameHasContent(index.row(), index.column());
     }
     case FrameExistsRole: {
         return m_d->frameExists(index.row(), index.column());
     }
     case SpecialKeyframeExists: {
         return m_d->specialKeyframeExists(index.row(), index.column());
     }
     case FrameColorLabelIndexRole: {
         int label = m_d->frameColorLabel(index.row(), index.column());
         return label > 0 ? label : QVariant();
     }
     case Qt::DisplayRole: {
         return m_d->layerName(index.row());
     }
     case Qt::TextAlignmentRole: {
         return QVariant(Qt::AlignHCenter | Qt::AlignVCenter);
     }
     case KoResourceModel::LargeThumbnailRole: {
         KisNodeDummy *dummy = m_d->converter->dummyFromRow(index.row());
         if (!dummy) {
             return  QVariant();
         }
         const int maxSize = 200;
 
         QSize size = dummy->node()->extent().size();
         size.scale(maxSize, maxSize, Qt::KeepAspectRatio);
         if (size.width() == 0 || size.height() == 0) {
             // No thumbnail can be shown if there isn't width or height...
             return QVariant();
         }
         QImage image(dummy->node()->createThumbnailForFrame(size.width(), size.height(), index.column()));
         return image;
     }
     }
 
     return ModelWithExternalNotifications::data(index, role);
 }
 
 bool TimelineFramesModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     if (!index.isValid() || !m_d->dummiesFacade) return false;
 
     switch (role) {
     case ActiveLayerRole: {
         if (value.toBool() &&
             index.row() != m_d->activeLayerIndex) {
 
             int prevLayer = m_d->activeLayerIndex;
             m_d->activeLayerIndex = index.row();
 
             emit dataChanged(this->index(prevLayer, 0), this->index(prevLayer, columnCount() - 1));
             emit dataChanged(this->index(m_d->activeLayerIndex, 0), this->index(m_d->activeLayerIndex, columnCount() - 1));
 
             emit headerDataChanged(Qt::Vertical, prevLayer, prevLayer);
             emit headerDataChanged(Qt::Vertical, m_d->activeLayerIndex, m_d->activeLayerIndex);
 
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(m_d->activeLayerIndex);
             KIS_ASSERT_RECOVER(dummy) { return true; }
 
             emit requestCurrentNodeChanged(dummy->node());
             emit sigEnsureRowVisible(m_d->activeLayerIndex);
         }
         break;
     }
     case FrameColorLabelIndexRole: {
         m_d->setFrameColorLabel(index.row(), index.column(), value.toInt());
     }
         break;
     }
 
     return ModelWithExternalNotifications::setData(index, value, role);
 }
 
 QVariant TimelineFramesModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if(!m_d->dummiesFacade) return QVariant();
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole:
             return section == m_d->activeLayerIndex;
         case Qt::DisplayRole: {
             QVariant value = headerData(section, orientation, Qt::ToolTipRole);
             if (!value.isValid()) return value;
 
             QString name = value.toString();
             const int maxNameSize = 13;
 
             if (name.size() > maxNameSize) {
                 name = QString("%1...").arg(name.left(maxNameSize));
             }
 
             return name;
         }
         case Qt::TextColorRole: {
             // WARNING: this role doesn't work for header views! Use
             //          bold font to show isolated mode instead!
             return QVariant();
         }
         case Qt::FontRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             KisNodeSP node = dummy->node();
 
             QFont baseFont;
             if (node->projectionLeaf()->isDroppedMask()) {
                 baseFont.setStrikeOut(true);
             } else if (m_d->image && m_d->image->isolatedModeRoot() &&
                        KisNodeModel::belongsToIsolatedGroup(m_d->image, node, m_d->dummiesFacade)) {
                 baseFont.setBold(true);
             }
             return baseFont;
         }
         case Qt::ToolTipRole: {
             return m_d->layerName(section);
         }
         case TimelinePropertiesRole: {
             return QVariant::fromValue(m_d->layerProperties(section));
         }
         case OtherLayersRole: {
             TimelineNodeListKeeper::OtherLayersList list =
                 m_d->converter->otherLayersList();
 
             return QVariant::fromValue(list);
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return QVariant();
             return dummy->node()->useInTimeline();
         }
         case Qt::BackgroundRole: {
             int label = m_d->layerColorLabel(section);
             if (label > 0) {
                 KisNodeViewColorScheme scm;
                 QColor color = scm.colorLabel(label);
                 QPalette pal = qApp->palette();
                 color = KritaUtils::blendColors(color, pal.color(QPalette::Button), 0.3);
                 return QBrush(color);
             } else {
                 return QVariant();
             }
         }
         }
     }
 
     return ModelWithExternalNotifications::headerData(section, orientation, role);
 }
 
 bool TimelineFramesModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
 {
     if (!m_d->dummiesFacade) return false;
 
     if (orientation == Qt::Vertical) {
         switch (role) {
         case ActiveLayerRole: {
             setData(index(section, 0), value, role);
             break;
         }
         case TimelinePropertiesRole: {
             TimelineFramesModel::PropertyList props = value.value<TimelineFramesModel::PropertyList>();
 
             int result = m_d->setLayerProperties(section, props);
             emit headerDataChanged (Qt::Vertical, section, section);
             return result;
         }
         case LayerUsedInTimelineRole: {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(section);
             if (!dummy) return false;
             dummy->node()->setUseInTimeline(value.toBool());
             return true;
         }
         }
     }
 
     return ModelWithExternalNotifications::setHeaderData(section, orientation, value, role);
 }
 
 Qt::DropActions TimelineFramesModel::supportedDragActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 Qt::DropActions TimelineFramesModel::supportedDropActions() const
 {
     return Qt::MoveAction | Qt::CopyAction;
 }
 
 QStringList TimelineFramesModel::mimeTypes() const
 {
     QStringList types;
     types << QLatin1String("application/x-krita-frame");
     return types;
 }
 
 void TimelineFramesModel::setLastClickedIndex(const QModelIndex &index)
 {
     m_d->lastClickedIndex = index;
 }
 
 QMimeData* TimelineFramesModel::mimeData(const QModelIndexList &indexes) const
 {
     return mimeDataExtended(indexes, m_d->lastClickedIndex, UndefinedPolicy);
 }
 
 QMimeData *TimelineFramesModel::mimeDataExtended(const QModelIndexList &indexes,
                                                  const QModelIndex &baseIndex,
                                                  TimelineFramesModel::MimeCopyPolicy copyPolicy) const
 {
     QMimeData *data = new QMimeData();
 
     QByteArray encoded;
     QDataStream stream(&encoded, QIODevice::WriteOnly);
 
     const int baseRow = baseIndex.row();
     const int baseColumn = baseIndex.column();
 
     stream << indexes.size();
     stream << baseRow << baseColumn;
 
     Q_FOREACH (const QModelIndex &index, indexes) {
         KisNodeSP node = nodeAt(index);
         KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
         stream << index.row() - baseRow << index.column() - baseColumn;
 
         const QByteArray uuidData = node->uuid().toRfc4122();
         stream << int(uuidData.size());
         stream.writeRawData(uuidData.data(), uuidData.size());
     }
 
     stream << int(copyPolicy);
     data->setData("application/x-krita-frame", encoded);
 
     return data;
 }
 
 inline void decodeBaseIndex(QByteArray *encoded, int *row, int *col)
 {
     int size_UNUSED = 0;
 
     QDataStream stream(encoded, QIODevice::ReadOnly);
     stream >> size_UNUSED >> *row >> *col;
 }
 
 bool TimelineFramesModel::canDropFrameData(const QMimeData */*data*/, const QModelIndex &index)
 {
     if (!index.isValid()) return false;
 
     /**
      * Now we support D&D around any layer, so just return 'true' all
      * the time.
      */
     return true;
 }
 
 bool TimelineFramesModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
     Q_UNUSED(row);
     Q_UNUSED(column);
 
     return dropMimeDataExtended(data, action, parent);
 }
 
 bool TimelineFramesModel::dropMimeDataExtended(const QMimeData *data, Qt::DropAction action, const QModelIndex &parent, bool *dataMoved)
 {
     bool result = false;
 
     if ((action != Qt::MoveAction && action != Qt::CopyAction) ||
         !parent.isValid()) return result;
 
     QByteArray encoded = data->data("application/x-krita-frame");
     QDataStream stream(&encoded, QIODevice::ReadOnly);
 
     int size, baseRow, baseColumn;
     stream >> size >> baseRow >> baseColumn;
 
     const QPoint offset(parent.column() - baseColumn, parent.row() - baseRow);
 
     KisAnimationUtils::FrameMovePairList frameMoves;
 
     for (int i = 0; i < size; i++) {
         int relRow, relColumn;
         stream >> relRow >> relColumn;
 
         const int srcRow = baseRow + relRow;
         const int srcColumn = baseColumn + relColumn;
 
         int uuidLen = 0;
         stream >> uuidLen;
         QByteArray uuidData(uuidLen, '\0');
         stream.readRawData(uuidData.data(), uuidLen);
         QUuid nodeUuid = QUuid::fromRfc4122(uuidData);
 
         KisNodeSP srcNode;
 
         if (!nodeUuid.isNull()) {
             KisNodeUuidInfo nodeInfo(nodeUuid);
             srcNode = nodeInfo.findNode(m_d->image->root());
         } else {
             QModelIndex index = this->index(srcRow, srcColumn);
             srcNode = nodeAt(index);
         }
 
         KIS_SAFE_ASSERT_RECOVER(srcNode) { continue; }
 
         const QModelIndex dstIndex = this->index(srcRow + offset.y(), srcColumn + offset.x());
         if (!dstIndex.isValid()) continue;
 
         KisNodeSP dstNode = nodeAt(dstIndex);
         KIS_SAFE_ASSERT_RECOVER(dstNode) { continue; }
 
         Q_FOREACH (KisKeyframeChannel *channel, srcNode->keyframeChannels().values()) {
             KisAnimationUtils::FrameItem srcItem(srcNode, channel->id(), srcColumn);
             KisAnimationUtils::FrameItem dstItem(dstNode, channel->id(), dstIndex.column());
             frameMoves << std::make_pair(srcItem, dstItem);
         }
     }
 
     MimeCopyPolicy copyPolicy = UndefinedPolicy;
 
     if (!stream.atEnd()) {
         int value = 0;
         stream >> value;
         copyPolicy = MimeCopyPolicy(value);
     }
 
     const bool copyFrames =
         copyPolicy == UndefinedPolicy ?
         action == Qt::CopyAction :
         copyPolicy == CopyFramesPolicy;
 
     if (dataMoved) {
         *dataMoved = !copyFrames;
     }
 
     KUndo2Command *cmd = 0;
 
     if (!frameMoves.isEmpty()) {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
         cmd = KisAnimationUtils::createMoveKeyframesCommand(frameMoves, copyFrames, 0);
     }
 
     if (cmd) {
         KisProcessingApplicator::runSingleCommandStroke(m_d->image, cmd, KisStrokeJobData::BARRIER);
     }
 
     return cmd;
 }
 
 Qt::ItemFlags TimelineFramesModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags flags = ModelWithExternalNotifications::flags(index);
     if (!index.isValid()) return flags;
 
     if (m_d->frameExists(index.row(), index.column()) || m_d->specialKeyframeExists(index.row(), index.column())) {
         if (data(index, FrameEditableRole).toBool()) {
             flags |= Qt::ItemIsDragEnabled;
         }
     }
 
     /**
      * Basically we should forbid overrides only if we D&D a single frame
      * and allow it when we D&D multiple frames. But we cannot distinguish
      * it here... So allow all the time.
      */
     flags |= Qt::ItemIsDropEnabled;
 
     return flags;
 }
 
 bool TimelineFramesModel::insertRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
 
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row > rowCount()) return false;
 
     bool result = m_d->addNewLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::removeRows(int row, int count, const QModelIndex &parent)
 {
     Q_UNUSED(parent);
     KIS_ASSERT_RECOVER(count == 1) { return false; }
 
     if (row < 0 || row >= rowCount()) return false;
 
     bool result = m_d->removeLayer(row);
     return result;
 }
 
 bool TimelineFramesModel::insertOtherLayer(int index, int dstRow)
 {
     Q_UNUSED(dstRow);
 
     TimelineNodeListKeeper::OtherLayersList list =
         m_d->converter->otherLayersList();
 
     if (index < 0 || index >= list.size()) return false;
 
     list[index].dummy->node()->setUseInTimeline(true);
     dstRow = m_d->converter->rowForDummy(list[index].dummy);
     setData(this->index(dstRow, 0), true, ActiveLayerRole);
 
     return true;
 }
 
 int TimelineFramesModel::activeLayerRow() const
 {
     return m_d->activeLayerIndex;
 }
 
 bool TimelineFramesModel::createFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), false);
 }
 
 bool TimelineFramesModel::copyFrame(const QModelIndex &dstIndex)
 {
     if (!dstIndex.isValid()) return false;
 
     return m_d->addKeyframe(dstIndex.row(), dstIndex.column(), true);
 }
 
-bool TimelineFramesModel::insertFrames(int dstColumn, const QList<int> &dstRows, int count)
+bool TimelineFramesModel::insertFrames(int dstColumn, const QList<int> &dstRows, int count, int timing)
 {
     if (dstRows.isEmpty() || count <= 0) return true;
+    timing = qMax(timing, 1);
 
     KUndo2Command *parentCommand = new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QModelIndexList indexes;
 
         Q_FOREACH (int row, dstRows) {
             for (int column = dstColumn; column < columnCount(); column++) {
                 indexes << index(row, column);
             }
         }
 
-        setLastVisibleFrame(columnCount() + count - 1);
+        setLastVisibleFrame(columnCount() + (count * timing) - 1);
 
-
-        createOffsetFramesCommand(indexes, QPoint(count, 0), false, parentCommand);
+        createOffsetFramesCommand(indexes, QPoint((count * timing), 0), false, parentCommand);
 
         Q_FOREACH (int row, dstRows) {
             KisNodeDummy *dummy = m_d->converter->dummyFromRow(row);
             if (!dummy) continue;
 
             KisNodeSP node = dummy->node();
             if (!KisAnimationUtils::supportsContentFrames(node)) continue;
 
-            for (int column = dstColumn; column < dstColumn + count; column++) {
+            for (int column = dstColumn; column < dstColumn + (count * timing); column += timing) {
                 KisAnimationUtils::createKeyframeCommand(m_d->image, node, KisKeyframeChannel::Content.id(), column, false, parentCommand);
             }
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
-        const int newTime = dstColumn > oldTime ? dstColumn : dstColumn + count - 1;
+        const int newTime = dstColumn > oldTime ? dstColumn : dstColumn + (count * timing) - 1;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand);
     }
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand, KisStrokeJobData::BARRIER);
 
     return true;
 }
 
 bool TimelineFramesModel::insertHoldFrames(QModelIndexList selectedIndexes, int count)
 {
     if (selectedIndexes.isEmpty() || count == 0) return true;
 
     QScopedPointer<KUndo2Command> parentCommand(new KUndo2Command(kundo2_i18np("Insert frame", "Insert %1 frames", count)));
 
     {
         KisImageBarrierLockerWithFeedback locker(m_d->image);
 
         QSet<KisKeyframeSP> uniqueKeyframesInSelection;
 
         Q_FOREACH (const QModelIndex &index, selectedIndexes) {
             KisNodeSP node = nodeAt(index);
             KIS_SAFE_ASSERT_RECOVER(node) { continue; }
 
             KisKeyframeChannel *channel = node->getKeyframeChannel(KisKeyframeChannel::Content.id());
             if (!channel) continue;
 
             KisKeyframeSP keyFrame = channel->activeKeyframeAt(index.column());
 
             if (keyFrame) {
                 uniqueKeyframesInSelection.insert(keyFrame);
             }
         }
 
         int minSelectedTime = std::numeric_limits<int>::max();
         QList<KisKeyframeSP> keyframesToMove;
 
         for (auto it = uniqueKeyframesInSelection.begin(); it != uniqueKeyframesInSelection.end(); ++it) {
             KisKeyframeSP keyframe = *it;
 
             minSelectedTime = qMin(minSelectedTime, keyframe->time());
 
             KisKeyframeChannel *channel = keyframe->channel();
             KisKeyframeSP nextKeyframe = channel->nextKeyframe(keyframe);
 
             if (nextKeyframe) {
                 keyframesToMove << nextKeyframe;
             }
         }
 
         std::sort(keyframesToMove.begin(), keyframesToMove.end(),
             [] (KisKeyframeSP lhs, KisKeyframeSP rhs) {
                 return lhs->time() > rhs->time();
             });
 
         if (keyframesToMove.isEmpty()) return true;
 
         const int maxColumn = columnCount();
 
         if (count > 0) {
             setLastVisibleFrame(columnCount() + count);
         }
 
         Q_FOREACH (KisKeyframeSP keyframe, keyframesToMove) {
             int plannedFrameMove = count;
 
             if (count < 0) {
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(keyframe->time() > 0, false);
 
                 KisKeyframeSP prevFrame = keyframe->channel()->previousKeyframe(keyframe);
                 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(prevFrame, false);
 
                 plannedFrameMove = qMax(count, prevFrame->time() - keyframe->time() + 1);
             }
 
             KisNodeDummy *dummy = m_d->dummiesFacade->dummyForNode(keyframe->channel()->node());
             KIS_SAFE_ASSERT_RECOVER(dummy) { continue; }
 
             const int row = m_d->converter->rowForDummy(dummy);
             KIS_SAFE_ASSERT_RECOVER(row >= 0) { continue; }
 
             QModelIndexList indexes;
             for (int column = keyframe->time(); column < maxColumn; column++) {
                 indexes << index(row, column);
             }
 
             createOffsetFramesCommand(indexes, QPoint(plannedFrameMove, 0), false, parentCommand.data());
         }
 
         const int oldTime = m_d->image->animationInterface()->currentUITime();
         const int newTime = minSelectedTime;
 
         new KisSwitchCurrentTimeCommand(m_d->image->animationInterface(),
                                         oldTime,
                                         newTime, parentCommand.data());
     }
 
 
     KisProcessingApplicator::runSingleCommandStroke(m_d->image, parentCommand.take(), KisStrokeJobData::BARRIER);
     return true;
 }
 
-
 QString TimelineFramesModel::audioChannelFileName() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioChannelFileName() : QString();
 }
 
 void TimelineFramesModel::setAudioChannelFileName(const QString &fileName)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioChannelFileName(fileName);
 }
 
 bool TimelineFramesModel::isAudioMuted() const
 {
     return m_d->image ? m_d->image->animationInterface()->isAudioMuted() : false;
 }
 
 void TimelineFramesModel::setAudioMuted(bool value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioMuted(value);
 }
 
 qreal TimelineFramesModel::audioVolume() const
 {
     return m_d->image ? m_d->image->animationInterface()->audioVolume() : 0.5;
 }
 
 void TimelineFramesModel::setAudioVolume(qreal value)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->image);
     m_d->image->animationInterface()->setAudioVolume(value);
 }
 
 void TimelineFramesModel::setFullClipRangeStart(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeStartTime(column);
 }
 
 void TimelineFramesModel::setFullClipRangeEnd(int column)
 {
     m_d->image->animationInterface()->setFullClipRangeEndTime(column);
 }
diff --git a/plugins/dockers/animation/timeline_frames_model.h b/plugins/dockers/animation/timeline_frames_model.h
index bbadd52bea..ab88a76e10 100644
--- a/plugins/dockers/animation/timeline_frames_model.h
+++ b/plugins/dockers/animation/timeline_frames_model.h
@@ -1,152 +1,152 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@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 __TIMELINE_FRAMES_MODEL_H
 #define __TIMELINE_FRAMES_MODEL_H
 
 #include <QScopedPointer>
 #include <QIcon>
 
 #include "kritaanimationdocker_export.h"
 #include "kis_node_model.h"
 #include "kis_types.h"
 #include "kis_node.h"
 #include "timeline_node_list_keeper.h"
 
 class KisNodeDummy;
 class KisDummiesFacadeBase;
 class KisAnimationPlayer;
 
 
 class KRITAANIMATIONDOCKER_EXPORT TimelineFramesModel : public TimelineNodeListKeeper::ModelWithExternalNotifications
 {
     Q_OBJECT
 
 public:
     enum MimeCopyPolicy {
         UndefinedPolicy = 0,
         MoveFramesPolicy,
         CopyFramesPolicy
     };
 
 public:
     TimelineFramesModel(QObject *parent);
     ~TimelineFramesModel() override;
 
     bool hasConnectionToCanvas() const;
 
     void setDummiesFacade(KisDummiesFacadeBase *dummiesFacade, KisImageSP image);
 
     bool canDropFrameData(const QMimeData *data, const QModelIndex &index);
     bool insertOtherLayer(int index, int dstRow);
     int activeLayerRow() const;
 
     bool createFrame(const QModelIndex &dstIndex);
     bool copyFrame(const QModelIndex &dstIndex);
 
-    bool insertFrames(int dstColumn, const QList<int> &dstRows, int count);
+    bool insertFrames(int dstColumn, const QList<int> &dstRows, int count, int timing = 1);
 
     bool insertHoldFrames(QModelIndexList selectedIndexes, int count);
 
     QString audioChannelFileName() const;
     void setAudioChannelFileName(const QString &fileName);
 
     bool isAudioMuted() const;
     void setAudioMuted(bool value);
 
     qreal audioVolume() const;
     void setAudioVolume(qreal value);
 
     void setFullClipRangeStart(int column);
     void setFullClipRangeEnd(int column);
 
     void setLastClickedIndex(const QModelIndex &index);
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     bool setData(const QModelIndex &index, const QVariant &value, int role) override;
     QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
     bool setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role) override;
 
     Qt::DropActions supportedDragActions() const override;
     Qt::DropActions supportedDropActions() const override;
     QStringList mimeTypes() const override;
     QMimeData * mimeData(const QModelIndexList &indexes) const override;
     QMimeData * mimeDataExtended(const QModelIndexList &indexes, const QModelIndex &baseIndex, MimeCopyPolicy copyPolicy) const;
     bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) override;
 
     bool dropMimeDataExtended(const QMimeData *data, Qt::DropAction action, const QModelIndex &parent, bool *dataMoved = 0);
 
     Qt::ItemFlags flags(const QModelIndex &index) const override;
 
     bool insertRows(int row, int count, const QModelIndex &parent) override;
     bool removeRows(int row, int count, const QModelIndex &parent) override;
 
     enum ItemDataRole
     {
         ActiveLayerRole = KisTimeBasedItemModel::UserRole,
         TimelinePropertiesRole,
         OtherLayersRole,
         LayerUsedInTimelineRole,
         FrameColorLabelIndexRole
     };
 
     // metatype is added by the original implementation
     typedef KisBaseNode::Property Property;
     typedef KisBaseNode::PropertyList PropertyList;
 
     typedef TimelineNodeListKeeper::OtherLayer OtherLayer;
     typedef TimelineNodeListKeeper::OtherLayersList OtherLayersList;
 
 
     struct NodeManipulationInterface {
         virtual ~NodeManipulationInterface() {}
         virtual KisLayerSP addPaintLayer() const = 0;
         virtual void removeNode(KisNodeSP node) const = 0;
     };
 
     /**
      * NOTE: the model has an ownership over the interface, that is it'll
      *       be deleted automatically later
      */
     void setNodeManipulationInterface(NodeManipulationInterface *iface);
 
 protected:
     KisNodeSP nodeAt(QModelIndex index) const override;
     QMap<QString, KisKeyframeChannel *> channelsAt(QModelIndex index) const override;
 
 private Q_SLOTS:
     void slotDummyChanged(KisNodeDummy *dummy);
     void slotImageContentChanged();
     void processUpdateQueue();
 
 public Q_SLOTS:
     void slotCurrentNodeChanged(KisNodeSP node);
 
 Q_SIGNALS:
     void requestCurrentNodeChanged(KisNodeSP node);
     void sigInfiniteTimelineUpdateNeeded();
     void sigAudioChannelChanged();
     void sigEnsureRowVisible(int row);
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __TIMELINE_FRAMES_MODEL_H */
diff --git a/plugins/dockers/animation/timeline_frames_view.cpp b/plugins/dockers/animation/timeline_frames_view.cpp
index c118b4ea93..688382a986 100644
--- a/plugins/dockers/animation/timeline_frames_view.cpp
+++ b/plugins/dockers/animation/timeline_frames_view.cpp
@@ -1,1753 +1,1725 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@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 "timeline_frames_view.h"
 
 #include "timeline_frames_model.h"
 
 #include "timeline_ruler_header.h"
 #include "timeline_layers_header.h"
+#include "timeline_insert_keyframe_dialog.h"
 
 #include <cmath>
 #include <limits>
 
 #include <QPainter>
 
 #include <QFileInfo>
 #include <QApplication>
 #include <QHeaderView>
 #include <QDropEvent>
 #include <QToolButton>
 #include <QMenu>
 #include <QScrollBar>
 #include <QIcon>
 #include <QDrag>
 #include <QWidgetAction>
 #include <kis_signals_blocker.h>
 #include <kis_image_config.h>
 
 #include "KSharedConfig"
 
 #include "kis_debug.h"
 #include "timeline_frames_item_delegate.h"
 
 #include "kis_zoom_button.h"
 
 #include "kis_icon_utils.h"
 
 #include "kis_animation_utils.h"
 #include "kis_custom_modifiers_catcher.h"
 #include "kis_action.h"
 #include "kis_signal_compressor.h"
 #include "kis_time_range.h"
 #include "kis_color_label_selector_widget.h"
 #include "kis_slider_spin_box.h"
 #include <KisImportExportManager.h>
 
 #include <KoFileDialog.h>
 #include <KoIconToolTip.h>
 #include <QStandardPaths>
 #include <QWidgetAction>
 #include <QInputDialog>
 
 #include <QClipboard>
 #include <QMimeData>
 
 #include "config-qtmultimedia.h"
 
 typedef QPair<QRect, QModelIndex> QItemViewPaintPair;
 typedef QList<QItemViewPaintPair> QItemViewPaintPairs;
 
 struct TimelineFramesView::Private
 {
     Private(TimelineFramesView *_q)
         : q(_q),
           fps(1),
           zoomStillPointIndex(-1),
           zoomStillPointOriginalOffset(0),
           dragInProgress(false),
           dragWasSuccessful(false),
           modifiersCatcher(0),
           selectionChangedCompressor(300, KisSignalCompressor::FIRST_INACTIVE)
     {}
 
     TimelineFramesView *q;
 
     TimelineFramesModel *model;
     TimelineRulerHeader *horizontalRuler;
     TimelineLayersHeader *layersHeader;
     int fps;
     int zoomStillPointIndex;
     int zoomStillPointOriginalOffset;
     QPoint initialDragPanValue;
     QPoint initialDragPanPos;
 
     QToolButton *addLayersButton;
     KisAction *showHideLayerAction;
 
     QToolButton *audioOptionsButton;
 
     KisColorLabelSelectorWidget *colorSelector;
     QWidgetAction *colorSelectorAction;
     KisColorLabelSelectorWidget *multiframeColorSelector;
     QWidgetAction *multiframeColorSelectorAction;
 
     QMenu *audioOptionsMenu;
     QAction *openAudioAction;
     QAction *audioMuteAction;
     KisSliderSpinBox *volumeSlider;
 
-
     QMenu *layerEditingMenu;
     QMenu *existingLayersMenu;
 
+    TimelineInsertKeyframeDialog *insertKeyframeDialog;
+
     KisZoomButton *zoomDragButton;
 
     bool dragInProgress;
     bool dragWasSuccessful;
 
     KisCustomModifiersCatcher *modifiersCatcher;
     QPoint lastPressedPosition;
     Qt::KeyboardModifiers lastPressedModifier;
     KisSignalCompressor selectionChangedCompressor;
 
     QStyleOptionViewItem viewOptionsV4() const;
     QItemViewPaintPairs draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const;
     QPixmap renderToPixmap(const QModelIndexList &indexes, QRect *r) const;
 
     KoIconToolTip tip;
 
     KisActionManager * actionMan = 0;
 };
 
 TimelineFramesView::TimelineFramesView(QWidget *parent)
     : QTableView(parent),
       m_d(new Private(this))
 {
     m_d->modifiersCatcher = new KisCustomModifiersCatcher(this);
     m_d->modifiersCatcher->addModifier("pan-zoom", Qt::Key_Space);
     m_d->modifiersCatcher->addModifier("offset-frame", Qt::Key_Alt);
 
     setCornerButtonEnabled(false);
     setSelectionBehavior(QAbstractItemView::SelectItems);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
 
     setItemDelegate(new TimelineFramesItemDelegate(this));
 
     setDragEnabled(true);
     setDragDropMode(QAbstractItemView::DragDrop);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
     setDefaultDropAction(Qt::MoveAction);
 
     m_d->horizontalRuler = new TimelineRulerHeader(this);
     this->setHorizontalHeader(m_d->horizontalRuler);
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnsLeft()), SLOT(slotInsertColumnsLeft()));
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnsRight()), SLOT(slotInsertColumnsRight()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnsLeftCustom()), SLOT(slotInsertColumnsLeftCustom()));
     connect(m_d->horizontalRuler, SIGNAL(sigInsertColumnsRightCustom()), SLOT(slotInsertColumnsRightCustom()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumns()), SLOT(slotRemoveColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveColumnsAndShift()), SLOT(slotRemoveColumnsAndShift()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumns()), SLOT(slotInsertHoldColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumns()), SLOT(slotRemoveHoldColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigInsertHoldColumnsCustom()), SLOT(slotInsertHoldColumnsCustom()));
     connect(m_d->horizontalRuler, SIGNAL(sigRemoveHoldColumnsCustom()), SLOT(slotRemoveHoldColumnsCustom()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigMirrorColumns()), SLOT(slotMirrorColumns()));
 
     connect(m_d->horizontalRuler, SIGNAL(sigCopyColumns()), SLOT(slotCopyColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigCutColumns()), SLOT(slotCutColumns()));
     connect(m_d->horizontalRuler, SIGNAL(sigPasteColumns()), SLOT(slotPasteColumns()));
 
     m_d->layersHeader = new TimelineLayersHeader(this);
 
     m_d->layersHeader->setSectionResizeMode(QHeaderView::Fixed);
 
     m_d->layersHeader->setDefaultSectionSize(24);
     m_d->layersHeader->setMinimumWidth(60);
     m_d->layersHeader->setHighlightSections(true);
 
     this->setVerticalHeader(m_d->layersHeader);
 
     connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), SLOT(slotUpdateInfiniteFramesCount()));
     connect(horizontalScrollBar(), SIGNAL(sliderReleased()), SLOT(slotUpdateInfiniteFramesCount()));
 
-
     /********** New Layer Menu ***********************************************************/
 
     m_d->addLayersButton = new QToolButton(this);
     m_d->addLayersButton->setAutoRaise(true);
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->addLayersButton->setIconSize(QSize(20, 20));
     m_d->addLayersButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->layerEditingMenu = new QMenu(this);
     m_d->layerEditingMenu->addAction(KisAnimationUtils::newLayerActionName, this, SLOT(slotAddNewLayer()));
     m_d->existingLayersMenu = m_d->layerEditingMenu->addMenu(KisAnimationUtils::addExistingLayerActionName);
     m_d->layerEditingMenu->addSeparator();
 
     m_d->layerEditingMenu->addAction(KisAnimationUtils::removeLayerActionName, this, SLOT(slotRemoveLayer()));
 
     connect(m_d->existingLayersMenu, SIGNAL(aboutToShow()), SLOT(slotUpdateLayersMenu()));
     connect(m_d->existingLayersMenu, SIGNAL(triggered(QAction*)), SLOT(slotAddExistingLayer(QAction*)));
 
     connect(m_d->layersHeader, SIGNAL(sigRequestContextMenu(const QPoint&)), SLOT(slotLayerContextMenuRequested(const QPoint&)));
 
     m_d->addLayersButton->setMenu(m_d->layerEditingMenu);
 
     /********** Audio Channel Menu *******************************************************/
 
     m_d->audioOptionsButton = new QToolButton(this);
     m_d->audioOptionsButton->setAutoRaise(true);
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->audioOptionsButton->setIconSize(QSize(20, 20)); // very small on windows if not explicity set
     m_d->audioOptionsButton->setPopupMode(QToolButton::InstantPopup);
 
     m_d->audioOptionsMenu = new QMenu(this);
 
 #ifndef HAVE_QT_MULTIMEDIA
     m_d->audioOptionsMenu->addSection(i18nc("@item:inmenu", "Audio playback is not supported in this build!"));
 #endif
 
     m_d->openAudioAction= new QAction("XXX", this);
     connect(m_d->openAudioAction, SIGNAL(triggered()), this, SLOT(slotSelectAudioChannelFile()));
     m_d->audioOptionsMenu->addAction(m_d->openAudioAction);
 
     m_d->audioMuteAction = new QAction(i18nc("@item:inmenu", "Mute"), this);
     m_d->audioMuteAction->setCheckable(true);
     connect(m_d->audioMuteAction, SIGNAL(triggered(bool)), SLOT(slotAudioChannelMute(bool)));
 
     m_d->audioOptionsMenu->addAction(m_d->audioMuteAction);
     m_d->audioOptionsMenu->addAction(i18nc("@item:inmenu", "Remove audio"), this, SLOT(slotAudioChannelRemove()));
 
     m_d->audioOptionsMenu->addSeparator();
 
     m_d->volumeSlider = new KisSliderSpinBox(this);
     m_d->volumeSlider->setRange(0, 100);
     m_d->volumeSlider->setSuffix("%");
     m_d->volumeSlider->setPrefix(i18nc("@item:inmenu, slider", "Volume:"));
     m_d->volumeSlider->setSingleStep(1);
     m_d->volumeSlider->setPageStep(10);
     m_d->volumeSlider->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
 
     connect(m_d->volumeSlider, SIGNAL(valueChanged(int)), SLOT(slotAudioVolumeChanged(int)));
 
     QWidgetAction *volumeAction = new QWidgetAction(m_d->audioOptionsMenu);
     volumeAction->setDefaultWidget(m_d->volumeSlider);
     m_d->audioOptionsMenu->addAction(volumeAction);
 
     m_d->audioOptionsButton->setMenu(m_d->audioOptionsMenu);
 
     /********** Frame Editing Context Menu ***********************************************/
 
     m_d->colorSelector = new KisColorLabelSelectorWidget(this);
     m_d->colorSelectorAction = new QWidgetAction(this);
     m_d->colorSelectorAction->setDefaultWidget(m_d->colorSelector);
     connect(m_d->colorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
     m_d->multiframeColorSelector = new KisColorLabelSelectorWidget(this);
     m_d->multiframeColorSelectorAction = new QWidgetAction(this);
     m_d->multiframeColorSelectorAction->setDefaultWidget(m_d->multiframeColorSelector);
     connect(m_d->multiframeColorSelector, &KisColorLabelSelectorWidget::currentIndexChanged, this, &TimelineFramesView::slotColorLabelChanged);
 
+    /********** Insert Keyframes Dialog **************************************************/
+
+    m_d->insertKeyframeDialog = new TimelineInsertKeyframeDialog(this);
+
     /********** Zoom Button **************************************************************/
 
     m_d->zoomDragButton = new KisZoomButton(this);
     m_d->zoomDragButton->setAutoRaise(true);
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
     m_d->zoomDragButton->setIconSize(QSize(20, 20)); // this icon is very small on windows if no explicity set
 
     m_d->zoomDragButton->setToolTip(i18nc("@info:tooltip", "Zoom Timeline. Hold down and drag left or right."));
     m_d->zoomDragButton->setPopupMode(QToolButton::InstantPopup);
     connect(m_d->zoomDragButton, SIGNAL(zoomLevelChanged(qreal)), SLOT(slotZoomButtonChanged(qreal)));
     connect(m_d->zoomDragButton, SIGNAL(zoomStarted(qreal)), SLOT(slotZoomButtonPressed(qreal)));
 
     setFramesPerSecond(12);
     setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
 
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotSelectionChanged()));
     connect(&m_d->selectionChangedCompressor, SIGNAL(timeout()),
             SLOT(slotUpdateFrameActions()));
 
     {
         QClipboard *cb = QApplication::clipboard();
         connect(cb, SIGNAL(dataChanged()), SLOT(slotUpdateFrameActions()));
     }
 }
 
 TimelineFramesView::~TimelineFramesView()
 {
 }
 
 void TimelineFramesView::setShowInTimeline(KisAction* action)
 {
     m_d->showHideLayerAction = action;
     m_d->layerEditingMenu->addAction(m_d->showHideLayerAction);
 }
 
 void TimelineFramesView::setActionManager( KisActionManager * actionManager)
 {
     m_d->actionMan = actionManager;
     m_d->horizontalRuler->setActionManager(actionManager);
 
 
     if (actionManager) {
         KisAction *action = 0;
 
         action = m_d->actionMan->createAction("add_blank_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotNewFrame()));
 
         action = m_d->actionMan->createAction("add_duplicate_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotCopyFrame()));
 
         action = m_d->actionMan->createAction("insert_keyframes_right");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframesRight()));
 
         action = m_d->actionMan->createAction("insert_n_keyframes_right");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframesRightCustom()));
 
         action = m_d->actionMan->createAction("insert_keyframes_left");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframesLeft()));
 
         action = m_d->actionMan->createAction("insert_n_keyframes_left");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertKeyframesLeftCustom()));
 
         action = m_d->actionMan->createAction("remove_frames_and_pull");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveFramesAndShift()));
 
         action = m_d->actionMan->createAction("remove_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveFrame()));
 
         action = m_d->actionMan->createAction("insert_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertHoldFrames()));
 
         action = m_d->actionMan->createAction("insert_n_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotInsertHoldFramesCustom()));
 
         action = m_d->actionMan->createAction("remove_hold_frame");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveHoldFrames()));
 
         action = m_d->actionMan->createAction("remove_n_hold_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotRemoveHoldFramesCustom()));
 
         action = m_d->actionMan->createAction("mirror_frames");
         connect(action, SIGNAL(triggered()), SLOT(slotMirrorFrames()));
 
         action = m_d->actionMan->createAction("copy_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCopyFrames()));
 
         action = m_d->actionMan->createAction("cut_frames_to_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotCutFrames()));
 
         action = m_d->actionMan->createAction("paste_frames_from_clipboard");
         connect(action, SIGNAL(triggered()), SLOT(slotPasteFrames()));
 
         action = m_d->actionMan->createAction("set_start_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetStartTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("set_end_time");
         connect(action, SIGNAL(triggered()), SLOT(slotSetEndTimeToCurrentPosition()));
 
         action = m_d->actionMan->createAction("update_playback_range");
         connect(action, SIGNAL(triggered()), SLOT(slotUpdatePlackbackRange()));
-
-
-
     }
 }
 
 void resizeToMinimalSize(QAbstractButton *w, int minimalSize) {
     QSize buttonSize = w->sizeHint();
     if (buttonSize.height() > minimalSize) {
         buttonSize = QSize(minimalSize, minimalSize);
     }
     w->resize(buttonSize);
 }
 
 void TimelineFramesView::updateGeometries()
 {
     QTableView::updateGeometries();
 
     const int availableHeight = m_d->horizontalRuler->height();
     const int margin = 2;
     const int minimalSize = availableHeight - 2 * margin;
 
     resizeToMinimalSize(m_d->addLayersButton, minimalSize);
     resizeToMinimalSize(m_d->audioOptionsButton, minimalSize);
     resizeToMinimalSize(m_d->zoomDragButton, minimalSize);
 
     int x = 2 * margin;
     int y = (availableHeight - minimalSize) / 2;
     m_d->addLayersButton->move(x, 2 * y);
     m_d->audioOptionsButton->move(x + minimalSize + 2 * margin, 2 * y);
 
     const int availableWidth = m_d->layersHeader->width();
 
     x = availableWidth - margin - minimalSize;
     m_d->zoomDragButton->move(x, 2 * y);
 }
 
 void TimelineFramesView::setModel(QAbstractItemModel *model)
 {
     TimelineFramesModel *framesModel = qobject_cast<TimelineFramesModel*>(model);
     m_d->model = framesModel;
 
     QTableView::setModel(model);
 
     connect(m_d->model, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),
             this, SLOT(slotHeaderDataChanged(Qt::Orientation, int, int)));
 
     connect(m_d->model, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
             this, SLOT(slotDataChanged(QModelIndex,QModelIndex)));
 
     connect(m_d->model, SIGNAL(rowsRemoved(const QModelIndex&, int, int)),
             this, SLOT(slotReselectCurrentIndex()));
 
     connect(m_d->model, SIGNAL(sigInfiniteTimelineUpdateNeeded()),
             this, SLOT(slotUpdateInfiniteFramesCount()));
 
     connect(m_d->model, SIGNAL(sigAudioChannelChanged()),
             this, SLOT(slotUpdateAudioActions()));
 
     connect(selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
             &m_d->selectionChangedCompressor, SLOT(start()));
 
     connect(m_d->model, SIGNAL(sigEnsureRowVisible(int)), SLOT(slotEnsureRowVisible(int)));
     slotUpdateAudioActions();
 }
 
 void TimelineFramesView::setFramesPerSecond(int fps)
 {
     m_d->fps = fps;
     m_d->horizontalRuler->setFramePerSecond(fps);
 
     // For some reason simple update sometimes doesn't work here, so
     // reset the whole header
     //
     // m_d->horizontalRuler->reset();
 }
 
 void TimelineFramesView::slotZoomButtonPressed(qreal staticPoint)
 {
     m_d->zoomStillPointIndex =
             qIsNaN(staticPoint) ? currentIndex().column() : staticPoint;
 
     const int w = m_d->horizontalRuler->defaultSectionSize();
 
     m_d->zoomStillPointOriginalOffset =
             w * m_d->zoomStillPointIndex -
             horizontalScrollBar()->value();
 }
 
 void TimelineFramesView::slotZoomButtonChanged(qreal zoomLevel)
 {
     if (m_d->horizontalRuler->setZoom(zoomLevel)) {
         slotUpdateInfiniteFramesCount();
 
         const int w = m_d->horizontalRuler->defaultSectionSize();
         horizontalScrollBar()->setValue(w * m_d->zoomStillPointIndex - m_d->zoomStillPointOriginalOffset);
 
         viewport()->update();
     }
 }
 
 void TimelineFramesView::slotColorLabelChanged(int label)
 {
     Q_FOREACH(QModelIndex index, selectedIndexes()) {
         m_d->model->setData(index, label, TimelineFramesModel::FrameColorLabelIndexRole);
     }
 
     KisImageConfig config;
     config.setDefaultFrameColorLabel(label);
 }
 
 void TimelineFramesView::slotSelectAudioChannelFile()
 {
     if (!m_d->model) return;
 
     QString defaultDir = QStandardPaths::writableLocation(QStandardPaths::MusicLocation);
 
     const QString currentFile = m_d->model->audioChannelFileName();
     QDir baseDir = QFileInfo(currentFile).absoluteDir();
     if (baseDir.exists()) {
         defaultDir = baseDir.absolutePath();
     }
 
     const QString result = KisImportExportManager::askForAudioFileName(defaultDir, this);
     const QFileInfo info(result);
 
     if (info.exists()) {
         m_d->model->setAudioChannelFileName(info.absoluteFilePath());
     }
 }
 
 void TimelineFramesView::slotAudioChannelMute(bool value)
 {
     if (!m_d->model) return;
 
     if (value != m_d->model->isAudioMuted()) {
         m_d->model->setAudioMuted(value);
     }
 }
 
 void TimelineFramesView::slotUpdateIcons()
 {
     m_d->addLayersButton->setIcon(KisIconUtils::loadIcon("addlayer"));
     m_d->audioOptionsButton->setIcon(KisIconUtils::loadIcon("audio-none"));
     m_d->zoomDragButton->setIcon(KisIconUtils::loadIcon("zoom-horizontal"));
 }
 
 void TimelineFramesView::slotAudioChannelRemove()
 {
     if (!m_d->model) return;
     m_d->model->setAudioChannelFileName(QString());
 }
 
 void TimelineFramesView::slotUpdateAudioActions()
 {
     if (!m_d->model) return;
 
     const QString currentFile = m_d->model->audioChannelFileName();
 
     if (currentFile.isEmpty()) {
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Open audio..."));
     } else {
         QFileInfo info(currentFile);
         m_d->openAudioAction->setText(i18nc("@item:inmenu", "Change audio (%1)...", info.fileName()));
     }
 
     m_d->audioMuteAction->setChecked(m_d->model->isAudioMuted());
 
     QIcon audioIcon;
     if (currentFile.isEmpty()) {
         audioIcon = KisIconUtils::loadIcon("audio-none");
     } else {
         if (m_d->model->isAudioMuted()) {
             audioIcon = KisIconUtils::loadIcon("audio-volume-mute");
         } else {
             audioIcon = KisIconUtils::loadIcon("audio-volume-high");
         }
     }
 
     m_d->audioOptionsButton->setIcon(audioIcon);
 
     m_d->volumeSlider->setEnabled(!m_d->model->isAudioMuted());
 
     KisSignalsBlocker b(m_d->volumeSlider);
     m_d->volumeSlider->setValue(qRound(m_d->model->audioVolume() * 100.0));
 }
 
 void TimelineFramesView::slotAudioVolumeChanged(int value)
 {
     m_d->model->setAudioVolume(qreal(value) / 100.0);
 }
 
-
-
-
 void TimelineFramesView::slotUpdateInfiniteFramesCount()
 {
     if (horizontalScrollBar()->isSliderDown()) return;
 
     const int sectionWidth = m_d->horizontalRuler->defaultSectionSize();
     const int calculatedIndex =
             (horizontalScrollBar()->value() +
              m_d->horizontalRuler->width() - 1) / sectionWidth;
 
     m_d->model->setLastVisibleFrame(calculatedIndex);
 }
 
 void TimelineFramesView::currentChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     QTableView::currentChanged(current, previous);
 
     if (previous.column() != current.column()) {
         m_d->model->setData(previous, false, TimelineFramesModel::ActiveFrameRole);
         m_d->model->setData(current, true, TimelineFramesModel::ActiveFrameRole);
     }
 }
 
 QItemSelectionModel::SelectionFlags TimelineFramesView::selectionCommand(const QModelIndex &index,
                                                                          const QEvent *event) const
 {
     // WARNING: Copy-pasted from KisNodeView! Please keep in sync!
 
     /**
      * Qt has a bug: when we Ctrl+click on an item, the item's
      * selections gets toggled on mouse *press*, whereas usually it is
      * done on mouse *release*.  Therefore the user cannot do a
      * Ctrl+D&D with the default configuration. This code fixes the
      * problem by manually returning QItemSelectionModel::NoUpdate
      * flag when the user clicks on an item and returning
      * QItemSelectionModel::Toggle on release.
      */
 
     if (event &&
             (event->type() == QEvent::MouseButtonPress ||
              event->type() == QEvent::MouseButtonRelease) &&
             index.isValid()) {
 
         const QMouseEvent *mevent = static_cast<const QMouseEvent*>(event);
 
         if (mevent->button() == Qt::RightButton &&
                 selectionModel()->selectedIndexes().contains(index)) {
 
             // Allow calling context menu for multiple layers
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonPress &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::NoUpdate;
         }
 
         if (event->type() == QEvent::MouseButtonRelease &&
                 (mevent->modifiers() & Qt::ControlModifier)) {
 
             return QItemSelectionModel::Toggle;
         }
     }
 
     return QAbstractItemView::selectionCommand(index, event);
 }
 
 void TimelineFramesView::slotSelectionChanged()
 {
     int minColumn = std::numeric_limits<int>::max();
     int maxColumn = std::numeric_limits<int>::min();
 
     foreach (const QModelIndex &idx, selectedIndexes()) {
         if (idx.column() > maxColumn) {
             maxColumn = idx.column();
         }
 
         if (idx.column() < minColumn) {
             minColumn = idx.column();
         }
     }
 
     KisTimeRange range;
     if (maxColumn > minColumn) {
         range = KisTimeRange(minColumn, maxColumn - minColumn + 1);
     }
     m_d->model->setPlaybackRange(range);
 }
 
 void TimelineFramesView::slotReselectCurrentIndex()
 {
     QModelIndex index = currentIndex();
     currentChanged(index, index);
 }
 
 void TimelineFramesView::slotEnsureRowVisible(int row)
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() || row < 0) return;
 
     index = m_d->model->index(row, index.column());
     scrollTo(index);
 }
 
 void TimelineFramesView::slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
 {
     if (m_d->model->isPlaybackActive()) return;
 
     int selectedColumn = -1;
 
     for (int j = topLeft.column(); j <= bottomRight.column(); j++) {
         QVariant value = m_d->model->data(
                     m_d->model->index(topLeft.row(), j),
                     TimelineFramesModel::ActiveFrameRole);
 
         if (value.isValid() && value.toBool()) {
             selectedColumn = j;
             break;
         }
     }
 
     QModelIndex index = currentIndex();
 
     if (!index.isValid() && selectedColumn < 0) {
         return;
     }
 
 
     if (selectedColumn == -1) {
         selectedColumn = index.column();
     }
 
     if (selectedColumn != index.column() && !m_d->dragInProgress) {
         int row= index.isValid() ? index.row() : 0;
         selectionModel()->setCurrentIndex(m_d->model->index(row, selectedColumn), QItemSelectionModel::ClearAndSelect);
     }
 }
 
 void TimelineFramesView::slotHeaderDataChanged(Qt::Orientation orientation, int first, int last)
 {
     Q_UNUSED(first);
     Q_UNUSED(last);
 
     if (orientation == Qt::Horizontal) {
         const int newFps = m_d->model->headerData(0, Qt::Horizontal, TimelineFramesModel::FramesPerSecondRole).toInt();
 
         if (newFps != m_d->fps) {
             setFramesPerSecond(newFps);
         }
     }
 }
 
 void TimelineFramesView::rowsInserted(const QModelIndex& parent, int start, int end)
 {
     QTableView::rowsInserted(parent, start, end);
 }
 
 
 inline bool isIndexDragEnabled(QAbstractItemModel *model, const QModelIndex &index) {
     return (model->flags(index) & Qt::ItemIsDragEnabled);
 }
 
 QStyleOptionViewItem TimelineFramesView::Private::viewOptionsV4() const
 {
     QStyleOptionViewItem option = q->viewOptions();
     option.locale = q->locale();
     option.locale.setNumberOptions(QLocale::OmitGroupSeparator);
     option.widget = q;
     return option;
 }
 
 QItemViewPaintPairs TimelineFramesView::Private::draggablePaintPairs(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QRect &rect = *r;
     const QRect viewportRect = q->viewport()->rect();
     QItemViewPaintPairs ret;
     for (int i = 0; i < indexes.count(); ++i) {
         const QModelIndex &index = indexes.at(i);
         const QRect current = q->visualRect(index);
         if (current.intersects(viewportRect)) {
             ret += qMakePair(current, index);
             rect |= current;
         }
     }
     rect &= viewportRect;
     return ret;
 }
 
 QPixmap TimelineFramesView::Private::renderToPixmap(const QModelIndexList &indexes, QRect *r) const
 {
     Q_ASSERT(r);
     QItemViewPaintPairs paintPairs = draggablePaintPairs(indexes, r);
     if (paintPairs.isEmpty())
         return QPixmap();
     QPixmap pixmap(r->size());
     pixmap.fill(Qt::transparent);
     QPainter painter(&pixmap);
     QStyleOptionViewItem option = viewOptionsV4();
     option.state |= QStyle::State_Selected;
     for (int j = 0; j < paintPairs.count(); ++j) {
         option.rect = paintPairs.at(j).first.translated(-r->topLeft());
         const QModelIndex &current = paintPairs.at(j).second;
         //adjustViewOptionsForIndex(&option, current);
 
         q->itemDelegate(current)->paint(&painter, option, current);
     }
     return pixmap;
 }
 
 void TimelineFramesView::startDrag(Qt::DropActions supportedActions)
 {
     QModelIndexList indexes = selectionModel()->selectedIndexes();
 
     if (!indexes.isEmpty() && m_d->modifiersCatcher->modifierPressed("offset-frame")) {
         QVector<int> rows;
         int leftmostColumn = std::numeric_limits<int>::max();
 
         Q_FOREACH (const QModelIndex &index, indexes) {
             leftmostColumn = qMin(leftmostColumn, index.column());
             if (!rows.contains(index.row())) {
                 rows.append(index.row());
             }
         }
 
         const int lastColumn = m_d->model->columnCount() - 1;
 
         selectionModel()->clear();
         Q_FOREACH (const int row, rows) {
             QItemSelection sel(m_d->model->index(row, leftmostColumn), m_d->model->index(row, lastColumn));
             selectionModel()->select(sel, QItemSelectionModel::Select);
         }
 
         supportedActions = Qt::MoveAction;
 
         {
             QModelIndexList indexes = selectedIndexes();
             for(int i = indexes.count() - 1 ; i >= 0; --i) {
                 if (!isIndexDragEnabled(m_d->model, indexes.at(i)))
                     indexes.removeAt(i);
             }
 
             selectionModel()->clear();
 
             if (indexes.count() > 0) {
                 QMimeData *data = m_d->model->mimeData(indexes);
                 if (!data)
                     return;
                 QRect rect;
                 QPixmap pixmap = m_d->renderToPixmap(indexes, &rect);
                 rect.adjust(horizontalOffset(), verticalOffset(), 0, 0);
                 QDrag *drag = new QDrag(this);
                 drag->setPixmap(pixmap);
                 drag->setMimeData(data);
                 drag->setHotSpot(m_d->lastPressedPosition - rect.topLeft());
                 drag->exec(supportedActions, Qt::MoveAction);
                 setCurrentIndex(currentIndex());
             }
         }
     } else {
 
         /**
          * Workaround for Qt5's bug: if we start a dragging action right during
          * Shift-selection, Qt will get crazy. We cannot workaround it easily,
          * because we would need to fork mouseMoveEvent() for that (where the
          * decision about drag state is done). So we just abort dragging in that
          * case.
          *
          * BUG:373067
          */
         if (m_d->lastPressedModifier & Qt::ShiftModifier) {
             return;
         }
 
         /**
          * Workaround for Qt5's bugs:
          *
          * 1) Qt doesn't treat selection the selection on D&D
          *    correctly, so we save it in advance and restore
          *    afterwards.
          *
          * 2) There is a private variable in QAbstractItemView:
          *    QAbstractItemView::Private::currentSelectionStartIndex.
          *    It is initialized *only* when the setCurrentIndex() is called
          *    explicitly on the view object, not on the selection model.
          *    Therefore we should explicitly call setCurrentIndex() after
          *    D&D, even if it already has *correct* value!
          *
          * 2) We should also call selectionModel()->select()
          *    explicitly.  There are two reasons for it: 1) Qt doesn't
          *    maintain selection over D&D; 2) when reselecting single
          *    element after D&D, Qt goes crazy, because it tries to
          *    read *global* keyboard modifiers. Therefore if we are
          *    dragging with Shift or Ctrl pressed it'll get crazy. So
          *    just reset it explicitly.
          */
 
         QModelIndexList selectionBefore = selectionModel()->selectedIndexes();
         QModelIndex currentBefore = selectionModel()->currentIndex();
 
         // initialize a global status variable
         m_d->dragWasSuccessful = false;
         QAbstractItemView::startDrag(supportedActions);
 
         QModelIndex newCurrent;
         QPoint selectionOffset;
 
         if (m_d->dragWasSuccessful) {
             newCurrent = currentIndex();
             selectionOffset = QPoint(newCurrent.column() - currentBefore.column(),
                                      newCurrent.row() - currentBefore.row());
         } else {
             newCurrent = currentBefore;
             selectionOffset = QPoint();
         }
 
         setCurrentIndex(newCurrent);
         selectionModel()->clearSelection();
         Q_FOREACH (const QModelIndex &idx, selectionBefore) {
             QModelIndex newIndex =
                     model()->index(idx.row() + selectionOffset.y(),
                                    idx.column() + selectionOffset.x());
             selectionModel()->select(newIndex, QItemSelectionModel::Select);
         }
     }
 }
 
 void TimelineFramesView::dragEnterEvent(QDragEnterEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragEnterEvent(event);
 }
 
 void TimelineFramesView::dragMoveEvent(QDragMoveEvent *event)
 {
     m_d->dragInProgress = true;
     m_d->model->setScrubState(true);
 
     QTableView::dragMoveEvent(event);
 
     if (event->isAccepted()) {
         QModelIndex index = indexAt(event->pos());
         if (!m_d->model->canDropFrameData(event->mimeData(), index)) {
             event->ignore();
         } else {
             selectionModel()->setCurrentIndex(index, QItemSelectionModel::NoUpdate);
         }
     }
 }
 
 void TimelineFramesView::dropEvent(QDropEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dropEvent(event);
     m_d->dragWasSuccessful = event->isAccepted();
 }
 
 void TimelineFramesView::dragLeaveEvent(QDragLeaveEvent *event)
 {
     m_d->dragInProgress = false;
     m_d->model->setScrubState(false);
 
     QAbstractItemView::dragLeaveEvent(event);
 }
 
 void TimelineFramesView::createFrameEditingMenuActions(QMenu *menu, bool addFrameCreationActions)
 {
     slotUpdateFrameActions();
 
     // calculate if selection range is set. This will determine if the update playback range is available
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     bool selectionExists = minColumn != maxColumn;
 
 
     if (selectionExists) {
             KisActionManager::safePopulateMenu(menu, "update_playback_range", m_d->actionMan);
     } else {
         KisActionManager::safePopulateMenu(menu, "set_start_time", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "set_end_time", m_d->actionMan);
     }
     menu->addSeparator();
 
 
     KisActionManager::safePopulateMenu(menu, "cut_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "copy_frames_to_clipboard", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "paste_frames_from_clipboard", m_d->actionMan);
 
     menu->addSeparator();
     QMenu *frames = menu->addMenu(i18nc("@item:inmenu", "Keyframes"));
     KisActionManager::safePopulateMenu(frames, "insert_keyframes_right", m_d->actionMan);
     KisActionManager::safePopulateMenu(frames, "insert_keyframes_left", m_d->actionMan);
 
     frames->addSeparator();
     KisActionManager::safePopulateMenu(frames, "insert_n_keyframes_right", m_d->actionMan);
     KisActionManager::safePopulateMenu(frames, "insert_n_keyframes_left", m_d->actionMan);
 
     QMenu *hold = menu->addMenu(i18nc("@item:inmenu", "Hold Frames"));
     KisActionManager::safePopulateMenu(hold, "insert_hold_frame", m_d->actionMan);
     KisActionManager::safePopulateMenu(hold, "remove_hold_frame", m_d->actionMan);
 
     hold->addSeparator();
     KisActionManager::safePopulateMenu(hold, "insert_n_hold_frames", m_d->actionMan);
     KisActionManager::safePopulateMenu(hold, "remove_n_hold_frames", m_d->actionMan);
 
     menu->addSeparator();
     KisActionManager::safePopulateMenu(menu, "remove_frames", m_d->actionMan);
     KisActionManager::safePopulateMenu(menu, "remove_frames_and_pull", m_d->actionMan);
 
     menu->addSeparator();
     if (addFrameCreationActions) {
         KisActionManager::safePopulateMenu(menu, "add_blank_frame", m_d->actionMan);
         KisActionManager::safePopulateMenu(menu, "add_duplicate_frame", m_d->actionMan);
         menu->addSeparator();
     }
-
 }
 
 void TimelineFramesView::mousePressEvent(QMouseEvent *event)
 {
     QPersistentModelIndex index = indexAt(event->pos());
 
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (event->button() == Qt::RightButton) {
             // TODO: try calculate index under mouse cursor even when
             //       it is outside any visible row
             qreal staticPoint = index.isValid() ? index.column() : currentIndex().column();
             m_d->zoomDragButton->beginZoom(event->pos(), staticPoint);
         } else if (event->button() == Qt::LeftButton) {
             m_d->initialDragPanPos = event->pos();
             m_d->initialDragPanValue =
                     QPoint(horizontalScrollBar()->value(),
                            verticalScrollBar()->value());
         }
         event->accept();
 
     } else if (event->button() == Qt::RightButton) {
 
         int numSelectedItems = selectionModel()->selectedIndexes().size();
 
         if (index.isValid() &&
                 numSelectedItems <= 1 &&
                 m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
             model()->setData(index, true, TimelineFramesModel::ActiveLayerRole);
             model()->setData(index, true, TimelineFramesModel::ActiveFrameRole);
             setCurrentIndex(index);
 
             if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool() ||
                     model()->data(index, TimelineFramesModel::SpecialKeyframeExists).toBool()) {
 
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
                     QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                     int labelIndex = colorLabel.isValid() ? colorLabel.toInt() : 0;
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, false);
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
 
             } else {
                 {
                     KisSignalsBlocker b(m_d->colorSelector);
                     KisImageConfig cfg;
                     const int labelIndex = cfg.defaultFrameColorLabel();
                     m_d->colorSelector->setCurrentIndex(labelIndex);
                 }
 
                 QMenu menu;
                 createFrameEditingMenuActions(&menu, true);
 
                 menu.addSeparator();
                 menu.addAction(m_d->colorSelectorAction);
                 menu.exec(event->globalPos());
             }
         } else if (numSelectedItems > 1) {
             int labelIndex = -1;
             bool haveFrames = false;
             Q_FOREACH(QModelIndex index, selectedIndexes()) {
                 haveFrames |= index.data(TimelineFramesModel::FrameExistsRole).toBool();
                 QVariant colorLabel = index.data(TimelineFramesModel::FrameColorLabelIndexRole);
                 if (colorLabel.isValid()) {
                     if (labelIndex == -1) {
                         // First label
                         labelIndex = colorLabel.toInt();
                     } else if (labelIndex != colorLabel.toInt()) {
                         // Mixed colors in selection
                         labelIndex = -1;
                         break;
                     }
                 }
             }
 
             if (haveFrames) {
                 KisSignalsBlocker b(m_d->multiframeColorSelector);
                 m_d->multiframeColorSelector->setCurrentIndex(labelIndex);
             }
 
             QMenu menu;
             createFrameEditingMenuActions(&menu, false);
             menu.addSeparator();
             KisActionManager::safePopulateMenu(&menu, "mirror_frames", m_d->actionMan);
             menu.addSeparator();
             menu.addAction(m_d->multiframeColorSelectorAction);
             menu.exec(event->globalPos());
         }
     } else if (event->button() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(event->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, event->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         event->accept();
     } else {
         if (index.isValid()) {
             m_d->model->setLastClickedIndex(index);
         }
 
         m_d->lastPressedPosition =
                 QPoint(horizontalOffset(), verticalOffset()) + event->pos();
         m_d->lastPressedModifier = event->modifiers();
 
         QAbstractItemView::mousePressEvent(event);
     }
 }
 
 void TimelineFramesView::mouseMoveEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
 
         if (e->buttons() & Qt::RightButton) {
             m_d->zoomDragButton->continueZoom(e->pos());
         } else if (e->buttons() & Qt::LeftButton) {
             QPoint diff = e->pos() - m_d->initialDragPanPos;
             QPoint offset = QPoint(m_d->initialDragPanValue.x() - diff.x(),
                                    m_d->initialDragPanValue.y() - diff.y());
 
             const int height = m_d->layersHeader->defaultSectionSize();
 
             horizontalScrollBar()->setValue(offset.x());
             verticalScrollBar()->setValue(offset.y() / height);
         }
         e->accept();
     } else if (e->buttons() == Qt::MidButton) {
         QModelIndex index = model()->buddy(indexAt(e->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, e->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
         }
         e->accept();
     } else {
         m_d->model->setScrubState(true);
         QTableView::mouseMoveEvent(e);
     }
 }
 
 void TimelineFramesView::mouseReleaseEvent(QMouseEvent *e)
 {
     if (m_d->modifiersCatcher->modifierPressed("pan-zoom")) {
         e->accept();
     } else {
         m_d->model->setScrubState(false);
         QTableView::mouseReleaseEvent(e);
     }
 }
 
 void TimelineFramesView::wheelEvent(QWheelEvent *e)
 {
     QModelIndex index = currentIndex();
     int column= -1;
 
     if (index.isValid()) {
         column= index.column() + ((e->delta() > 0) ? 1 : -1);
     }
 
     if (column >= 0 && !m_d->dragInProgress) {
         setCurrentIndex(m_d->model->index(index.row(), column));
     }
 }
 
 void TimelineFramesView::slotUpdateLayersMenu()
 {
     QAction *action = 0;
 
     m_d->existingLayersMenu->clear();
 
     QVariant value = model()->headerData(0, Qt::Vertical, TimelineFramesModel::OtherLayersRole);
     if (value.isValid()) {
         TimelineFramesModel::OtherLayersList list = value.value<TimelineFramesModel::OtherLayersList>();
 
         int i = 0;
         Q_FOREACH (const TimelineFramesModel::OtherLayer &l, list) {
             action = m_d->existingLayersMenu->addAction(l.name);
             action->setData(i++);
         }
     }
 }
 
 void TimelineFramesView::slotUpdateFrameActions()
 {
     if (!m_d->actionMan) return;
 
     const QModelIndexList editableIndexes = calculateSelectionSpan(false, true);
     const bool hasEditableFrames = !editableIndexes.isEmpty();
 
     bool hasExistingFrames = false;
     Q_FOREACH (const QModelIndex &index, editableIndexes) {
         if (model()->data(index, TimelineFramesModel::FrameExistsRole).toBool()) {
             hasExistingFrames = true;
             break;
         }
     }
 
     auto enableAction = [this] (const QString &id, bool value) {
         KisAction *action = m_d->actionMan->actionByName(id);
         KIS_SAFE_ASSERT_RECOVER_RETURN(action);
         action->setEnabled(value);
     };
 
     enableAction("add_blank_frame", hasEditableFrames);
     enableAction("add_duplicate_frame", hasEditableFrames);
 
     enableAction("insert_keyframes_right", hasEditableFrames);
     enableAction("insert_n_keyframes_right", hasEditableFrames);
 
     enableAction("insert_keyframes_left", hasEditableFrames);
     enableAction("insert_n_keyframes_left", hasEditableFrames);
 
     enableAction("remove_frames", hasEditableFrames && hasExistingFrames);
     enableAction("remove_frames_and_pull", hasEditableFrames);
 
     enableAction("insert_hold_frame", hasEditableFrames);
     enableAction("insert_n_hold_frames", hasEditableFrames);
 
     enableAction("remove_hold_frame", hasEditableFrames);
     enableAction("remove_n_hold_frames", hasEditableFrames);
 
     enableAction("mirror_frames", hasEditableFrames && editableIndexes.size() > 1);
 
     enableAction("copy_frames_to_clipboard", true);
     enableAction("cut_frames_to_clipboard", hasEditableFrames);
 
     QClipboard *cp = QApplication::clipboard();
     const QMimeData *data = cp->mimeData();
 
     enableAction("paste_frames_from_clipboard", data && data->hasFormat("application/x-krita-frame"));
 
     //TODO: update column actions!
 }
 
 void TimelineFramesView::slotSetStartTimeToCurrentPosition()
 {
      m_d->model->setFullClipRangeStart(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotSetEndTimeToCurrentPosition()
 {
     m_d->model->setFullClipRangeEnd(this->currentIndex().column());
 }
 
 void TimelineFramesView::slotUpdatePlackbackRange()
 {
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     m_d->model->setFullClipRangeStart(minColumn);
     m_d->model->setFullClipRangeEnd(maxColumn);
 }
 
 void TimelineFramesView::slotLayerContextMenuRequested(const QPoint &globalPos)
 {
     m_d->layerEditingMenu->exec(globalPos);
 }
 
 void TimelineFramesView::slotAddNewLayer()
 {
     QModelIndex index = currentIndex();
     const int newRow = index.isValid() ? index.row() : 0;
     model()->insertRow(newRow);
 }
 
 void TimelineFramesView::slotAddExistingLayer(QAction *action)
 {
     QVariant value = action->data();
 
     if (value.isValid()) {
         QModelIndex index = currentIndex();
         const int newRow = index.isValid() ? index.row() + 1 : 0;
 
         m_d->model->insertOtherLayer(value.toInt(), newRow);
     }
 }
 
 void TimelineFramesView::slotRemoveLayer()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid()) return;
 
     model()->removeRow(index.row());
 }
 
 void TimelineFramesView::slotNewFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->createFrame(index);
 }
 
 void TimelineFramesView::slotCopyFrame()
 {
     QModelIndex index = currentIndex();
     if (!index.isValid() ||
         !m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
 
         return;
     }
 
     m_d->model->copyFrame(index);
 }
 
 void TimelineFramesView::calculateSelectionMetrics(int &minColumn, int &maxColumn, QSet<int> &rows) const
 {
     minColumn = std::numeric_limits<int>::max();
     maxColumn = std::numeric_limits<int>::min();
 
     Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
         if (!m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
         rows.insert(index.row());
         minColumn = qMin(minColumn, index.column());
         maxColumn = qMax(maxColumn, index.column());
     }
 }
 
-void TimelineFramesView::insertFramesImpl(int insertAtColumn, int count, QSet<int> rows, bool forceEntireColumn)
+void TimelineFramesView::insertFramesImpl(int insertAtColumn, int count, int timing, QSet<int> rows, bool forceEntireColumn)
 {
     if (forceEntireColumn) {
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (!m_d->model->data(m_d->model->index(i, insertAtColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
             rows.insert(i);
         }
     }
 
     if (!rows.isEmpty()) {
-        m_d->model->insertFrames(insertAtColumn, rows.toList(), count);
+        m_d->model->insertFrames(insertAtColumn, rows.toList(), count, timing);
     }
 }
 
-void TimelineFramesView::slotInsertKeyframesLeft(int count, bool forceEntireColumn)
+void TimelineFramesView::slotInsertKeyframesLeft(int count, int timing, bool forceEntireColumn)
 {
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     if (count <= 0) {
         count = qMax(1, maxColumn - minColumn + 1);
     }
 
-    insertFramesImpl(minColumn, count, rows, forceEntireColumn);
+    insertFramesImpl(minColumn, count, timing, rows, forceEntireColumn);
 }
 
-void TimelineFramesView::slotInsertKeyframesRight(int count, bool forceEntireColumn)
+void TimelineFramesView::slotInsertKeyframesRight(int count, int timing, bool forceEntireColumn)
 {
     QSet<int> rows;
     int minColumn = 0;
     int maxColumn = 0;
 
     calculateSelectionMetrics(minColumn, maxColumn, rows);
 
     if (count <= 0) {
         count = qMax(1, maxColumn - minColumn + 1);
     }
 
-    insertFramesImpl(maxColumn + 1, count, rows, forceEntireColumn);
+    insertFramesImpl(maxColumn + 1, count, timing, rows, forceEntireColumn);
 }
 
-void TimelineFramesView::slotInsertColumnsLeft(int count)
+void TimelineFramesView::slotInsertColumnsLeft(int count, int timing)
 {
-    slotInsertKeyframesLeft(count, true);
+    slotInsertKeyframesLeft(count, timing, true);
 }
 
-void TimelineFramesView::slotInsertColumnsRight(int count)
+void TimelineFramesView::slotInsertColumnsRight(int count, int timing)
 {
-    slotInsertKeyframesRight(count, true);
+    slotInsertKeyframesRight(count, timing, true);
 }
 
 void TimelineFramesView::slotInsertKeyframesLeftCustom()
 {
-    bool ok = false;
-    const int count = QInputDialog::getInt(this,
-                                           i18nc("@title:window", "Insert left"),
-                                           i18nc("@label:spinbox", "Enter number of frames"),
-                                           defaultNumberOfFramesToAdd(),
-                                           1, 10000, 1, &ok);
+    int count, timing;
 
-    if (ok) {
-        setDefaultNumberOfFramesToAdd(count);
-        slotInsertKeyframesLeft(count);
+    if (m_d->insertKeyframeDialog->promptUserSettings(count, timing)) {
+        slotInsertKeyframesLeft(count, timing, false);
     }
 }
 
-
 void TimelineFramesView::slotInsertKeyframesRightCustom()
 {
-    bool ok = false;
-    const int count = QInputDialog::getInt(this,
-                                           i18nc("@title:window", "Insert right"),
-                                           i18nc("@label:spinbox", "Enter number of frames"),
-                                           defaultNumberOfFramesToAdd(),
-                                           1, 10000, 1, &ok);
+    int count, timing;
 
-    if (ok) {
-        setDefaultNumberOfFramesToAdd(count);
-        slotInsertKeyframesRight(count);
+    if (m_d->insertKeyframeDialog->promptUserSettings(count, timing)) {
+        slotInsertKeyframesRight(count, timing, false);
     }
 }
 
 void TimelineFramesView::slotInsertColumnsLeftCustom()
 {
-    bool ok = false;
-    const int count = QInputDialog::getInt(this,
-                                           i18nc("@title:window", "Insert left"),
-                                           i18nc("@label:spinbox", "Enter number of columns"),
-                                           defaultNumberOfColumnsToAdd(),
-                                           1, 10000, 1, &ok);
+    int count, timing;
 
-    if (ok) {
-        setDefaultNumberOfColumnsToAdd(count);
-        slotInsertColumnsLeft(count);
+    if (m_d->insertKeyframeDialog->promptUserSettings(count, timing)) {
+        slotInsertColumnsLeft(count, timing);
     }
 }
 
-
 void TimelineFramesView::slotInsertColumnsRightCustom()
 {
-    bool ok = false;
-    const int count = QInputDialog::getInt(this,
-                                           i18nc("@title:window", "Insert right"),
-                                           i18nc("@label:spinbox", "Enter number of columns"),
-                                           defaultNumberOfColumnsToAdd(),
-                                           1, 10000, 1, &ok);
+    int count, timing;
 
-    if (ok) {
-        setDefaultNumberOfColumnsToAdd(count);
-        slotInsertColumnsRight(count);
+    if (m_d->insertKeyframeDialog->promptUserSettings(count, timing)) {
+        slotInsertColumnsRight(count, timing);
     }
 }
 
 QModelIndexList TimelineFramesView::calculateSelectionSpan(bool forceEntireColumn, bool editableOnly) const
 {
     QModelIndexList indexes;
 
     if (forceEntireColumn) {
         QSet<int> rows;
         int minColumn = 0;
         int maxColumn = 0;
 
         calculateSelectionMetrics(minColumn, maxColumn, rows);
 
         rows.clear();
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             if (editableOnly &&
                 !m_d->model->data(m_d->model->index(i, minColumn), TimelineFramesModel::FrameEditableRole).toBool()) continue;
 
             for (int column = minColumn; column <= maxColumn; column++) {
                 indexes << m_d->model->index(i, column);
             }
         }
     } else {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (!editableOnly || m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     return indexes;
 }
 
 void TimelineFramesView::slotRemoveFrame(bool forceEntireColumn, bool needsOffset)
 {
     const QModelIndexList indexes = calculateSelectionSpan(forceEntireColumn);
 
     if (!indexes.isEmpty()) {
         if (needsOffset) {
             m_d->model->removeFramesAndOffset(indexes);
         } else {
             m_d->model->removeFrames(indexes);
         }
     }
 }
 
 void TimelineFramesView::slotRemoveColumns()
 {
     slotRemoveFrame(true);
 }
 
 void TimelineFramesView::slotRemoveFramesAndShift(bool forceEntireColumn)
 {
     slotRemoveFrame(forceEntireColumn, true);
 }
 
 void TimelineFramesView::slotRemoveColumnsAndShift()
 {
     slotRemoveFramesAndShift(true);
 }
 
 void TimelineFramesView::slotInsertHoldFrames(int count, bool forceEntireColumn)
 {
     QModelIndexList indexes;
 
     if (!forceEntireColumn) {
         Q_FOREACH (const QModelIndex &index, selectionModel()->selectedIndexes()) {
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     } else {
         const int column = selectionModel()->currentIndex().column();
 
         for (int i = 0; i < m_d->model->rowCount(); i++) {
             const QModelIndex index = m_d->model->index(i, column);
             if (m_d->model->data(index, TimelineFramesModel::FrameEditableRole).toBool()) {
                 indexes << index;
             }
         }
     }
 
     if (!indexes.isEmpty()) {
         m_d->model->insertHoldFrames(indexes, count);
     }
 }
 
 void TimelineFramesView::slotRemoveHoldFrames(int count, bool forceEntireColumn)
 {
     slotInsertHoldFrames(-count, forceEntireColumn);
 }
 
 void TimelineFramesView::slotInsertHoldFramesCustom()
 {
     bool ok = false;
     const int count = QInputDialog::getInt(this,
                                            i18nc("@title:window", "Insert hold frames"),
                                            i18nc("@label:spinbox", "Enter number of frames"),
                                            defaultNumberOfFramesToAdd(),
                                            1, 10000, 1, &ok);
 
     if (ok) {
         setDefaultNumberOfFramesToAdd(count);
         slotInsertHoldFrames(count);
     }
 }
 
 void TimelineFramesView::slotRemoveHoldFramesCustom()
 {
     bool ok = false;
     const int count = QInputDialog::getInt(this,
                                            i18nc("@title:window", "Remove hold frames"),
                                            i18nc("@label:spinbox", "Enter number of frames"),
                                            defaultNumberOfFramesToRemove(),
                                            1, 10000, 1, &ok);
 
     if (ok) {
         setDefaultNumberOfFramesToRemove(count);
         slotRemoveHoldFrames(count);
     }
 }
 
 void TimelineFramesView::slotInsertHoldColumns(int count)
 {
     slotInsertHoldFrames(count, true);
 }
 
 void TimelineFramesView::slotRemoveHoldColumns(int count)
 {
     slotRemoveHoldFrames(count, true);
 }
 
 void TimelineFramesView::slotInsertHoldColumnsCustom()
 {
     bool ok = false;
     const int count = QInputDialog::getInt(this,
                                            i18nc("@title:window", "Insert hold columns"),
                                            i18nc("@label:spinbox", "Enter number of columns"),
                                            defaultNumberOfColumnsToAdd(),
                                            1, 10000, 1, &ok);
 
     if (ok) {
         setDefaultNumberOfColumnsToAdd(count);
         slotInsertHoldColumns(count);
     }
 }
 
 void TimelineFramesView::slotRemoveHoldColumnsCustom()
 {
     bool ok = false;
     const int count = QInputDialog::getInt(this,
                                            i18nc("@title:window", "Remove hold columns"),
                                            i18nc("@label:spinbox", "Enter number of columns"),
                                            defaultNumberOfColumnsToRemove(),
                                            1, 10000, 1, &ok);
 
     if (ok) {
         setDefaultNumberOfColumnsToRemove(count);
         slotRemoveHoldColumns(count);
     }
 }
 
 void TimelineFramesView::slotMirrorFrames(bool forceEntireColumn)
 {
     const QModelIndexList indexes = calculateSelectionSpan(forceEntireColumn);
 
     if (!indexes.isEmpty()) {
         m_d->model->mirrorFrames(indexes);
     }
 }
 
 void TimelineFramesView::slotMirrorColumns()
 {
     slotMirrorFrames(true);
 }
 
 void TimelineFramesView::cutCopyImpl(bool forceEntireColumn, bool copy)
 {
     const QModelIndexList indexes = calculateSelectionSpan(forceEntireColumn, !copy);
     if (indexes.isEmpty()) return;
 
     int minColumn = std::numeric_limits<int>::max();
     int minRow = std::numeric_limits<int>::max();
 
     Q_FOREACH (const QModelIndex &index, indexes) {
         minRow = qMin(minRow, index.row());
         minColumn = qMin(minColumn, index.column());
     }
 
     const QModelIndex baseIndex = m_d->model->index(minRow, minColumn);
 
     QMimeData *data = m_d->model->mimeDataExtended(indexes,
                                                    baseIndex,
                                                    copy ?
                                                        TimelineFramesModel::CopyFramesPolicy :
                                                        TimelineFramesModel::MoveFramesPolicy);
     if (data) {
         QClipboard *cb = QApplication::clipboard();
         cb->setMimeData(data);
     }
 }
 
 void TimelineFramesView::slotCopyFrames(bool forceEntireColumn)
 {
     cutCopyImpl(forceEntireColumn, true);
 }
 
 void TimelineFramesView::slotCutFrames(bool forceEntireColumn)
 {
     cutCopyImpl(forceEntireColumn, false);
 }
 
 void TimelineFramesView::slotPasteFrames(bool forceEntireColumn)
 {
     const QModelIndex currentIndex =
         !forceEntireColumn ? this->currentIndex() : m_d->model->index(0, this->currentIndex().column());
 
     if (!currentIndex.isValid()) return;
 
     QClipboard *cb = QApplication::clipboard();
     const QMimeData *data = cb->mimeData();
 
     if (data && data->hasFormat("application/x-krita-frame")) {
 
         bool dataMoved = false;
         bool result = m_d->model->dropMimeDataExtended(data, Qt::MoveAction, currentIndex, &dataMoved);
 
         if (result && dataMoved) {
             cb->clear();
         }
     }
 }
 
 void TimelineFramesView::slotCutColumns()
 {
     slotCutFrames(true);
 }
 
 void TimelineFramesView::slotPasteColumns()
 {
     slotPasteFrames(true);
 }
 
 void TimelineFramesView::slotCopyColumns()
 {
     slotCopyFrames(true);
 }
 
 int TimelineFramesView::defaultNumberOfFramesToAdd() const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     return cfg.readEntry("defaultNumberOfFramesToAdd", 1);
 }
 
 void TimelineFramesView::setDefaultNumberOfFramesToAdd(int value) const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     cfg.writeEntry("defaultNumberOfFramesToAdd", value);
 }
 
 int TimelineFramesView::defaultNumberOfColumnsToAdd() const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     return cfg.readEntry("defaultNumberOfColumnsToAdd", 1);
 }
 
 void TimelineFramesView::setDefaultNumberOfColumnsToAdd(int value) const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     cfg.writeEntry("defaultNumberOfColumnsToAdd", value);
 }
 
 int TimelineFramesView::defaultNumberOfFramesToRemove() const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     return cfg.readEntry("defaultNumberOfFramesToRemove", 1);
 }
 
 void TimelineFramesView::setDefaultNumberOfFramesToRemove(int value) const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     cfg.writeEntry("defaultNumberOfFramesToRemove", value);
 }
 
 int TimelineFramesView::defaultNumberOfColumnsToRemove() const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     return cfg.readEntry("defaultNumberOfColumnsToRemove", 1);
 }
 
 void TimelineFramesView::setDefaultNumberOfColumnsToRemove(int value) const
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("FrameActionsDefaultValues");
     cfg.writeEntry("defaultNumberOfColumnsToRemove", value);
 }
 
 bool TimelineFramesView::viewportEvent(QEvent *event)
 {
     if (event->type() == QEvent::ToolTip && model()) {
         QHelpEvent *he = static_cast<QHelpEvent *>(event);
         QModelIndex index = model()->buddy(indexAt(he->pos()));
         if (index.isValid()) {
             QStyleOptionViewItem option = viewOptions();
             option.rect = visualRect(index);
             // The offset of the headers is needed to get the correct position inside the view.
             m_d->tip.showTip(this, he->pos() + QPoint(verticalHeader()->width(), horizontalHeader()->height()), option, index);
             return true;
         }
     }
 
     return QTableView::viewportEvent(event);
 }
diff --git a/plugins/dockers/animation/timeline_frames_view.h b/plugins/dockers/animation/timeline_frames_view.h
index d099160cf5..c3aa6ef132 100644
--- a/plugins/dockers/animation/timeline_frames_view.h
+++ b/plugins/dockers/animation/timeline_frames_view.h
@@ -1,176 +1,174 @@
 /*
  *  Copyright (c) 2015 Dmitry Kazakov <dimula73@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 __TIMELINE_FRAMES_VIEW_H
 #define __TIMELINE_FRAMES_VIEW_H
 
 #include <QScopedPointer>
 #include <QTableView>
 #include "kis_action_manager.h"
 #include "kritaanimationdocker_export.h"
 
 class KisAction;
 class TimelineWidget;
 
-
 class KRITAANIMATIONDOCKER_EXPORT TimelineFramesView : public QTableView
 {
     Q_OBJECT
 public:
     TimelineFramesView(QWidget *parent);
     ~TimelineFramesView() override;
 
     void setModel(QAbstractItemModel *model) override;
 
     void updateGeometries() override;
 
     void setShowInTimeline(KisAction *action);
 
     void setActionManager( KisActionManager * actionManager);
 
 public Q_SLOTS:
     void slotSelectionChanged();
     void slotUpdateIcons();
 
 private Q_SLOTS:
     void slotUpdateLayersMenu();
     void slotUpdateFrameActions();
 
     void slotSetStartTimeToCurrentPosition();
     void slotSetEndTimeToCurrentPosition();
     void slotUpdatePlackbackRange();
 
+    // Layer
     void slotAddNewLayer();
     void slotAddExistingLayer(QAction *action);
     void slotDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
-
     void slotRemoveLayer();
-
     void slotLayerContextMenuRequested(const QPoint &globalPos);
 
+    // New, Copy, Insert and Remove Frames
     void slotNewFrame();
     void slotCopyFrame();
 
-
-    void slotInsertKeyframesLeft(int count = -1, bool forceEntireColumn = false);
-    void slotInsertKeyframesRight(int count = -1, bool forceEntireColumn = false);
+    void slotInsertKeyframesLeft(int count = 1, int timing = 1, bool forceEntireColumn = false);
+    void slotInsertKeyframesRight(int count = 1, int timing = 1, bool forceEntireColumn = false);
 
     void slotInsertKeyframesLeftCustom();
     void slotInsertKeyframesRightCustom();
 
     void slotRemoveFrame(bool forceEntireColumn = false, bool needsOffset = false);
     void slotRemoveFramesAndShift(bool forceEntireColumn = false);
 
-    void slotInsertColumnsLeft(int count = -1);
+    void slotInsertColumnsLeft(int count = 1, int timing = 1);
     void slotInsertColumnsLeftCustom();
 
-    void slotInsertColumnsRight(int count = -1);
+    void slotInsertColumnsRight(int count = 1, int timing = 1);
     void slotInsertColumnsRightCustom();
 
     void slotRemoveColumns();
     void slotRemoveColumnsAndShift();
 
     void slotInsertHoldFrames(int count = 1, bool forceEntireColumn = false);
     void slotRemoveHoldFrames(int count = 1, bool forceEntireColumn = false);
 
     void slotInsertHoldFramesCustom();
     void slotRemoveHoldFramesCustom();
 
     void slotInsertHoldColumns(int count = 1);
     void slotRemoveHoldColumns(int count = 1);
 
     void slotInsertHoldColumnsCustom();
     void slotRemoveHoldColumnsCustom();
 
     void slotMirrorFrames(bool forceEntireColumn = false);
     void slotMirrorColumns();
 
-
+    // Copy-paste
     void slotCopyFrames(bool forceEntireColumn = false);
     void slotCutFrames(bool forceEntireColumn = false);
     void slotPasteFrames(bool forceEntireColumn = false);
 
     void slotCopyColumns();
     void slotCutColumns();
     void slotPasteColumns();
 
     void slotReselectCurrentIndex();
 
     void slotUpdateInfiniteFramesCount();
 
     void slotHeaderDataChanged(Qt::Orientation orientation, int first, int last);
 
     void slotZoomButtonPressed(qreal staticPoint);
     void slotZoomButtonChanged(qreal value);
 
     void slotColorLabelChanged(int);
     void slotEnsureRowVisible(int row);
 
-
+    // Audio
     void slotSelectAudioChannelFile();
     void slotAudioChannelMute(bool value);
     void slotAudioChannelRemove();
     void slotUpdateAudioActions();
     void slotAudioVolumeChanged(int value);
 
 private:
     void setFramesPerSecond(int fps);
     void calculateSelectionMetrics(int &minColumn, int &maxColumn, QSet<int> &rows) const;
 
-    void insertFramesImpl(int insertAtColumn, int count, QSet<int> rows, bool forceEntireColumn);
+    void insertFramesImpl(int insertAtColumn, int count, int timing, QSet<int> rows, bool forceEntireColumn);
 
     void createFrameEditingMenuActions(QMenu *menu, bool addFrameCreationActions);
 
     QModelIndexList calculateSelectionSpan(bool forceEntireColumn, bool editableOnly = true) const;
     void cutCopyImpl(bool forceEntireColumn, bool copy);
 
     int defaultNumberOfFramesToAdd() const;
     void setDefaultNumberOfFramesToAdd(int value) const;
 
     int defaultNumberOfColumnsToAdd() const;
     void setDefaultNumberOfColumnsToAdd(int value) const;
 
     int defaultNumberOfFramesToRemove() const;
     void setDefaultNumberOfFramesToRemove(int value) const;
 
     int defaultNumberOfColumnsToRemove() const;
     void setDefaultNumberOfColumnsToRemove(int value) const;
 
 protected:
     QItemSelectionModel::SelectionFlags selectionCommand(const QModelIndex &index,
                                                          const QEvent *event) const override;
 
     void currentChanged(const QModelIndex &current, const QModelIndex &previous) override;
     void startDrag(Qt::DropActions supportedActions) override;
     void dragEnterEvent(QDragEnterEvent *event) override;
     void dragMoveEvent(QDragMoveEvent *event) override;
     void dropEvent(QDropEvent *event) override;
     void dragLeaveEvent(QDragLeaveEvent *event) override;
     void mousePressEvent(QMouseEvent *event) override;
     void mouseMoveEvent(QMouseEvent *e) override;
     void mouseReleaseEvent(QMouseEvent *e) override;
     void wheelEvent(QWheelEvent *e) override;
     void rowsInserted(const QModelIndex& parent, int start, int end) override;
     bool viewportEvent(QEvent *event) override;
 
 private:
     struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 #endif /* __TIMELINE_FRAMES_VIEW_H */
diff --git a/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp b/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp
new file mode 100644
index 0000000000..a9cd66f4e4
--- /dev/null
+++ b/plugins/dockers/animation/timeline_insert_keyframe_dialog.cpp
@@ -0,0 +1,45 @@
+#include "timeline_insert_keyframe_dialog.h"
+
+#include <QLabel>
+#include <QSpinBox>
+#include <QDialogButtonBox>
+#include <QVBoxLayout>
+#include <QFormLayout>
+#include <klocalizedstring.h>
+
+TimelineInsertKeyframeDialog::TimelineInsertKeyframeDialog(QWidget *parent) :
+    QDialog(parent)
+{
+    setWindowTitle(i18nc("@title:window","Insert Keyframes"));
+    setModal(true);
+    setLayout(new QVBoxLayout(this));
+
+    frameCountSpinbox.setMinimum(1);
+    frameCountSpinbox.setValue(1);
+
+    frameTimingSpinbox.setMinimum(1);
+    frameTimingSpinbox.setValue(1);
+
+    QWidget *formsWidget = new QWidget();
+    QFormLayout *formLayout = new QFormLayout();
+    formsWidget->setLayout( formLayout );
+    layout()->addWidget(formsWidget);
+
+    QDialogButtonBox *buttonbox = new QDialogButtonBox(QDialogButtonBox::Cancel | QDialogButtonBox::Ok);
+    layout()->addWidget(buttonbox);
+
+    formLayout->addRow(QString(i18nc("@label:spinbox", "Number of frames:")), &frameCountSpinbox);
+    formLayout->addRow(QString(i18nc("@label:spinbox", "Frame timing:")), &frameTimingSpinbox);
+
+    connect(buttonbox, SIGNAL(accepted()), this, SLOT(accept()));
+    connect(buttonbox, SIGNAL(rejected()), this, SLOT(reject()));
+}
+
+bool TimelineInsertKeyframeDialog::promptUserSettings(int &out_count, int &out_timing){
+    if(exec() == QDialog::Accepted){
+        out_count = frameCountSpinbox.value();
+        out_timing = frameTimingSpinbox.value();
+        return true;
+    }
+    return false;
+}
diff --git a/plugins/dockers/animation/timeline_insert_keyframe_dialog.h b/plugins/dockers/animation/timeline_insert_keyframe_dialog.h
new file mode 100644
index 0000000000..c2ae5ee206
--- /dev/null
+++ b/plugins/dockers/animation/timeline_insert_keyframe_dialog.h
@@ -0,0 +1,20 @@
+#ifndef __TIMELINE_INSERT_KEYFRAME_DIALOG_H
+#define __TIMELINE_INSERT_KEYFRAME_DIALOG_H
+
+#include "kritaanimationdocker_export.h"
+#include <QDialog>
+#include <QSpinBox>
+
+class KRITAANIMATIONDOCKER_EXPORT TimelineInsertKeyframeDialog : QDialog {
+    Q_OBJECT
+private:
+    QSpinBox frameCountSpinbox;
+    QSpinBox frameTimingSpinbox;
+
+public:
+    TimelineInsertKeyframeDialog(QWidget *parent = 0);
+
+    bool promptUserSettings(int &count, int &timing);
+};
+
+#endif // __TIMELINE_INSERT_KEYFRAME_DIALOG_H