diff --git a/plugins/dockers/storyboarddocker/storyboardModel.cpp b/plugins/dockers/storyboarddocker/storyboardModel.cpp
index 2168a6557e..6e8df2a22c 100644
--- a/plugins/dockers/storyboarddocker/storyboardModel.cpp
+++ b/plugins/dockers/storyboarddocker/storyboardModel.cpp
@@ -1,420 +1,415 @@
 /*
  *  Copyright (c) 2020 Saurabh Kumar <saurabhk660@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 "storyboardModel.h"
 
 #include <QDebug>
 #include <QMimeData>
 
 #include <kis_icon.h>
 
 StoryboardModel::StoryboardModel(QObject *parent)
         : QAbstractItemModel(parent)
         , m_commentCount(0)
 {}
 
 QModelIndex StoryboardModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!hasIndex(row, column, parent))
         return QModelIndex();
-    if (row < 0 || row >= rowCount())
+    if (row < 0 || row >= rowCount(parent))
         return QModelIndex();
     if (column !=0)
         return QModelIndex();
     
     //1st level node has invalid parent
     if (!parent.isValid()){
         return createIndex(row, column, m_items.at(row));
     }
     else if (!parent.parent().isValid()){
         StoryboardItem *parentItem = static_cast<StoryboardItem*>(parent.internalPointer());
         StoryboardChild *childItem = parentItem->child(row);
         if (childItem)
             return createIndex(row, column, childItem);
     }
     return QModelIndex();
 }
 
 QModelIndex StoryboardModel::parent(const QModelIndex &index) const
 {
     if (!index.isValid())
         return QModelIndex();
 
     {
         //no parent for 1st level node
         StoryboardItem *childItem = static_cast<StoryboardItem*>(index.internalPointer());
         if (m_items.contains(childItem)){
             return QModelIndex();
         }
     }
 
     //return parent only for 2nd level nodes
     StoryboardChild *childItem = static_cast<StoryboardChild*>(index.internalPointer());
     StoryboardItem *parentItem = childItem->parent();
     int indexOfParent = m_items.indexOf(const_cast<StoryboardItem*>(parentItem));
     return createIndex(indexOfParent, 0, parentItem);
 }
 
 int StoryboardModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid())
         return m_items.count();
     else if (!parent.parent().isValid()){
         StoryboardItem *parentItem = static_cast<StoryboardItem*>(parent.internalPointer());
         return parentItem->childCount();
     }
     return 0;   //2nd level nodes have no child
 }
 
 int StoryboardModel::columnCount(const QModelIndex &parent) const
 {
    if (!parent.isValid()){
        return 1;
    }
    //1st level nodes have 1 column
    if (!parent.parent().isValid()){
        return 1;
    }
    //end level nodes have no child
    return 0;
 }
 
 QVariant StoryboardModel::data(const QModelIndex &index, int role) const
 {
 
     if (!index.isValid())
         return QVariant();
-    if (index.row() >= m_items.size())
-        return QVariant();
 
-    if(role == Qt::SizeHintRole){
-            return QSize(200,200);
-    }
     //return data only for the storyboardChild i.e. 2nd level nodes
     if (!index.parent().isValid()){
         return QVariant();
     }
 
     if (role == Qt::DisplayRole || role == Qt::EditRole || role == Qt::UserRole)
     {
         StoryboardChild *child = static_cast<StoryboardChild*>(index.internalPointer());
         if (index.row() > 3){
             if (role == Qt::UserRole){         //scroll bar position
                 CommentBox commentBox = qvariant_cast<CommentBox>(child->data());
                 return commentBox.scrollValue;
             }
             else {
                 CommentBox commentBox = qvariant_cast<CommentBox>(child->data());
                 return commentBox.content;
             }
         }
         return child->data();
     }
     return QVariant();
 }
 
 bool StoryboardModel::setData(const QModelIndex & index, const QVariant & value, int role)
 {
     if (index.isValid() && (role == Qt::EditRole || role == Qt::DisplayRole))
     {
         if (!index.parent().isValid())
         return false;
 
         StoryboardChild *child = static_cast<StoryboardChild*>(index.internalPointer());
         if (child){
             int fps = 24;
             if(index.row() == 3 && value.toInt() >= fps){         //TODO : set fps
                 QModelIndex secondIndex = index.siblingAtRow(2);
                 setData(secondIndex, secondIndex.data().toInt() + value.toInt() / fps, role);
                 child->setData(value.toInt() % fps);
             }
             else if (index.row() > 3){
                 CommentBox commentBox = qvariant_cast<CommentBox>(child->data());
                 commentBox.content = value.toString();
                 child->setData(QVariant::fromValue<CommentBox>(commentBox));
             }
             else {
                 child->setData(value);
             }
             emit dataChanged(index, index);
             return true;
         }
     }
     return false;
 }
 
 bool StoryboardModel::setCommentScrollData(const QModelIndex & index, const QVariant & value)
 {
     StoryboardChild *child = static_cast<StoryboardChild*>(index.internalPointer());
     if (child){
         CommentBox commentBox = qvariant_cast<CommentBox>(child->data());
         commentBox.scrollValue = value.toInt();
         child->setData(QVariant::fromValue<CommentBox>(commentBox));
         return true;
     }
     return false;
 }
 
 Qt::ItemFlags StoryboardModel::flags(const QModelIndex & index) const
 {
     if(!index.isValid())
         return Qt::ItemIsDropEnabled;
 
     //1st level nodes
     if (!index.parent().isValid())
         return Qt::ItemIsDragEnabled | Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 
     //2nd level nodes
     return Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren;
 }
 
 bool StoryboardModel::insertRows(int position, int rows, const QModelIndex &parent)
 {
     if (!parent.isValid()){
         beginInsertRows(QModelIndex(), position, position+rows-1);
         for (int row = 0; row < rows; ++row) {
             StoryboardItem *newItem = new StoryboardItem();
             m_items.insert(position, newItem);
         }
         endInsertRows();
         for (int row = 0; row < rows; ++row) {
             insertRows(rowCount(index(position + row, 0)), m_commentList.count(), index(position + row, 0));
         }
         return true;
     }
     else if (!parent.parent().isValid()){              //insert 2nd level nodes
         StoryboardItem *item = static_cast<StoryboardItem*>(parent.internalPointer());
         beginInsertRows(parent, position, position+rows-1);
         for (int row = 0; row < rows; ++row) {
             item->insertChild(position, QVariant());
         }
         endInsertRows();
         return true;
     }
     //we can't insert to 2nd level nodes as they are leaf nodes
     return false;
 }
 
 bool StoryboardModel::removeRows(int position, int rows, const QModelIndex &parent)
 {
     //remove 1st level nodes
     if (!parent.isValid()){
         beginRemoveRows(QModelIndex(), position, position+rows-1);
         for (int row = 0; row < rows; ++row){
             QModelIndex currentIndex = index(position, 0);
             removeRows(0, rowCount(currentIndex), currentIndex);
             delete m_items.at(position);
             m_items.removeAt(position);
         }
         endRemoveRows();
         return true;
     }
     else if (!parent.parent().isValid()){                     //remove 2nd level nodes
         StoryboardItem *item = static_cast<StoryboardItem*>(parent.internalPointer());
         if (m_items.contains(item)){
             beginRemoveRows(parent, position, position+rows-1);
             for (int row = 0; row < rows; ++row) {
                 item->removeChild(position);
             }
             endRemoveRows();
             return true;
         }
     }
     //2nd level node has no child
     return false;
 }
 
 bool StoryboardModel::moveRows(const QModelIndex &sourceParent, int sourceRow, int count,
                                 const QModelIndex &destinationParent, int destinationChild)
 {
     if (sourceParent != destinationParent){
         return false;
     }
     if (destinationChild == sourceRow || destinationChild == sourceRow + 1){
         return false;
     }
     if (destinationChild > sourceRow + count - 1){
         //we adjust for the upward shift, see qt doc for why this is needed
         beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1, destinationParent, destinationChild + count - 1);
         destinationChild = destinationChild - count;
     }
     else {
         beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1, destinationParent, destinationChild);
     }
     //for moves within the 1st level nodes for comment nodes
     if (sourceParent == destinationParent && sourceParent.isValid() && !sourceParent.parent().isValid()){
         const QModelIndex parent = sourceParent;
         for (int row = 0; row < count; row++){
             if (sourceRow < 4 || sourceRow >= rowCount(parent)) return false;
             if (destinationChild + row < 4 || destinationChild + row >= rowCount(parent)) return false;
 
             StoryboardItem *item = static_cast<StoryboardItem*>(parent.internalPointer());
             item->moveChild(sourceRow, destinationChild + row);
         }
         endMoveRows();
         return true;
     }
     else if (!sourceParent.isValid()){                  //for moves of 1st level nodes
         for (int row = 0; row < count; row++){
             if (sourceRow < 0 || sourceRow >= rowCount()) return false;
             if (destinationChild + row < 0 || destinationChild + row >= rowCount()) return false;
 
             m_items.move(sourceRow, destinationChild + row);
         }
         endMoveRows();
         return true;
     }
     else {
         return false;
     }
 }
 
 QMimeData *StoryboardModel::mimeData(const QModelIndexList &indexes) const
 {
     QMimeData *mimeData = new QMimeData();
     QByteArray encodeData;
 
     QDataStream stream(&encodeData, QIODevice::WriteOnly);
 
     //take the row number of the index where drag started
     foreach (QModelIndex index, indexes){
         if (index.isValid()) {
             int row = index.row();
             stream << row;
         }
     }
 
     mimeData->setData("application/x-qabstractitemmodeldatalist", encodeData); //default mimetype
     return mimeData;
 }
 
 bool StoryboardModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
                                 int row, int column, const QModelIndex &parent)
 {
     if (action == Qt::IgnoreAction)
         return false;
 
     if (action == Qt::MoveAction && data->hasFormat("application/x-qabstractitemmodeldatalist")){
         QByteArray bytes = data->data("application/x-qabstractitemmodeldatalist");
         QDataStream stream(&bytes, QIODevice::ReadOnly);
 
         if (parent.isValid()){
             return false;
         }
         int sourceRow;
         QModelIndexList moveRowIndexes;
         while (!stream.atEnd()) {
             stream >> sourceRow;
             QModelIndex index = createIndex(sourceRow, 0);
             moveRowIndexes.append(index);
         }
         moveRows(QModelIndex(), moveRowIndexes.at(0).row(), moveRowIndexes.count(), parent, row);
 
         //returning true deletes the source row
         return false;
     }
     return false;
 }
 
 Qt::DropActions StoryboardModel::supportedDropActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
 Qt::DropActions StoryboardModel::supportedDragActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
 int StoryboardModel::visibleCommentCount() const
 {
     int visibleComments = 0;
     foreach(Comment comment, m_commentList){
         if (comment.visibility){
             visibleComments++;
         }
     }
     return visibleComments;
 }
 
 int StoryboardModel::visibleCommentsUpto(QModelIndex index) const
 {
     int commentRow = index.row() - 4;
     int visibleComments = 0;
     for (int row = 0; row < commentRow; row++){
         if (m_commentList.at(row).visibility){
             visibleComments++;
         }
     }
     return visibleComments;
 }
 
 void StoryboardModel::setCommentModel(CommentModel *commentModel)
 {
     m_commentModel = commentModel;
     connect(m_commentModel, SIGNAL(dataChanged(const QModelIndex ,const QModelIndex)),
                 this, SLOT(slotCommentDataChanged()));
     connect(m_commentModel, SIGNAL(rowsRemoved(const QModelIndex ,int, int)),
                 this, SLOT(slotCommentRowRemoved(const QModelIndex ,int, int)));
     connect(m_commentModel, SIGNAL(rowsInserted(const QModelIndex, int, int)),
                 this, SLOT(slotCommentRowInserted(const QModelIndex, int, int)));
     connect(m_commentModel, SIGNAL(rowsMoved(const QModelIndex, int, int, const QModelIndex, int)),
                 this, SLOT(slotCommentRowMoved(const QModelIndex, int, int, const QModelIndex, int)));
 }
 
 Comment StoryboardModel::getComment(int row) const
 {
     return m_commentList.at(row);
 }
 
 void StoryboardModel::slotCommentDataChanged()
 {
     m_commentList = m_commentModel->m_commentList;
     emit(dataChanged(QModelIndex(), QModelIndex()));
 }
 
 void StoryboardModel::slotCommentRowInserted(const QModelIndex parent, int first, int last)
 {
     int numItems = rowCount();
     for(int row = 0; row < numItems; row++){
         QModelIndex parentIndex = index(row, 0);
         insertRows(4 + first, last - first + 1, parentIndex);       //four indices are already there
     }
     slotCommentDataChanged();
 }
 
 void StoryboardModel::slotCommentRowRemoved(const QModelIndex parent, int first, int last)
 {
     int numItems = rowCount();
     for(int row = 0; row < numItems; row++){
         QModelIndex parentIndex = index(row, 0);
         removeRows(4 + first, last - first + 1, parentIndex);
     }
     slotCommentDataChanged();
 }
 
 void StoryboardModel::slotCommentRowMoved(const QModelIndex &sourceParent, int start, int end,
                             const QModelIndex &destinationParent, int destinationRow)
 {
     int numItems = rowCount();
     for(int row = 0; row < numItems; row++){
         QModelIndex parentIndex = index(row, 0);
         moveRows(parentIndex, start + 4, end - start + 1, parentIndex, destinationRow + 4);
     }
     slotCommentDataChanged();
 }
\ No newline at end of file
diff --git a/plugins/dockers/storyboarddocker/storyboardView.cpp b/plugins/dockers/storyboarddocker/storyboardView.cpp
index 533b67e12a..e010c5f45f 100644
--- a/plugins/dockers/storyboarddocker/storyboardView.cpp
+++ b/plugins/dockers/storyboarddocker/storyboardView.cpp
@@ -1,225 +1,224 @@
 /*
   Copyright (c) 2020 Saurabh Kumar <saurabhk660@gmail.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 #include <QDebug>
 #include <QPainter>
 #include <QPaintEvent>
 
 #include "storyboardView.h"
 #include "storyboardModel.h"
 
 /**
  * This view draws the children of every index in the first column of 
  * the model inside the parent
  *
  * */
 
 StoryboardView::StoryboardView(QWidget *parent)
     : QListView(parent)
     , m_commentIsVisible(true)
     , m_thumbnailIsVisible(true)
 {
     setSelectionBehavior(SelectRows);
     setDefaultDropAction(Qt::MoveAction);
     setResizeMode(QListView::Adjust);
     setUniformItemSizes(true);
     setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
     setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
     QWidget::setMouseTracking(true);
-
     setDragEnabled(true);
     viewport()->setAcceptDrops(true);
     setDropIndicatorShown(true);
     setDragDropMode(QAbstractItemView::InternalMove);
 }
 
 StoryboardView::~StoryboardView()
 {}
 
 void StoryboardView::paintEvent(QPaintEvent *event)
 {
     event->accept();
     QListView::paintEvent(event);
 
     //ask delegate to draw the child nodes too
     QPainter painter(viewport());
     int itemNum = model()->rowCount();
     for (int row = 0; row < itemNum; row++){
         QModelIndex index = model()->index(row, 0);
         int childNum = model()->rowCount(index);
         for (int childRow = 0; childRow < childNum; childRow++){
 
             QModelIndex childIndex = model()->index(childRow, 0, index);
 
             QStyleOptionViewItem option;
             if (selectionModel()->isSelected(childIndex)) {
                 option.state |= QStyle::State_Selected;
             }
             if (childIndex == selectionModel()->currentIndex()) {
                 option.state |= QStyle::State_HasFocus;
             }
             if (childIndex == m_hoverIndex){
                 option.state |= QStyle::State_MouseOver;
             }
             option.font = font();
             option.fontMetrics = fontMetrics();
             option.rect = visualRect(childIndex);
             itemDelegate()->paint(&painter, option, childIndex);
         }
     }
 }
 
 QRect StoryboardView::visualRect(const QModelIndex &index) const
 {
     if (!index.isValid() || !index.parent().isValid()) {
         return QListView::visualRect(index);
     }
     else {
         QRect parentRect = visualRect(index.parent());
         parentRect.setTopLeft(parentRect.topLeft() + QPoint(5, 5));
         parentRect.setBottomRight(parentRect.bottomRight() - QPoint(5, 5));
         int fontHeight = fontMetrics().height() + 3;
         int numericFontWidth = fontMetrics().width("0");
         int height = parentRect.height();
         int parentWidth = parentRect.width();
         int childRow = index.row();
 
         int thumbnailWidth = parentWidth;
         if (m_itemOrientation == Qt::Horizontal){
             thumbnailWidth = 250;
         }
         switch (childRow)
         {
             case 0:
             {   
                 //the frame thumbnail rect
                 if (!thumbnailIsVisible()){
                     parentRect.setSize(QSize(3*numericFontWidth + 2, fontHeight));
                     return parentRect;
                 }
 
                 parentRect.setSize(QSize(thumbnailWidth, 120));
                 parentRect.translate(0, fontHeight);
                 return parentRect;
             }
             case 1:
             {
                 QRect itemNameRect = parentRect;
                 itemNameRect.setSize(QSize(thumbnailWidth - (10 * numericFontWidth + 22), fontHeight));
                 itemNameRect.moveLeft(parentRect.left() + 3*numericFontWidth + 2);
                 return itemNameRect;
             }
             case 2:
             {
                 QRect secondRect = parentRect;
                 secondRect.setSize(QSize(4 * numericFontWidth + 10, fontHeight));
                 //secondRect.moveRight(parentRect.right() - 3*numericFontWidth -10);
                 secondRect.moveLeft(parentRect.left() - 7*numericFontWidth + thumbnailWidth -20);
                 return secondRect;
             }
             case 3:
             {
                 QRect frameRect = parentRect;
                 frameRect.setSize(QSize(3 * numericFontWidth + 10, fontHeight));
                 frameRect.moveRight(parentRect.right());
                 frameRect.moveLeft(parentRect.left() - 3*numericFontWidth + thumbnailWidth - 10);
                 return frameRect;
             }
             default:
             {
                 //comment rect
                 if (!commentIsVisible()) return QRect();
 
                 int thumbnailheight = thumbnailIsVisible() ? 120 : 0;
                 if (m_itemOrientation == Qt::Vertical){
                     const StoryboardModel* Model = dynamic_cast<const StoryboardModel*>(model());
                     parentRect.setTop(parentRect.top() + thumbnailheight + fontHeight + Model->visibleCommentsUpto(index) * 100);
                     parentRect.setHeight(100);
                     return parentRect;
                 }
                 else {
                     const StoryboardModel* Model = dynamic_cast<const StoryboardModel*>(model());
                     int numVisibleComments = Model->visibleCommentCount();
                     int commentWidth = 200;
                     if (numVisibleComments){
                         commentWidth = qMax(200, (viewport()->width() - 250) / numVisibleComments);
                     }
                     parentRect.setSize(QSize(commentWidth, thumbnailheight + fontHeight));
                     parentRect.moveLeft(parentRect.left() + thumbnailWidth + Model->visibleCommentsUpto(index) * commentWidth);
                     return parentRect;
                 }
             }
         }
     }
     return QRect();
 }
 
 QModelIndex StoryboardView::indexAt(const QPoint &point) const
 {
     QModelIndex index = QListView::indexAt(point);
     if (index.isValid()) {
         //look for the index in children of the current index
         int numChild = model()->rowCount(index);
         for (int row = 0; row < numChild; row++) {
             QRect childRect = visualRect(model()->index(row, 0, index));
             if (childRect.contains(point)) {
                 return model()->index(row, 0, index);
             }
         }
     }
     return index;
 }
 
 void StoryboardView::mouseMoveEvent(QMouseEvent *event)
 {
     event->accept();
     QListView::mouseMoveEvent(event);
 
     m_hoverIndex = indexAt(event->pos());
 }
 
 void StoryboardView::setItemOrientation(Qt::Orientation orientation)
 {
     m_itemOrientation = orientation;
 }
 
 Qt::Orientation StoryboardView::itemOrientation()
 {
     return m_itemOrientation;
 }
 
 bool StoryboardView::commentIsVisible() const
 {
     return m_commentIsVisible;
 }
 
 bool StoryboardView::thumbnailIsVisible() const
 {
     return m_thumbnailIsVisible;
 }
 
 void StoryboardView::setCommentVisibility(bool value)
 {
     m_commentIsVisible = value;
 }
 
 void StoryboardView::setThumbnailVisibility(bool value)
 {
     m_thumbnailIsVisible = value;
 }