diff --git a/plugins/dockers/storyboarddocker/storyboardModel.cpp b/plugins/dockers/storyboarddocker/storyboardModel.cpp
index 9f5ae12872..8560883537 100644
--- a/plugins/dockers/storyboarddocker/storyboardModel.cpp
+++ b/plugins/dockers/storyboarddocker/storyboardModel.cpp
@@ -1,367 +1,419 @@
 /*
  *  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())
         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();
         return true;
     }
 
     //insert 2nd level nodes
     if (!parent.parent().isValid()){
         StoryboardItem *item = static_cast<StoryboardItem*>(parent.internalPointer());
         beginInsertRows(QModelIndex(), 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) {
             delete m_items.at(row);
             m_items.removeAt(position);
         }
         endRemoveRows();
         return true;
     }
 
     //remove 2nd level nodes
     if (!parent.parent().isValid()){
         StoryboardItem *item = static_cast<StoryboardItem*>(parent.internalPointer());
         if (m_items.contains(item)){
             beginRemoveRows(QModelIndex(), 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);
     }
-
-    //only implementing for moves within the 1st level nodes for comment nodes
-    if (sourceParent == destinationParent && !sourceParent.parent().isValid()){
+    //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)));
 }
 
-void StoryboardModel::optionsChanged()
-{
-    emit(layoutChanged());
-}
-
 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/storyboardModel.h b/plugins/dockers/storyboarddocker/storyboardModel.h
index 7c7052a3b8..4d8b4200e6 100644
--- a/plugins/dockers/storyboarddocker/storyboardModel.h
+++ b/plugins/dockers/storyboarddocker/storyboardModel.h
@@ -1,100 +1,100 @@
 /*
  *  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.
  */
 #ifndef STORYBOARD_MODEL
 #define STORYBOARD_MODEL
 
 #include <QAbstractListModel>
 #include <QStringList>
 
 #include "storyboardItem.h"
 #include "commentModel.h"
 
 /*
     The main storyboard model. 
 */
 
 class CommentBox
 {
 public:
     CommentBox()
     : content("")
     , scrollValue(0)
     {}
     CommentBox(const CommentBox& other)
     : content(other.content)
     , scrollValue(other.scrollValue)
     {}
     ~CommentBox()
     {}
     QVariant content;
     QVariant scrollValue;
 };
 Q_DECLARE_METATYPE(CommentBox)
 
 class StoryboardModel : public QAbstractItemModel
 {
     Q_OBJECT
 
 public:
 //if we don't need this constructor change it
     StoryboardModel(QObject *parent = nullptr);
 
     QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
     QModelIndex parent(const QModelIndex &index) const override;
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
 
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
     bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
     bool setCommentScrollData(const QModelIndex & index, const QVariant & value);
-    //QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
     Qt::ItemFlags flags(const QModelIndex &index) const override;
     
     //for removing and inserting rows
     bool insertRows(int position, int rows, const QModelIndex &index = QModelIndex());
     bool removeRows(int position, int rows, const QModelIndex &index = QModelIndex());
     bool moveRows(const QModelIndex &sourceParent, int sourceRow, int count,
                     const QModelIndex &destinationParent, int destinationChild);
 
     //for drag and drop
+    QMimeData *mimeData(const QModelIndexList &indexes) const;
+    bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent);
     Qt::DropActions supportedDropActions() const override;
     Qt::DropActions supportedDragActions() const override;
 
-    //this function accesses the value from the comment model
+    //these function access the value from the comment model
     int visibleCommentCount() const;
     int visibleCommentsUpto(QModelIndex index) const;
     void setCommentModel(CommentModel *commentModel);
-    void optionsChanged();
     Comment getComment(int row) const;
 
 private Q_SLOTS:
     void slotCommentDataChanged();
     void slotCommentRowInserted(const QModelIndex, int, int);
     void slotCommentRowRemoved(const QModelIndex, int, int);
     void slotCommentRowMoved(const QModelIndex &sourceParent, int sourceRow, int count,
                             const QModelIndex &destinationParent, int destinationChild);
 
 private:
     QVector<StoryboardItem*> m_items;
     int m_commentCount = 0;
     QVector<Comment> m_commentList;
     CommentModel *m_commentModel;
 };
 
 #endif
\ No newline at end of file
diff --git a/plugins/dockers/storyboarddocker/storyboardView.cpp b/plugins/dockers/storyboarddocker/storyboardView.cpp
index 609f7ed682..eef47986ff 100644
--- a/plugins/dockers/storyboarddocker/storyboardView.cpp
+++ b/plugins/dockers/storyboarddocker/storyboardView.cpp
@@ -1,228 +1,226 @@
 /*
   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)
 {
     setWrapping(true);
     setFlow(QListView::LeftToRight);
     setResizeMode(QListView::Adjust);
     setUniformItemSizes(true);
     setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
     setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
     QWidget::setMouseTracking(true);
 
     //make drag and drop work as expected
-/*
     setDragEnabled(true);
-    setAcceptDrops(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;
 }
diff --git a/plugins/dockers/storyboarddocker/storyboarddocker_dock.cpp b/plugins/dockers/storyboarddocker/storyboarddocker_dock.cpp
index 91e0136848..93776774cf 100644
--- a/plugins/dockers/storyboarddocker/storyboarddocker_dock.cpp
+++ b/plugins/dockers/storyboarddocker/storyboarddocker_dock.cpp
@@ -1,279 +1,279 @@
 /*
  *  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 Lesser General Public License as published by
  *  the Free Software Foundation; 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "storyboarddocker_dock.h"
 #include "commentDelegate.h"
 #include "commentModel.h"
 #include "storyboardModel.h"
 #include "storyboardDelegate.h"
 
 #include <QMenu>
 #include <QButtonGroup>
 #include <QDebug>
 #include <QStringListModel>
 #include <QListView>
 
 #include <klocalizedstring.h>
 
 #include <KisPart.h>
 #include <KisViewManager.h>
 #include <KisDocument.h>
 #include <kis_icon.h>
 
 #include "ui_wdgstoryboarddock.h"
 #include "ui_wdgcommentmenu.h"
 #include "ui_wdgarrangemenu.h"
 
 class CommentMenu: public QMenu
 {
     Q_OBJECT
 public:
     CommentMenu(QWidget *parent, CommentModel *m_model)
         : QMenu(parent)
         , m_menuUI(new Ui_WdgCommentMenu())
         , model(m_model)
         , delegate(new CommentDelegate(this))
     {
         QWidget* commentWidget = new QWidget(this);
         m_menuUI->setupUi(commentWidget);
 
         m_menuUI->fieldListView->setDragEnabled(true);
         m_menuUI->fieldListView->setAcceptDrops(true);
         m_menuUI->fieldListView->setDropIndicatorShown(true);
         m_menuUI->fieldListView->setDragDropMode(QAbstractItemView::InternalMove);
 
         m_menuUI->fieldListView->setModel(model);
         m_menuUI->fieldListView->setItemDelegate(delegate);
 
         m_menuUI->fieldListView->setEditTriggers(QAbstractItemView::AnyKeyPressed |
                                                     QAbstractItemView::DoubleClicked  );
 
         m_menuUI->btnAddField->setIcon(KisIconUtils::loadIcon("list-add"));
         m_menuUI->btnDeleteField->setIcon(KisIconUtils::loadIcon("trash-empty"));
         m_menuUI->btnAddField->setIconSize(QSize(22, 22));
         m_menuUI->btnDeleteField->setIconSize(QSize(22, 22));
         connect(m_menuUI->btnAddField, SIGNAL(clicked()), this, SLOT(slotaddItem()));
         connect(m_menuUI->btnDeleteField, SIGNAL(clicked()), this, SLOT(slotdeleteItem()));
 
         KisAction *commentAction = new KisAction(commentWidget);
         commentAction->setDefaultWidget(commentWidget);
         this->addAction(commentAction);
     }
 
 private Q_SLOTS:
     void slotaddItem()
     {
         int row = m_menuUI->fieldListView->currentIndex().row()+1;
         model->insertRows(row, 1);
 
         QModelIndex index = model->index(row);
         m_menuUI->fieldListView->setCurrentIndex(index);
         m_menuUI->fieldListView->edit(index);
     }
 
     void slotdeleteItem()
     {
         model->removeRows(m_menuUI->fieldListView->currentIndex().row(), 1);
     }
 
 private:
     QScopedPointer<Ui_WdgCommentMenu> m_menuUI;
     CommentModel *model;
     CommentDelegate *delegate;
 };
 
 class ArrangeMenu: public QMenu
 {
 public:
     ArrangeMenu(QWidget *parent)
         : QMenu(parent)
         , m_menuUI(new Ui_WdgArrangeMenu())
         , modeGroup(new QButtonGroup(this))
         , viewGroup(new QButtonGroup(this))
     {
         QWidget* arrangeWidget = new QWidget(this);
         m_menuUI->setupUi(arrangeWidget);
 
         modeGroup->addButton(m_menuUI->btnColumnMode, 0);
         modeGroup->addButton(m_menuUI->btnRowMode, 1);
         modeGroup->addButton(m_menuUI->btnGridMode, 2);
 
         viewGroup->addButton(m_menuUI->btnAllView, 0);
         viewGroup->addButton(m_menuUI->btnThumbnailsView, 1);
         viewGroup->addButton(m_menuUI->btnCommentsView, 2);
 
         KisAction *arrangeAction = new KisAction(arrangeWidget);
         arrangeAction->setDefaultWidget(arrangeWidget);
         this->addAction(arrangeAction);
     }
 
     QButtonGroup* getModeGroup(){ return modeGroup;}
     QButtonGroup* getViewGroup(){ return viewGroup;}
 
 private:
     QScopedPointer<Ui_WdgArrangeMenu> m_menuUI;
     QButtonGroup *modeGroup;
     QButtonGroup *viewGroup;
 };
 
 StoryboardDockerDock::StoryboardDockerDock( )
     : QDockWidget(i18n("Storyboard"))
     , m_ui(new Ui_WdgStoryboardDock())
 {
     QWidget* mainWidget = new QWidget(this);
     setWidget(mainWidget);
     m_ui->setupUi(mainWidget);
 
 
     m_exportMenu = new QMenu(this);
     m_ui->btnExport->setMenu(m_exportMenu);
     m_ui->btnExport->setPopupMode(QToolButton::MenuButtonPopup);
 
     m_exportAsPdfAction = new KisAction("Export as PDF", m_exportMenu);
     m_exportMenu->addAction(m_exportAsPdfAction);
 
     m_exportAsSvgAction = new KisAction("Export as SVG");
     m_exportMenu->addAction(m_exportAsSvgAction);
     connect(m_exportAsPdfAction, SIGNAL(triggered()), this, SLOT(slotExportAsPdf()));
     connect(m_exportAsSvgAction, SIGNAL(triggered()), this, SLOT(slotExportAsSvg()));
 
     m_commentModel = new CommentModel(this);
     m_commentMenu = new CommentMenu(this, m_commentModel);
 
     m_ui->btnComment->setMenu(m_commentMenu);
     m_ui->btnComment->setPopupMode(QToolButton::MenuButtonPopup);
 
 
     m_lockAction = new KisAction(KisIconUtils::loadIcon("unlocked"), "Lock", m_ui->btnLock);
     m_lockAction->setCheckable(true);
     m_ui->btnLock->setDefaultAction(m_lockAction);
     m_ui->btnLock->setIconSize(QSize(22, 22));
     connect(m_lockAction, SIGNAL(toggled(bool)), this, SLOT(slotLockClicked(bool)));
     
 
     m_arrangeMenu = new ArrangeMenu(this);
     m_ui->btnArrange->setMenu(m_arrangeMenu);
     m_ui->btnArrange->setPopupMode(QToolButton::InstantPopup);
     m_ui->btnArrange->setIcon(KisIconUtils::loadIcon("view-choose"));
     m_ui->btnArrange->setIconSize(QSize(22, 22));
 
     m_modeGroup = m_arrangeMenu->getModeGroup();
     m_viewGroup = m_arrangeMenu->getViewGroup();
 
     connect(m_modeGroup, SIGNAL(buttonClicked(QAbstractButton*)), this, SLOT(slotModeChanged(QAbstractButton*)));
     connect(m_viewGroup, SIGNAL(buttonClicked(QAbstractButton*)), this, SLOT(slotViewChanged(QAbstractButton*)));
 
     m_storyboardModel = new StoryboardModel(this);
     StoryboardDelegate *delegate = new StoryboardDelegate(this);
     delegate->setView(m_ui->listView);
     m_ui->listView->setModel(m_storyboardModel);
     m_ui->listView->setItemDelegate(delegate);
     delegate->setView(m_ui->listView);
 
     m_storyboardModel->insertRows(0, 10);
     m_storyboardModel->setCommentModel(m_commentModel);
 
-    m_modeGroup->button(0)->click();
+    m_modeGroup->button(2)->click();
     m_viewGroup->button(0)->click();
 }
 
 StoryboardDockerDock::~StoryboardDockerDock()
 {
 }
 
 void StoryboardDockerDock::setCanvas(KoCanvasBase *canvas)
 {
 }
 
 void StoryboardDockerDock::setViewManager(KisViewManager* kisview)
 {
 }
 
 void StoryboardDockerDock::slotExportAsPdf()
 {
     qDebug()<<"export as pdf";
     slotExport("pdf");
 }
 
 void StoryboardDockerDock::slotExportAsSvg()
 {
     qDebug()<<"export as svg";
     slotExport("svg");
 }
 
 void StoryboardDockerDock::slotExport(QString mode)
 {
     qDebug()<<"mode is "<<mode;
 }
 
 void StoryboardDockerDock::slotLockClicked(bool isLocked){
     if (isLocked){
         m_lockAction->setIcon(KisIconUtils::loadIcon("locked"));
     }
     else{
         m_lockAction->setIcon(KisIconUtils::loadIcon("unlocked"));
     }
 }
 
 void StoryboardDockerDock::slotModeChanged(QAbstractButton* button)
 {
     QString mode = button->text();
     if (mode == "Column"){
         m_ui->listView->setFlow(QListView::LeftToRight);
         m_ui->listView->setWrapping(false);
         m_ui->listView->setItemOrientation(Qt::Vertical);
         m_viewGroup->button(2)->setEnabled(true);
     }
     else if (mode == "Row"){
         m_ui->listView->setFlow(QListView::TopToBottom);
         m_ui->listView->setWrapping(false);
         m_ui->listView->setItemOrientation(Qt::Horizontal);
         m_viewGroup->button(2)->setEnabled(false);           //disable the comments only view
     }
     else if (mode == "Grid"){
         m_ui->listView->setFlow(QListView::LeftToRight);
         m_ui->listView->setWrapping(true);
         m_ui->listView->setItemOrientation(Qt::Vertical);
         m_viewGroup->button(2)->setEnabled(true);
     }
     m_storyboardModel->layoutChanged();
 }
 
 void StoryboardDockerDock::slotViewChanged(QAbstractButton* button)
 {
     QString view = button->text();
     if (view == "All"){
         m_ui->listView->setCommentVisibility(true);
         m_ui->listView->setThumbnailVisibility(true);
         m_modeGroup->button(1)->setEnabled(true);
     }
     else if (view == "Thumbnails Only"){
         m_ui->listView->setCommentVisibility(false);
         m_ui->listView->setThumbnailVisibility(true);
         m_modeGroup->button(1)->setEnabled(true);
     }
 
     else if (view == "Comments Only"){
         m_ui->listView->setCommentVisibility(true);
         m_ui->listView->setThumbnailVisibility(false);
         m_modeGroup->button(1)->setEnabled(false);               //disable the row mode
     }
     m_storyboardModel->layoutChanged();
 }
 
 #include "storyboarddocker_dock.moc"
\ No newline at end of file