diff --git a/src/bin/abstractprojectitem.cpp b/src/bin/abstractprojectitem.cpp
index 39f6657f6..a99ed3a85 100644
--- a/src/bin/abstractprojectitem.cpp
+++ b/src/bin/abstractprojectitem.cpp
@@ -1,305 +1,305 @@
 /*
 Copyright (C) 2012  Till Theato <root@ttill.de>
 Copyright (C) 2014  Jean-Baptiste Mardelle <jb@kdenlive.org>
 This file is part of Kdenlive. See www.kdenlive.org.
 
 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) version 3 or any later version
 accepted by the membership of KDE e.V. (or its successor approved
 by the membership of KDE e.V.), which shall act as a proxy
 defined in Section 14 of version 3 of the license.
 
 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, see <http://www.gnu.org/licenses/>.
 */
 
 #include "abstractprojectitem.h"
 #include "bin.h"
 #include "core.h"
 #include "jobs/jobmanager.h"
 #include "macros.hpp"
 #include "projectitemmodel.h"
 
 #include "jobs/audiothumbjob.hpp"
 #include "jobs/loadjob.hpp"
 #include "jobs/thumbjob.hpp"
 
 #include <QPainter>
 #include <QVariant>
 #include <utility>
 AbstractProjectItem::AbstractProjectItem(PROJECTITEMTYPE type, QString id, const std::shared_ptr<ProjectItemModel> &model, bool isRoot)
     : TreeItem(QList<QVariant>(), std::static_pointer_cast<AbstractTreeModel>(model), isRoot)
     , m_name()
     , m_description()
     , m_thumbnail(QIcon())
     , m_date()
     , m_binId(std::move(id))
     , m_usage(0)
     , m_clipStatus(StatusReady)
     , m_itemType(type)
     , m_lock(QReadWriteLock::Recursive)
     , m_isCurrent(false)
 {
     Q_ASSERT(!isRoot || type == FolderItem);
 }
 
 bool AbstractProjectItem::operator==(const std::shared_ptr<AbstractProjectItem> &projectItem) const
 {
     // FIXME: only works for folders
     bool equal = this->m_childItems == projectItem->m_childItems;
     // equal = equal && (m_parentItem == projectItem->m_parentItem);
     return equal;
 }
 
 std::shared_ptr<AbstractProjectItem> AbstractProjectItem::parent() const
 {
     return std::static_pointer_cast<AbstractProjectItem>(m_parentItem.lock());
 }
 
 void AbstractProjectItem::setRefCount(uint count)
 {
     m_usage = count;
     if (auto ptr = m_model.lock())
         std::static_pointer_cast<ProjectItemModel>(ptr)->onItemUpdated(std::static_pointer_cast<AbstractProjectItem>(shared_from_this()),
                                                                        AbstractProjectItem::UsageCount);
 }
 
 uint AbstractProjectItem::refCount() const
 {
     return m_usage;
 }
 
 void AbstractProjectItem::addRef()
 {
     m_usage++;
     if (auto ptr = m_model.lock())
         std::static_pointer_cast<ProjectItemModel>(ptr)->onItemUpdated(std::static_pointer_cast<AbstractProjectItem>(shared_from_this()),
                                                                        AbstractProjectItem::UsageCount);
 }
 
 void AbstractProjectItem::removeRef()
 {
     m_usage--;
     if (auto ptr = m_model.lock())
         std::static_pointer_cast<ProjectItemModel>(ptr)->onItemUpdated(std::static_pointer_cast<AbstractProjectItem>(shared_from_this()),
                                                                        AbstractProjectItem::UsageCount);
 }
 
 const QString &AbstractProjectItem::clipId() const
 {
     return m_binId;
 }
 
 QPixmap AbstractProjectItem::roundedPixmap(const QPixmap &source)
 {
     QPixmap pix(source.size());
     pix.fill(Qt::transparent);
     QPainter p(&pix);
     p.setRenderHint(QPainter::Antialiasing, true);
     QPainterPath path;
     path.addRoundedRect(0.5, 0.5, pix.width() - 1, pix.height() - 1, 4, 4);
     p.setClipPath(path);
     p.drawPixmap(0, 0, source);
     p.end();
     return pix;
 }
 
 AbstractProjectItem::PROJECTITEMTYPE AbstractProjectItem::itemType() const
 {
     return m_itemType;
 }
 
 QVariant AbstractProjectItem::getData(DataType type) const
 {
     QVariant data;
     switch (type) {
     case DataName:
         data = QVariant(m_name);
         break;
     case DataDescription:
         data = QVariant(m_description);
         break;
     case DataThumbnail:
         data = QVariant(m_thumbnail);
         break;
     case DataId:
         data = QVariant(m_binId);
         break;
     case DataDuration:
         data = QVariant(m_duration);
         break;
     case ParentDuration:
         data = QVariant(m_parentDuration);
         break;
     case DataInPoint:
         data = QVariant(m_inPoint);
         break;
     case DataOutPoint:
         data = QVariant(m_outPoint);
         break;
     case DataDate:
         data = QVariant(m_date);
         break;
     case UsageCount:
         data = QVariant(m_usage);
         break;
     case ItemTypeRole:
         data = QVariant(m_itemType);
         break;
     case ClipType:
         data = clipType();
         break;
     case ClipHasAudioAndVideo:
         data = hasAudioAndVideo();
         break;
     case JobType:
         if (itemType() == ClipItem) {
             auto jobIds = pCore->jobManager()->getPendingJobsIds(clipId());
             if (jobIds.empty()) {
                 jobIds = pCore->jobManager()->getFinishedJobsIds(clipId());
             }
             if (jobIds.size() > 0) {
                 data = QVariant(pCore->jobManager()->getJobType(jobIds[0]));
             }
         }
         break;
     case JobStatus:
         if (itemType() == ClipItem) {
             auto jobIds = pCore->jobManager()->getPendingJobsIds(clipId());
             if (jobIds.empty()) {
                 jobIds = pCore->jobManager()->getFinishedJobsIds(clipId());
             }
             if (jobIds.size() > 0) {
                 data = QVariant::fromValue(pCore->jobManager()->getJobStatus(jobIds[0]));
             } else {
                 data = QVariant::fromValue(JobManagerStatus::NoJob);
             }
         }
         break;
     case JobProgress:
         if (itemType() == ClipItem) {
             auto jobIds = pCore->jobManager()->getPendingJobsIds(clipId());
             if (jobIds.size() > 0) {
                 data = QVariant(pCore->jobManager()->getJobProgressForClip(jobIds[0], clipId()));
             } else {
                 data = QVariant(0);
             }
         }
         break;
     case JobSuccess:
         if (itemType() == ClipItem) {
             auto jobIds = pCore->jobManager()->getFinishedJobsIds(clipId());
             if (jobIds.size() > 0) {
                 // Check the last job status
                 data = QVariant(pCore->jobManager()->jobSucceded(jobIds[jobIds.size() - 1]));
             } else {
                 data = QVariant(true);
             }
         }
         break;
     case ClipStatus:
         data = QVariant(m_clipStatus);
         break;
     case ClipToolTip:
         data = QVariant(getToolTip());
         break;
     default:
         break;
     }
     return data;
 }
 
 int AbstractProjectItem::supportedDataCount() const
 {
-    return 3;
+    return 4;
 }
 
 QString AbstractProjectItem::name() const
 {
     return m_name;
 }
 
 void AbstractProjectItem::setName(const QString &name)
 {
     m_name = name;
 }
 
 QString AbstractProjectItem::description() const
 {
     return m_description;
 }
 
 void AbstractProjectItem::setDescription(const QString &description)
 {
     m_description = description;
 }
 
 QPoint AbstractProjectItem::zone() const
 {
     return {};
 }
 
 void AbstractProjectItem::setClipStatus(CLIPSTATUS status)
 {
     m_clipStatus = status;
 }
 
 bool AbstractProjectItem::statusReady() const
 {
     return m_clipStatus == StatusReady;
 }
 
 AbstractProjectItem::CLIPSTATUS AbstractProjectItem::clipStatus() const
 {
     return m_clipStatus;
 }
 
 std::shared_ptr<AbstractProjectItem> AbstractProjectItem::getEnclosingFolder(bool strict)
 {
     if (!strict && itemType() == AbstractProjectItem::FolderItem) {
         return std::static_pointer_cast<AbstractProjectItem>(shared_from_this());
     }
     if (auto ptr = m_parentItem.lock()) {
         return std::static_pointer_cast<AbstractProjectItem>(ptr)->getEnclosingFolder(false);
     }
     return std::shared_ptr<AbstractProjectItem>();
 }
 
 bool AbstractProjectItem::selfSoftDelete(Fun &undo, Fun &redo)
 {
     pCore->jobManager()->slotDiscardClipJobs(clipId());
     Fun local_undo = []() { return true; };
     Fun local_redo = []() { return true; };
     for (const auto &child : m_childItems) {
         bool res = std::static_pointer_cast<AbstractProjectItem>(child)->selfSoftDelete(local_undo, local_redo);
         if (!res) {
             bool undone = local_undo();
             Q_ASSERT(undone);
             return false;
         }
     }
     UPDATE_UNDO_REDO(local_redo, local_undo, undo, redo);
     return true;
 }
 
 QString AbstractProjectItem::lastParentId() const
 {
     return m_lastParentId;
 }
 
 void AbstractProjectItem::updateParent(std::shared_ptr<TreeItem> newParent)
 {
     // bool reload = !m_lastParentId.isEmpty();
     m_lastParentId.clear();
     if (newParent) {
         m_lastParentId = std::static_pointer_cast<AbstractProjectItem>(newParent)->clipId();
     }
     TreeItem::updateParent(newParent);
 }
diff --git a/src/bin/bin.cpp b/src/bin/bin.cpp
index 7cb2cdfff..6d5fe100c 100644
--- a/src/bin/bin.cpp
+++ b/src/bin/bin.cpp
@@ -1,3367 +1,3435 @@
 /*
 Copyright (C) 2012  Till Theato <root@ttill.de>
 Copyright (C) 2014  Jean-Baptiste Mardelle <jb@kdenlive.org>
 This file is part of Kdenlive. See www.kdenlive.org.
 
 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) version 3 or any later version
 accepted by the membership of KDE e.V. (or its successor approved
 by the membership of KDE e.V.), which shall act as a proxy
 defined in Section 14 of version 3 of the license.
 
 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, see <http://www.gnu.org/licenses/>.
 */
 
 #include "bin.h"
 #include "bincommands.h"
 #include "clipcreator.hpp"
 #include "core.h"
 #include "dialogs/clipcreationdialog.h"
 #include "doc/documentchecker.h"
 #include "doc/docundostack.hpp"
 #include "doc/kdenlivedoc.h"
 #include "effects/effectstack/model/effectstackmodel.hpp"
 #include "jobs/audiothumbjob.hpp"
 #include "jobs/jobmanager.h"
 #include "jobs/loadjob.hpp"
 #include "jobs/thumbjob.hpp"
 #include "kdenlive_debug.h"
 #include "kdenlivesettings.h"
 #include "mainwindow.h"
 #include "mlt++/Mlt.h"
 #include "mltcontroller/clipcontroller.h"
 #include "mltcontroller/clippropertiescontroller.h"
 #include "monitor/monitor.h"
 #include "project/dialogs/slideshowclip.h"
 #include "project/invaliddialog.h"
 #include "project/projectcommands.h"
 #include "project/projectmanager.h"
 #include "projectclip.h"
 #include "projectfolder.h"
 #include "projectitemmodel.h"
 #include "projectsortproxymodel.h"
 #include "projectsubclip.h"
 #include "titler/titlewidget.h"
 #include "ui_qtextclip_ui.h"
 #include "undohelper.hpp"
 #include "xml/xml.hpp"
 
 #include <KColorScheme>
 #include <KMessageBox>
 #include <KXMLGUIFactory>
 #include <QToolBar>
 
 #include <QCryptographicHash>
 #include <QDesktopServices>
 #include <QDrag>
 #include <QFile>
 #include <QMenu>
+#include <QActionGroup>
 #include <QSlider>
 #include <QTimeLine>
 #include <QUndoCommand>
 #include <QUrl>
 #include <QVBoxLayout>
 #include <utility>
 #include <utils/thumbnailcache.hpp>
 
 /**
  * @class BinItemDelegate
  * @brief This class is responsible for drawing items in the QTreeView.
  */
 
 class BinItemDelegate : public QStyledItemDelegate
 {
 public:
     explicit BinItemDelegate(QObject *parent = nullptr)
         : QStyledItemDelegate(parent)
 
     {
         connect(this, &QStyledItemDelegate::closeEditor, [&]() { m_editorOpen = false; });
     }
     void setDar(double dar) { m_dar = dar; }
     void setEditorData(QWidget *w, const QModelIndex &i) const override
     {
         if (!m_editorOpen) {
             QStyledItemDelegate::setEditorData(w, i);
             m_editorOpen = true;
         }
     }
     bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index) override
     {
         Q_UNUSED(model);
         Q_UNUSED(option);
         Q_UNUSED(index);
         if (event->type() == QEvent::MouseButtonPress) {
             auto *me = (QMouseEvent *)event;
             if (m_audioDragRect.contains(me->pos())) {
                 dragType = PlaylistState::AudioOnly;
             } else if (m_videoDragRect.contains(me->pos())) {
                 dragType = PlaylistState::VideoOnly;
             } else {
                 dragType = PlaylistState::Disabled;
             }
         }
         event->ignore();
         return false;
     }
     void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const override
     {
         if (index.column() != 0) {
             QStyledItemDelegate::updateEditorGeometry(editor, option, index);
             return;
         }
         QStyleOptionViewItem opt = option;
         initStyleOption(&opt, index);
         QRect r1 = option.rect;
         int type = index.data(AbstractProjectItem::ItemTypeRole).toInt();
         int decoWidth = 0;
         if (opt.decorationSize.height() > 0) {
             decoWidth += r1.height() * m_dar;
         }
         int mid = 0;
         if (type == AbstractProjectItem::ClipItem || type == AbstractProjectItem::SubClipItem) {
             mid = (int)((r1.height() / 2));
         }
         r1.adjust(decoWidth, 0, 0, -mid);
         QFont ft = option.font;
         ft.setBold(true);
         QFontMetricsF fm(ft);
         QRect r2 = fm.boundingRect(r1, Qt::AlignLeft | Qt::AlignTop, index.data(AbstractProjectItem::DataName).toString()).toRect();
         editor->setGeometry(r2);
     }
 
     QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override
     {
         QSize hint = QStyledItemDelegate::sizeHint(option, index);
         QString text = index.data(AbstractProjectItem::DataName).toString();
         QRectF r = option.rect;
         QFont ft = option.font;
         ft.setBold(true);
         QFontMetricsF fm(ft);
         QStyle *style = option.widget ? option.widget->style() : QApplication::style();
         const int textMargin = style->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
         int width = fm.boundingRect(r, Qt::AlignLeft | Qt::AlignTop, text).width() + option.decorationSize.width() + 2 * textMargin;
         hint.setWidth(width);
         int type = index.data(AbstractProjectItem::ItemTypeRole).toInt();
         if (type == AbstractProjectItem::FolderItem) {
             return QSize(hint.width(), qMin(option.fontMetrics.lineSpacing() + 4, hint.height()));
         }
         if (type == AbstractProjectItem::ClipItem) {
             return QSize(hint.width(), qMax(option.fontMetrics.lineSpacing() * 2 + 4, qMax(hint.height(), option.decorationSize.height())));
         }
         if (type == AbstractProjectItem::SubClipItem) {
             return QSize(hint.width(), qMax(option.fontMetrics.lineSpacing() * 2 + 4, qMin(hint.height(), (int)(option.decorationSize.height() / 1.5))));
         }
         QIcon icon = qvariant_cast<QIcon>(index.data(Qt::DecorationRole));
         QString line1 = index.data(Qt::DisplayRole).toString();
         QString line2 = index.data(Qt::UserRole).toString();
 
         int textW = qMax(option.fontMetrics.horizontalAdvance(line1), option.fontMetrics.horizontalAdvance(line2));
         QSize iconSize = icon.actualSize(option.decorationSize);
         return {qMax(textW, iconSize.width()) + 4, option.fontMetrics.lineSpacing() * 2 + 4};
     }
 
     void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
     {
         if (index.column() == 0 && !index.data().isNull()) {
             QRect r1 = option.rect;
             painter->save();
             painter->setClipRect(r1);
             QStyleOptionViewItem opt(option);
             initStyleOption(&opt, index);
             int type = index.data(AbstractProjectItem::ItemTypeRole).toInt();
             QStyle *style = opt.widget ? opt.widget->style() : QApplication::style();
             const int textMargin = style->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
             // QRect r = QStyle::alignedRect(opt.direction, Qt::AlignVCenter | Qt::AlignLeft, opt.decorationSize, r1);
 
             style->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, painter, opt.widget);
             if ((option.state & static_cast<int>(QStyle::State_Selected)) != 0) {
                 painter->setPen(option.palette.highlightedText().color());
             } else {
                 painter->setPen(option.palette.text().color());
             }
             QRect r = r1;
             QFont font = painter->font();
             font.setBold(true);
             painter->setFont(font);
             if (type == AbstractProjectItem::ClipItem || type == AbstractProjectItem::SubClipItem) {
                 int decoWidth = 0;
                 if (opt.decorationSize.height() > 0) {
                     r.setWidth(r.height() * m_dar);
                     QPixmap pix = opt.icon.pixmap(opt.icon.actualSize(r.size()));
                     // Draw icon
                     decoWidth += r.width() + textMargin;
                     r.setWidth(r.height() * pix.width() / pix.height());
                     painter->drawPixmap(r, pix, QRect(0, 0, pix.width(), pix.height()));
                     m_thumbRect = r;
                 }
                 int mid = (int)((r1.height() / 2));
                 r1.adjust(decoWidth, 0, 0, -mid);
                 QRect r2 = option.rect;
                 r2.adjust(decoWidth, mid, 0, 0);
                 QRectF bounding;
                 painter->drawText(r1, Qt::AlignLeft | Qt::AlignTop, index.data(AbstractProjectItem::DataName).toString(), &bounding);
                 font.setBold(false);
                 painter->setFont(font);
                 QString subText = index.data(AbstractProjectItem::DataDuration).toString();
                 if (!subText.isEmpty()) {
                     r2.adjust(0, bounding.bottom() - r2.top(), 0, 0);
                     QColor subTextColor = painter->pen().color();
                     subTextColor.setAlphaF(.5);
                     painter->setPen(subTextColor);
                     // Draw usage counter
                     int usage = index.data(AbstractProjectItem::UsageCount).toInt();
                     if (usage > 0) {
                         subText.append(QString::asprintf(" [%d]", usage));
                     }
                     painter->drawText(r2, Qt::AlignLeft | Qt::AlignTop, subText, &bounding);
 
                     // Add audio/video icons for selective drag
                     int cType = index.data(AbstractProjectItem::ClipType).toInt();
                     bool hasAudioAndVideo = index.data(AbstractProjectItem::ClipHasAudioAndVideo).toBool();
                     if (hasAudioAndVideo && (cType == ClipType::AV || cType == ClipType::Playlist) && (opt.state & QStyle::State_MouseOver)) {
                         bounding.moveLeft(bounding.right() + (2 * textMargin));
                         bounding.adjust(0, textMargin, 0, -textMargin);
                         QIcon aDrag = QIcon::fromTheme(QStringLiteral("audio-volume-medium"));
                         m_audioDragRect = bounding.toRect();
                         m_audioDragRect.setWidth(m_audioDragRect.height());
                         aDrag.paint(painter, m_audioDragRect, Qt::AlignLeft);
                         m_videoDragRect = m_audioDragRect;
                         m_videoDragRect.moveLeft(m_audioDragRect.right());
                         QIcon vDrag = QIcon::fromTheme(QStringLiteral("kdenlive-show-video"));
                         vDrag.paint(painter, m_videoDragRect, Qt::AlignLeft);
                     } else {
                         //m_audioDragRect = QRect();
                         //m_videoDragRect = QRect();
                     }
                 }
                 if (type == AbstractProjectItem::ClipItem) {
                     // Overlay icon if necessary
                     QVariant v = index.data(AbstractProjectItem::IconOverlay);
                     if (!v.isNull()) {
                         QIcon reload = QIcon::fromTheme(v.toString());
                         r.setTop(r.bottom() - bounding.height());
                         r.setWidth(bounding.height());
                         reload.paint(painter, r);
                     }
 
                     int jobProgress = index.data(AbstractProjectItem::JobProgress).toInt();
                     auto status = index.data(AbstractProjectItem::JobStatus).value<JobManagerStatus>();
                     if (status == JobManagerStatus::Pending || status == JobManagerStatus::Running) {
                         // Draw job progress bar
                         int progressWidth = option.fontMetrics.averageCharWidth() * 8;
                         int progressHeight = option.fontMetrics.ascent() / 4;
                         QRect progress(r1.x() + 1, opt.rect.bottom() - progressHeight - 2, progressWidth, progressHeight);
                         painter->setPen(Qt::NoPen);
                         painter->setBrush(Qt::darkGray);
                         if (status == JobManagerStatus::Running) {
                             painter->drawRoundedRect(progress, 2, 2);
                             painter->setBrush((option.state & static_cast<int>((QStyle::State_Selected) != 0)) != 0 ? option.palette.text()
                                                                                                                     : option.palette.highlight());
                             progress.setWidth((progressWidth - 2) * jobProgress / 100);
                             painter->drawRoundedRect(progress, 2, 2);
                         } else {
                             // Draw kind of a pause icon
                             progress.setWidth(3);
                             painter->drawRect(progress);
                             progress.moveLeft(progress.right() + 3);
                             painter->drawRect(progress);
                         }
                     }
                     bool jobsucceeded = index.data(AbstractProjectItem::JobSuccess).toBool();
                     if (!jobsucceeded) {
                         QIcon warning = QIcon::fromTheme(QStringLiteral("process-stop"));
                         warning.paint(painter, r2);
                     }
                 }
             } else {
                 // Folder
                 int decoWidth = 0;
                 if (opt.decorationSize.height() > 0) {
                     r.setWidth(r.height() * m_dar);
                     QPixmap pix = opt.icon.pixmap(opt.icon.actualSize(r.size()));
                     // Draw icon
                     decoWidth += r.width() + textMargin;
                     r.setWidth(r.height() * pix.width() / pix.height());
                     painter->drawPixmap(r, pix, QRect(0, 0, pix.width(), pix.height()));
                 }
                 r1.adjust(decoWidth, 0, 0, 0);
                 QRectF bounding;
                 painter->drawText(r1, Qt::AlignLeft | Qt::AlignTop, index.data(AbstractProjectItem::DataName).toString(), &bounding);
             }
             painter->restore();
         } else {
             QStyledItemDelegate::paint(painter, option, index);
         }
     }
 
     int getFrame(QModelIndex index, int mouseX)
     {
         int type = index.data(AbstractProjectItem::ItemTypeRole).toInt();
         if ((type != AbstractProjectItem::ClipItem && type != AbstractProjectItem::SubClipItem) || mouseX < m_thumbRect.x() || mouseX > m_thumbRect.right()) {
             return 0;
         }
         return 100 * (mouseX - m_thumbRect.x()) / m_thumbRect.width();
     }
 
 private:
     mutable bool m_editorOpen{false};
     mutable QRect m_audioDragRect;
     mutable QRect m_videoDragRect;
     mutable QRect m_thumbRect;
     double m_dar{1.778};
 
 public:
     PlaylistState::ClipState dragType{PlaylistState::Disabled};
 };
 
 /**
  * @class BinListItemDelegate
  * @brief This class is responsible for drawing items in the QListView.
  */
 
 class BinListItemDelegate : public QStyledItemDelegate
 {
 public:
     explicit BinListItemDelegate(QObject *parent = nullptr)
         : QStyledItemDelegate(parent)
 
     {
         connect(this, &QStyledItemDelegate::closeEditor, [&]() { m_editorOpen = false; });
     }
     void setDar(double dar) { m_dar = dar; }
     
     bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index) override
     {
         Q_UNUSED(model);
         Q_UNUSED(option);
         Q_UNUSED(index);
         if (event->type() == QEvent::MouseButtonPress) {
             auto *me = (QMouseEvent *)event;
             if (m_audioDragRect.contains(me->pos())) {
                 dragType = PlaylistState::AudioOnly;
             } else if (m_videoDragRect.contains(me->pos())) {
                 dragType = PlaylistState::VideoOnly;
             } else {
                 dragType = PlaylistState::Disabled;
             }
         }
         event->ignore();
         return false;
     }
 
     void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
     {
         if (!index.data().isNull()) {
             QStyleOptionViewItem opt(option);
             initStyleOption(&opt, index);
             QStyledItemDelegate::paint(painter, option, index);
             int adjust = (opt.rect.width() - opt.decorationSize.width()) / 2;
             QRect rect(opt.rect.x(), opt.rect.y(), opt.decorationSize.width(), opt.decorationSize.height());
             m_thumbRect = adjust > 0 && adjust < rect.width() ? rect.adjusted(adjust, 0, -adjust, 0) : rect;
             // Add audio/video icons for selective drag
                     int cType = index.data(AbstractProjectItem::ClipType).toInt();
                     bool hasAudioAndVideo = index.data(AbstractProjectItem::ClipHasAudioAndVideo).toBool();
                     if (hasAudioAndVideo && (cType == ClipType::AV || cType == ClipType::Playlist) && (opt.state & QStyle::State_MouseOver)) {
                         QRect thumbRect = m_thumbRect;
                         int iconSize = painter->boundingRect(thumbRect, Qt::AlignLeft, QStringLiteral("O")).height();
                         thumbRect.setLeft(opt.rect.right() - iconSize - 4);
                         thumbRect.setWidth(iconSize);
                         thumbRect.setBottom(m_thumbRect.top() + iconSize);
                         QIcon aDrag = QIcon::fromTheme(QStringLiteral("audio-volume-medium"));
                         m_audioDragRect = thumbRect;
                         aDrag.paint(painter, m_audioDragRect, Qt::AlignRight);
                         m_videoDragRect = m_audioDragRect;
                         m_videoDragRect.moveTop(thumbRect.bottom());
                         QIcon vDrag = QIcon::fromTheme(QStringLiteral("kdenlive-show-video"));
                         vDrag.paint(painter, m_videoDragRect, Qt::AlignRight);
                     } else {
                         //m_audioDragRect = QRect();
                         //m_videoDragRect = QRect();
                     }
             
         }
     }
 
     int getFrame(QModelIndex index, int mouseX)
     {
         int type = index.data(AbstractProjectItem::ItemTypeRole).toInt();
         if ((type != AbstractProjectItem::ClipItem && type != AbstractProjectItem::SubClipItem)|| mouseX < m_thumbRect.x() || mouseX > m_thumbRect.right()) {
             return 0;
         }
         return 100 * (mouseX - m_thumbRect.x()) / m_thumbRect.width();
     }
 
 private:
     mutable bool m_editorOpen{false};
     mutable QRect m_audioDragRect;
     mutable QRect m_videoDragRect;
     mutable QRect m_thumbRect;
     double m_dar{1.778};
 
 public:
     PlaylistState::ClipState dragType{PlaylistState::Disabled};
 };
 
 
 MyListView::MyListView(QWidget *parent)
     : QListView(parent)
 {
     setViewMode(QListView::IconMode);
     setMovement(QListView::Static);
     setResizeMode(QListView::Adjust);
     setWordWrap(true);
     setDragDropMode(QAbstractItemView::DragDrop);
     setAcceptDrops(true);
     setDragEnabled(true);
     viewport()->setAcceptDrops(true);
 }
 
 void MyListView::focusInEvent(QFocusEvent *event)
 {
     QListView::focusInEvent(event);
     if (event->reason() == Qt::MouseFocusReason) {
         emit focusView();
     }
 }
 
 void MyListView::mousePressEvent(QMouseEvent *event)
 {
     QListView::mousePressEvent(event);
     if (event->button() == Qt::LeftButton) {
         m_startPos = event->pos();
         QModelIndex ix = indexAt(m_startPos);
         if (ix.isValid()) {
             QAbstractItemDelegate *del = itemDelegate(ix);
             m_dragType = static_cast<BinListItemDelegate *>(del)->dragType;
         } else {
             m_dragType = PlaylistState::Disabled;
         }
         emit updateDragMode(m_dragType);
     }
 }
 
 void MyListView::mouseMoveEvent(QMouseEvent *event)
 {
     if (event->modifiers() == Qt::ShiftModifier) {
         QModelIndex index = indexAt(event->pos());
         if (index.isValid()) {
             QAbstractItemDelegate *del = itemDelegate(index);
             if (del) {
                 auto delegate = static_cast<BinListItemDelegate *>(del);
                 QRect vRect = visualRect(index);
                 int frame = delegate->getFrame(index, event->pos().x() - vRect.x());
                 emit displayBinFrame(index, frame);
             } else {
                 qDebug()<<"<<< NO DELEGATE!!!";
             }
         }
     }
     QListView::mouseMoveEvent(event);
 }
 
 MyTreeView::MyTreeView(QWidget *parent)
     : QTreeView(parent)
 {
     setEditing(false);
 }
 
 void MyTreeView::mousePressEvent(QMouseEvent *event)
 {
     QTreeView::mousePressEvent(event);
     if (event->button() == Qt::LeftButton) {
         m_startPos = event->pos();
         QModelIndex ix = indexAt(m_startPos);
         if (ix.isValid()) {
             QAbstractItemDelegate *del = itemDelegate(ix);
             m_dragType = static_cast<BinItemDelegate *>(del)->dragType;
         } else {
             m_dragType = PlaylistState::Disabled;
         }
     }
 }
 
 void MyTreeView::focusInEvent(QFocusEvent *event)
 {
     QTreeView::focusInEvent(event);
     if (event->reason() == Qt::MouseFocusReason) {
         emit focusView();
     }
 }
 
 void MyTreeView::mouseMoveEvent(QMouseEvent *event)
 {
     bool dragged = false;
     if ((event->buttons() & Qt::LeftButton) != 0u) {
         int distance = (event->pos() - m_startPos).manhattanLength();
         if (distance >= QApplication::startDragDistance()) {
             dragged = performDrag();
         }
     } else if (event->modifiers() == Qt::ShiftModifier) {
         QModelIndex index = indexAt(event->pos());
         if (index.isValid()) {
             QAbstractItemDelegate *del = itemDelegate(index);
             int frame = static_cast<BinItemDelegate *>(del)->getFrame(index, event->pos().x());
             emit displayBinFrame(index, frame);
         }
     }
     if (!dragged) {
         QTreeView::mouseMoveEvent(event);
     }
 }
 
 void MyTreeView::closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHint hint)
 {
     QAbstractItemView::closeEditor(editor, hint);
     setEditing(false);
 }
 
 void MyTreeView::editorDestroyed(QObject *editor)
 {
     QAbstractItemView::editorDestroyed(editor);
     setEditing(false);
 }
 
 bool MyTreeView::isEditing() const
 {
     return state() == QAbstractItemView::EditingState;
 }
 
 void MyTreeView::setEditing(bool edit)
 {
     setState(edit ? QAbstractItemView::EditingState : QAbstractItemView::NoState);
 }
 
 bool MyTreeView::performDrag()
 {
     QModelIndexList bases = selectedIndexes();
     QModelIndexList indexes;
     for (int i = 0; i < bases.count(); i++) {
         if (bases.at(i).column() == 0) {
             indexes << bases.at(i);
         }
     }
     if (indexes.isEmpty()) {
         return false;
     }
     // Check if we want audio or video only
     emit updateDragMode(m_dragType);
     auto *drag = new QDrag(this);
     drag->setMimeData(model()->mimeData(indexes));
     QModelIndex ix = indexes.constFirst();
     if (ix.isValid()) {
         QIcon icon = ix.data(AbstractProjectItem::DataThumbnail).value<QIcon>();
         QPixmap pix = icon.pixmap(iconSize());
         QSize size = pix.size();
         QImage image(size, QImage::Format_ARGB32_Premultiplied);
         image.fill(Qt::transparent);
         QPainter p(&image);
         p.setOpacity(0.7);
         p.drawPixmap(0, 0, pix);
         p.setOpacity(1);
         if (indexes.count() > 1) {
             QPalette palette;
             int radius = size.height() / 3;
             p.setBrush(palette.highlight());
             p.setPen(palette.highlightedText().color());
             p.drawEllipse(QPoint(size.width() / 2, size.height() / 2), radius, radius);
             p.drawText(size.width() / 2 - radius, size.height() / 2 - radius, 2 * radius, 2 * radius, Qt::AlignCenter, QString::number(indexes.count()));
         }
         p.end();
         drag->setPixmap(QPixmap::fromImage(image));
     }
     drag->exec();
     return true;
 }
 
 SmallJobLabel::SmallJobLabel(QWidget *parent)
     : QPushButton(parent)
 
 {
     setFixedWidth(0);
     setFlat(true);
     m_timeLine = new QTimeLine(500, this);
     QObject::connect(m_timeLine, &QTimeLine::valueChanged, this, &SmallJobLabel::slotTimeLineChanged);
     QObject::connect(m_timeLine, &QTimeLine::finished, this, &SmallJobLabel::slotTimeLineFinished);
     hide();
 }
 
 const QString SmallJobLabel::getStyleSheet(const QPalette &p)
 {
     KColorScheme scheme(p.currentColorGroup(), KColorScheme::Window);
     QColor bg = scheme.background(KColorScheme::LinkBackground).color();
     QColor fg = scheme.foreground(KColorScheme::LinkText).color();
     QString style =
         QStringLiteral("QPushButton {margin:3px;padding:2px;background-color: rgb(%1, %2, %3);border-radius: 4px;border: none;color: rgb(%4, %5, %6)}")
             .arg(bg.red())
             .arg(bg.green())
             .arg(bg.blue())
             .arg(fg.red())
             .arg(fg.green())
             .arg(fg.blue());
 
     bg = scheme.background(KColorScheme::ActiveBackground).color();
     fg = scheme.foreground(KColorScheme::ActiveText).color();
     style.append(
         QStringLiteral("\nQPushButton:hover {margin:3px;padding:2px;background-color: rgb(%1, %2, %3);border-radius: 4px;border: none;color: rgb(%4, %5, %6)}")
             .arg(bg.red())
             .arg(bg.green())
             .arg(bg.blue())
             .arg(fg.red())
             .arg(fg.green())
             .arg(fg.blue()));
 
     return style;
 }
 
 void SmallJobLabel::setAction(QAction *action)
 {
     m_action = action;
 }
 
 void SmallJobLabel::slotTimeLineChanged(qreal value)
 {
     setFixedWidth(qMin(value * 2, qreal(1.0)) * sizeHint().width());
     update();
 }
 
 void SmallJobLabel::slotTimeLineFinished()
 {
     if (m_timeLine->direction() == QTimeLine::Forward) {
         // Show
         m_action->setVisible(true);
     } else {
         // Hide
         m_action->setVisible(false);
         setText(QString());
     }
 }
 
 void SmallJobLabel::slotSetJobCount(int jobCount)
 {
     QMutexLocker lk(&m_locker);
     if (jobCount > 0) {
         // prepare animation
         setText(i18np("%1 job", "%1 jobs", jobCount));
         setToolTip(i18np("%1 pending job", "%1 pending jobs", jobCount));
 
         if (style()->styleHint(QStyle::SH_Widget_Animate, nullptr, this) != 0) {
             setFixedWidth(sizeHint().width());
             m_action->setVisible(true);
             return;
         }
 
         if (m_action->isVisible()) {
             setFixedWidth(sizeHint().width());
             update();
             return;
         }
 
         setFixedWidth(0);
         m_action->setVisible(true);
         int wantedWidth = sizeHint().width();
         setGeometry(-wantedWidth, 0, wantedWidth, height());
         m_timeLine->setDirection(QTimeLine::Forward);
         if (m_timeLine->state() == QTimeLine::NotRunning) {
             m_timeLine->start();
         }
     } else {
         if (style()->styleHint(QStyle::SH_Widget_Animate, nullptr, this) != 0) {
             setFixedWidth(0);
             m_action->setVisible(false);
             return;
         }
         // hide
         m_timeLine->setDirection(QTimeLine::Backward);
         if (m_timeLine->state() == QTimeLine::NotRunning) {
             m_timeLine->start();
         }
     }
 }
 
 LineEventEater::LineEventEater(QObject *parent)
     : QObject(parent)
 {
 }
 
 bool LineEventEater::eventFilter(QObject *obj, QEvent *event)
 {
     switch (event->type()) {
     case QEvent::ShortcutOverride:
         if (((QKeyEvent *)event)->key() == Qt::Key_Escape) {
             emit clearSearchLine();
         }
         break;
     case QEvent::Resize:
         // Workaround Qt BUG 54676
         emit showClearButton(((QResizeEvent *)event)->size().width() > QFontMetrics(QApplication::font()).averageCharWidth() * 8);
         break;
     default:
         break;
     }
     return QObject::eventFilter(obj, event);
 }
 
 Bin::Bin(std::shared_ptr<ProjectItemModel> model, QWidget *parent)
     : QWidget(parent)
     , isLoading(false)
     , m_itemModel(std::move(model))
     , m_itemView(nullptr)
     , m_doc(nullptr)
     , m_extractAudioAction(nullptr)
     , m_transcodeAction(nullptr)
     , m_clipsActionsMenu(nullptr)
     , m_inTimelineAction(nullptr)
     , m_listType((BinViewType)KdenliveSettings::binMode())
     , m_iconSize(160, 90)
     , m_propertiesPanel(nullptr)
     , m_blankThumb()
     , m_invalidClipDialog(nullptr)
     , m_gainedFocus(false)
     , m_audioDuration(0)
     , m_processedAudio(0)
 {
     m_layout = new QVBoxLayout(this);
 
     // Create toolbar for buttons
     m_toolbar = new QToolBar(this);
     int size = style()->pixelMetric(QStyle::PM_SmallIconSize);
     QSize iconSize(size, size);
     m_toolbar->setIconSize(iconSize);
     m_toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
     m_layout->addWidget(m_toolbar);
     m_layout->setSpacing(0);
     m_layout->setContentsMargins(0, 0, 0, 0);
     // Search line
     m_searchLine = new QLineEdit(this);
     m_searchLine->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Preferred);
     // m_searchLine->setClearButtonEnabled(true);
     m_searchLine->setPlaceholderText(i18n("Search..."));
     m_searchLine->setFocusPolicy(Qt::ClickFocus);
 
     auto *leventEater = new LineEventEater(this);
     m_searchLine->installEventFilter(leventEater);
     connect(leventEater, &LineEventEater::clearSearchLine, m_searchLine, &QLineEdit::clear);
     connect(leventEater, &LineEventEater::showClearButton, this, &Bin::showClearButton);
 
     setFocusPolicy(Qt::ClickFocus);
 
     connect(m_itemModel.get(), &ProjectItemModel::refreshPanel, this, &Bin::refreshPanel);
     connect(m_itemModel.get(), &ProjectItemModel::refreshClip, this, &Bin::refreshClip);
 
     connect(m_itemModel.get(), static_cast<void (ProjectItemModel::*)(const QStringList &, const QModelIndex &)>(&ProjectItemModel::itemDropped), this,
             static_cast<void (Bin::*)(const QStringList &, const QModelIndex &)>(&Bin::slotItemDropped));
     connect(m_itemModel.get(), static_cast<void (ProjectItemModel::*)(const QList<QUrl> &, const QModelIndex &)>(&ProjectItemModel::itemDropped), this,
             static_cast<void (Bin::*)(const QList<QUrl> &, const QModelIndex &)>(&Bin::slotItemDropped));
     connect(m_itemModel.get(), &ProjectItemModel::effectDropped, this, &Bin::slotEffectDropped);
     connect(m_itemModel.get(), &QAbstractItemModel::dataChanged, this, &Bin::slotItemEdited);
     connect(this, &Bin::refreshPanel, this, &Bin::doRefreshPanel);
 
     // Zoom slider
     QWidget *container = new QWidget(this);
     auto *lay = new QHBoxLayout;
     m_slider = new QSlider(Qt::Horizontal, this);
     m_slider->setMaximumWidth(100);
     m_slider->setMinimumWidth(40);
     m_slider->setRange(0, 10);
     m_slider->setValue(KdenliveSettings::bin_zoom());
     connect(m_slider, &QAbstractSlider::valueChanged, this, &Bin::slotSetIconSize);
     auto *tb1 = new QToolButton(this);
     tb1->setIcon(QIcon::fromTheme(QStringLiteral("zoom-in")));
     connect(tb1, &QToolButton::clicked, [&]() { m_slider->setValue(qMin(m_slider->value() + 1, m_slider->maximum())); });
     auto *tb2 = new QToolButton(this);
     tb2->setIcon(QIcon::fromTheme(QStringLiteral("zoom-out")));
     connect(tb2, &QToolButton::clicked, [&]() { m_slider->setValue(qMax(m_slider->value() - 1, m_slider->minimum())); });
     lay->addWidget(tb2);
     lay->addWidget(m_slider);
     lay->addWidget(tb1);
     container->setLayout(lay);
     auto *widgetslider = new QWidgetAction(this);
     widgetslider->setDefaultWidget(container);
 
     // View type
     KSelectAction *listType = new KSelectAction(QIcon::fromTheme(QStringLiteral("view-list-tree")), i18n("View Mode"), this);
     pCore->window()->actionCollection()->addAction(QStringLiteral("bin_view_mode"), listType);
     QAction *treeViewAction = listType->addAction(QIcon::fromTheme(QStringLiteral("view-list-tree")), i18n("Tree View"));
     listType->addAction(treeViewAction);
     treeViewAction->setData(BinTreeView);
     if (m_listType == treeViewAction->data().toInt()) {
         listType->setCurrentAction(treeViewAction);
     }
     pCore->window()->actionCollection()->addAction(QStringLiteral("bin_view_mode_tree"), treeViewAction);
 
     QAction *iconViewAction = listType->addAction(QIcon::fromTheme(QStringLiteral("view-list-icons")), i18n("Icon View"));
     iconViewAction->setData(BinIconView);
     if (m_listType == iconViewAction->data().toInt()) {
         listType->setCurrentAction(iconViewAction);
     }
     pCore->window()->actionCollection()->addAction(QStringLiteral("bin_view_mode_icon"), iconViewAction);
 
+    // Sort menu
+    m_sortDescend = new QAction(i18n("Descending"), this);
+    m_sortDescend->setCheckable(true);
+    m_sortDescend->setChecked(KdenliveSettings::binSorting() > 99);
+    connect(m_sortDescend, &QAction::triggered, [&] () {
+        if (m_sortGroup->checkedAction()) {
+            if ((m_itemView != nullptr) && m_listType == BinTreeView) {
+                auto *view = static_cast<QTreeView *>(m_itemView);
+                view->header()->setSortIndicator(m_sortGroup->checkedAction()->data().toInt(), m_sortDescend->isChecked() ? Qt::DescendingOrder : Qt::AscendingOrder);
+            } else {
+                m_proxyModel->sort(m_sortGroup->checkedAction()->data().toInt(), m_sortDescend->isChecked() ? Qt::DescendingOrder : Qt::AscendingOrder);
+            }
+        }
+    });
+
+    QMenu *sort = new QMenu(i18n("Sort By"), this);
+    int binSort = KdenliveSettings::binSorting() % 100;
+    m_sortGroup = new QActionGroup(sort);
+    QAction *sortByName = new QAction(i18n("Name"), m_sortGroup);
+    sortByName->setCheckable(true);
+    sortByName->setData(0);
+    sortByName->setChecked(binSort == 0);
+    QAction *sortByDate = new QAction(i18n("Date"), m_sortGroup);
+    sortByDate->setCheckable(true);
+    sortByDate->setData(1);
+    sortByDate->setChecked(binSort == 1);
+    QAction *sortByDesc = new QAction(i18n("Description"), m_sortGroup);
+    sortByDesc->setCheckable(true);
+    sortByDesc->setData(2);
+    sortByDesc->setChecked(binSort == 2);
+    QAction *sortByType = new QAction(i18n("Type"), m_sortGroup);
+    sortByType->setCheckable(true);
+    sortByType->setData(3);
+    sortByType->setChecked(binSort == 3);
+    sort->addAction(sortByName);
+    sort->addAction(sortByDate);
+    sort->addAction(sortByType);
+    sort->addAction(sortByDesc);
+    sort->addSeparator();
+    sort->addAction(m_sortDescend);
+    connect(m_sortGroup, &QActionGroup::triggered, [&] (QAction *ac) {
+        if ((m_itemView != nullptr) && m_listType == BinTreeView) {
+            auto *view = static_cast<QTreeView *>(m_itemView);
+            view->header()->setSortIndicator(ac->data().toInt(), m_sortDescend->isChecked() ? Qt::DescendingOrder : Qt::AscendingOrder);
+        } else {
+            m_proxyModel->sort(ac->data().toInt(), m_sortDescend->isChecked() ? Qt::DescendingOrder : Qt::AscendingOrder);
+        }
+    });
+
     QAction *disableEffects = new QAction(i18n("Disable Bin Effects"), this);
     connect(disableEffects, &QAction::triggered, [this](bool disable) { this->setBinEffectsEnabled(!disable); });
     disableEffects->setIcon(QIcon::fromTheme(QStringLiteral("favorite")));
     disableEffects->setData("disable_bin_effects");
     disableEffects->setCheckable(true);
     disableEffects->setChecked(false);
     pCore->window()->actionCollection()->addAction(QStringLiteral("disable_bin_effects"), disableEffects);
 
     listType->setToolBarMode(KSelectAction::MenuMode);
     connect(listType, static_cast<void (KSelectAction::*)(QAction *)>(&KSelectAction::triggered), this, &Bin::slotInitView);
 
     // Settings menu
     QMenu *settingsMenu = new QMenu(i18n("Settings"), this);
     settingsMenu->addAction(listType);
     QMenu *sliderMenu = new QMenu(i18n("Zoom"), this);
     sliderMenu->setIcon(QIcon::fromTheme(QStringLiteral("zoom-in")));
     sliderMenu->addAction(widgetslider);
     settingsMenu->addMenu(sliderMenu);
+    settingsMenu->addMenu(sort);
 
     // Column show / hide actions
     m_showDate = new QAction(i18n("Show date"), this);
     m_showDate->setCheckable(true);
     connect(m_showDate, &QAction::triggered, this, &Bin::slotShowDateColumn);
     m_showDesc = new QAction(i18n("Show description"), this);
     m_showDesc->setCheckable(true);
     connect(m_showDesc, &QAction::triggered, this, &Bin::slotShowDescColumn);
     settingsMenu->addAction(m_showDate);
     settingsMenu->addAction(m_showDesc);
     settingsMenu->addAction(disableEffects);
     auto *button = new QToolButton;
     button->setIcon(QIcon::fromTheme(QStringLiteral("kdenlive-menu")));
     button->setToolTip(i18n("Options"));
     button->setMenu(settingsMenu);
     button->setPopupMode(QToolButton::InstantPopup);
     m_toolbar->addWidget(button);
 
     // small info button for pending jobs
     m_infoLabel = new SmallJobLabel(this);
     m_infoLabel->setStyleSheet(SmallJobLabel::getStyleSheet(palette()));
     connect(pCore->jobManager().get(), &JobManager::jobCount, m_infoLabel, &SmallJobLabel::slotSetJobCount);
     QAction *infoAction = m_toolbar->addWidget(m_infoLabel);
     m_jobsMenu = new QMenu(this);
     // connect(m_jobsMenu, &QMenu::aboutToShow, this, &Bin::slotPrepareJobsMenu);
     m_cancelJobs = new QAction(i18n("Cancel All Jobs"), this);
     m_cancelJobs->setCheckable(false);
     m_discardCurrentClipJobs = new QAction(i18n("Cancel Current Clip Jobs"), this);
     m_discardCurrentClipJobs->setCheckable(false);
     m_discardPendingJobs = new QAction(i18n("Cancel Pending Jobs"), this);
     m_discardPendingJobs->setCheckable(false);
     m_jobsMenu->addAction(m_cancelJobs);
     m_jobsMenu->addAction(m_discardCurrentClipJobs);
     m_jobsMenu->addAction(m_discardPendingJobs);
     m_infoLabel->setMenu(m_jobsMenu);
     m_infoLabel->setAction(infoAction);
 
     connect(m_discardCurrentClipJobs, &QAction::triggered, [&]() {
         const QString currentId = m_monitor->activeClipId();
         if (!currentId.isEmpty()) {
             pCore->jobManager()->discardJobs(currentId);
         }
     });
     connect(m_cancelJobs, &QAction::triggered, [&]() {
         pCore->jobManager()->slotCancelJobs();
     });
     connect(m_discardPendingJobs, &QAction::triggered, [&]() {
         pCore->jobManager()->slotCancelPendingJobs();
     });
 
     // Hack, create toolbar spacer
     QWidget *spacer = new QWidget();
     spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     m_toolbar->addWidget(spacer);
 
     // Add search line
     m_toolbar->addWidget(m_searchLine);
 
     m_binTreeViewDelegate = new BinItemDelegate(this);
     m_binListViewDelegate = new BinListItemDelegate(this);
     // connect(pCore->projectManager(), SIGNAL(projectOpened(Project*)), this, SLOT(setProject(Project*)));
     m_headerInfo = QByteArray::fromBase64(KdenliveSettings::treeviewheaders().toLatin1());
     m_propertiesPanel = new QScrollArea(this);
     m_propertiesPanel->setFrameShape(QFrame::NoFrame);
     // Insert listview
     m_itemView = new MyTreeView(this);
     m_layout->addWidget(m_itemView);
     // Info widget for failed jobs, other errors
     m_infoMessage = new KMessageWidget(this);
     m_layout->addWidget(m_infoMessage);
     m_infoMessage->setCloseButtonVisible(false);
     connect(m_infoMessage, &KMessageWidget::hideAnimationFinished, this, &Bin::slotResetInfoMessage);
     // m_infoMessage->setWordWrap(true);
     m_infoMessage->hide();
     connect(this, &Bin::requesteInvalidRemoval, this, &Bin::slotQueryRemoval);
     connect(this, SIGNAL(displayBinMessage(QString, KMessageWidget::MessageType)), this, SLOT(doDisplayMessage(QString, KMessageWidget::MessageType)));
     wheelAccumulatedDelta = 0;
 }
 
 Bin::~Bin()
 {
     pCore->jobManager()->slotCancelJobs();
     blockSignals(true);
     m_proxyModel->selectionModel()->blockSignals(true);
     setEnabled(false);
     m_propertiesPanel = nullptr;
     abortOperations();
     m_itemModel->clean();
 }
 
 QDockWidget *Bin::clipPropertiesDock()
 {
     return m_propertiesDock;
 }
 
 void Bin::abortOperations()
 {
     m_infoMessage->hide();
     blockSignals(true);
     if (m_propertiesPanel) {
         for (QWidget *w : m_propertiesPanel->findChildren<ClipPropertiesController *>()) {
             delete w;
         }
     }
     delete m_itemView;
     m_itemView = nullptr;
     blockSignals(false);
 }
 
 bool Bin::eventFilter(QObject *obj, QEvent *event)
 {
     if (event->type() == QEvent::MouseButtonRelease) {
         if (!m_monitor->isActive()) {
             m_monitor->slotActivateMonitor();
         }
         bool success = QWidget::eventFilter(obj, event);
         if (m_gainedFocus) {
             auto *mouseEvent = static_cast<QMouseEvent *>(event);
             auto *view = qobject_cast<QAbstractItemView *>(obj->parent());
             if (view) {
                 QModelIndex idx = view->indexAt(mouseEvent->pos());
                 m_gainedFocus = false;
                 if (idx.isValid() && m_proxyModel) {
                     std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(idx));
                     editMasterEffect(item);
                 } else {
                     editMasterEffect(nullptr);
                 }
             }
             // make sure we discard the focus indicator
             m_gainedFocus = false;
         }
         return success;
     }
     if (event->type() == QEvent::MouseButtonDblClick) {
         auto *mouseEvent = static_cast<QMouseEvent *>(event);
         auto *view = qobject_cast<QAbstractItemView *>(obj->parent());
         if (view) {
             QModelIndex idx = view->indexAt(mouseEvent->pos());
             if (!idx.isValid()) {
                 // User double clicked on empty area
                 slotAddClip();
             } else {
                 slotItemDoubleClicked(idx, mouseEvent->pos());
             }
         } else {
             qCDebug(KDENLIVE_LOG) << " +++++++ NO VIEW-------!!";
         }
         return true;
     }
     if (event->type() == QEvent::Wheel) {
         auto *e = static_cast<QWheelEvent *>(event);
         if ((e != nullptr) && e->modifiers() == Qt::ControlModifier) {
             wheelAccumulatedDelta += e->delta();
             if (abs(wheelAccumulatedDelta) >= QWheelEvent::DefaultDeltasPerStep) {
                 slotZoomView(wheelAccumulatedDelta > 0);
             }
             // emit zoomView(e->delta() > 0);
             return true;
         }
     }
     return QWidget::eventFilter(obj, event);
 }
 
 void Bin::refreshIcons()
 {
     QList<QMenu *> allMenus = this->findChildren<QMenu *>();
     for (int i = 0; i < allMenus.count(); i++) {
         QMenu *m = allMenus.at(i);
         QIcon ic = m->icon();
         if (ic.isNull() || ic.name().isEmpty()) {
             continue;
         }
         QIcon newIcon = QIcon::fromTheme(ic.name());
         m->setIcon(newIcon);
     }
     QList<QToolButton *> allButtons = this->findChildren<QToolButton *>();
     for (int i = 0; i < allButtons.count(); i++) {
         QToolButton *m = allButtons.at(i);
         QIcon ic = m->icon();
         if (ic.isNull() || ic.name().isEmpty()) {
             continue;
         }
         QIcon newIcon = QIcon::fromTheme(ic.name());
         m->setIcon(newIcon);
     }
 }
 
 void Bin::slotSaveHeaders()
 {
     if ((m_itemView != nullptr) && m_listType == BinTreeView) {
         // save current treeview state (column width)
         auto *view = static_cast<QTreeView *>(m_itemView);
         m_headerInfo = view->header()->saveState();
         KdenliveSettings::setTreeviewheaders(m_headerInfo.toBase64());
+        int ix = view->header()->sortIndicatorSection();
+        updateSortingAction(ix);
+        m_sortDescend->setChecked(view->header()->sortIndicatorOrder() == Qt::DescendingOrder);
+    }
+    if (m_sortGroup->checkedAction()) {
+        KdenliveSettings::setBinSorting(m_sortGroup->checkedAction()->data().toInt() + (m_sortDescend->isChecked() ? 100 : 0));
+    }
+}
+
+void Bin::updateSortingAction(int ix)
+{
+    for (QAction *ac : m_sortGroup->actions()) {
+        if (ac->data().toInt() == ix) {
+            ac->setChecked(true);
+        }
     }
 }
 
 void Bin::slotZoomView(bool zoomIn)
 {
     wheelAccumulatedDelta = 0;
     if (m_itemModel->rowCount() == 0) {
         // Don't zoom on empty bin
         return;
     }
     int progress = (zoomIn) ? 1 : -1;
     m_slider->setValue(m_slider->value() + progress);
 }
 
 Monitor *Bin::monitor()
 {
     return m_monitor;
 }
 
 void Bin::slotAddClip()
 {
     // Check if we are in a folder
     QString parentFolder = getCurrentFolder();
     ClipCreationDialog::createClipsCommand(m_doc, parentFolder, m_itemModel);
 }
 
 std::shared_ptr<ProjectClip> Bin::getFirstSelectedClip()
 {
     const QModelIndexList indexes = m_proxyModel->selectionModel()->selectedIndexes();
     if (indexes.isEmpty()) {
         return std::shared_ptr<ProjectClip>();
     }
     for (const QModelIndex &ix : indexes) {
         std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(ix));
         if (item->itemType() == AbstractProjectItem::ClipItem) {
             auto clip = std::static_pointer_cast<ProjectClip>(item);
             if (clip) {
                 return clip;
             }
         }
     }
     return nullptr;
 }
 
 void Bin::slotDeleteClip()
 {
     const QModelIndexList indexes = m_proxyModel->selectionModel()->selectedIndexes();
     std::vector<std::shared_ptr<AbstractProjectItem>> items;
     bool included = false;
     bool usedFolder = false;
     auto checkInclusion = [](bool accum, std::shared_ptr<TreeItem> item) {
         return accum || std::static_pointer_cast<AbstractProjectItem>(item)->isIncludedInTimeline();
     };
     for (const QModelIndex &ix : indexes) {
         if (!ix.isValid() || ix.column() != 0) {
             continue;
         }
         std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(ix));
         if (!item) {
             qDebug() << "Suspicious: item not found when trying to delete";
             continue;
         }
         included = included || item->accumulate(false, checkInclusion);
         // Check if we are deleting non-empty folders:
         usedFolder = usedFolder || item->childCount() > 0;
         items.push_back(item);
     }
     if (included && (KMessageBox::warningContinueCancel(this, i18n("This will delete all selected clips from the timeline")) != KMessageBox::Continue)) {
         return;
     }
     if (usedFolder && (KMessageBox::warningContinueCancel(this, i18n("This will delete all folder content")) != KMessageBox::Continue)) {
         return;
     }
     Fun undo = []() { return true; };
     Fun redo = []() { return true; };
     for (const auto &item : items) {
         m_itemModel->requestBinClipDeletion(item, undo, redo);
     }
     pCore->pushUndo(undo, redo, i18n("Delete bin Clips"));
 }
 
 void Bin::slotReloadClip()
 {
     const QModelIndexList indexes = m_proxyModel->selectionModel()->selectedIndexes();
     for (const QModelIndex &ix : indexes) {
         if (!ix.isValid() || ix.column() != 0) {
             continue;
         }
         std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(ix));
         std::shared_ptr<ProjectClip> currentItem = nullptr;
         if (item->itemType() == AbstractProjectItem::ClipItem) {
             currentItem = std::static_pointer_cast<ProjectClip>(item);
         } else if (item->itemType() == AbstractProjectItem::SubClipItem) {
             currentItem = std::static_pointer_cast<ProjectSubClip>(item)->getMasterClip();
         }
         if (currentItem) {
             emit openClip(std::shared_ptr<ProjectClip>());
             if (currentItem->clipType() == ClipType::Playlist) {
                 // Check if a clip inside playlist is missing
                 QString path = currentItem->url();
                 QFile f(path);
                 QDomDocument doc;
                 doc.setContent(&f, false);
                 f.close();
                 DocumentChecker d(QUrl::fromLocalFile(path), doc);
                 if (!d.hasErrorInClips() && doc.documentElement().hasAttribute(QStringLiteral("modified"))) {
                     QString backupFile = path + QStringLiteral(".backup");
                     KIO::FileCopyJob *copyjob = KIO::file_copy(QUrl::fromLocalFile(path), QUrl::fromLocalFile(backupFile));
                     if (copyjob->exec()) {
                         if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
                             KMessageBox::sorry(this, i18n("Unable to write to file %1", path));
                         } else {
                             QTextStream out(&f);
                             out << doc.toString();
                             f.close();
                             KMessageBox::information(
                                 this,
                                 i18n("Your project file was modified by Kdenlive.\nTo make sure you do not lose data, a backup copy called %1 was created.",
                                      backupFile));
                         }
                     }
                 }
             }
             currentItem->reloadProducer(false, true);
         }
     }
 }
 
 void Bin::slotLocateClip()
 {
     const QModelIndexList indexes = m_proxyModel->selectionModel()->selectedIndexes();
     for (const QModelIndex &ix : indexes) {
         if (!ix.isValid() || ix.column() != 0) {
             continue;
         }
         std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(ix));
         std::shared_ptr<ProjectClip> currentItem = nullptr;
         if (item->itemType() == AbstractProjectItem::ClipItem) {
             currentItem = std::static_pointer_cast<ProjectClip>(item);
         } else if (item->itemType() == AbstractProjectItem::SubClipItem) {
             currentItem = std::static_pointer_cast<ProjectSubClip>(item)->getMasterClip();
         }
         if (currentItem) {
             QUrl url = QUrl::fromLocalFile(currentItem->url()).adjusted(QUrl::RemoveFilename);
             bool exists = QFile(url.toLocalFile()).exists();
             if (currentItem->hasUrl() && exists) {
                 QDesktopServices::openUrl(url);
                 qCDebug(KDENLIVE_LOG) << "  / / " + url.toString();
             } else {
                 if (!exists) {
                     pCore->displayMessage(i18n("Could not locate %1", url.toString()), ErrorMessage, 300);
                 }
                 return;
             }
         }
     }
 }
 
 void Bin::slotDuplicateClip()
 {
     const QModelIndexList indexes = m_proxyModel->selectionModel()->selectedIndexes();
     for (const QModelIndex &ix : indexes) {
         if (!ix.isValid() || ix.column() != 0) {
             continue;
         }
         std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(ix));
         if (item->itemType() == AbstractProjectItem::ClipItem) {
             auto currentItem = std::static_pointer_cast<ProjectClip>(item);
             if (currentItem) {
                 QDomDocument doc;
                 QDomElement xml = currentItem->toXml(doc);
                 if (!xml.isNull()) {
                     QString currentName = Xml::getXmlProperty(xml, QStringLiteral("kdenlive:clipname"));
                     if (currentName.isEmpty()) {
                         QUrl url = QUrl::fromLocalFile(Xml::getXmlProperty(xml, QStringLiteral("resource")));
                         if (url.isValid()) {
                             currentName = url.fileName();
                         }
                     }
                     if (!currentName.isEmpty()) {
                         currentName.append(i18nc("append to clip name to indicate a copied idem", " (copy)"));
                         Xml::setXmlProperty(xml, QStringLiteral("kdenlive:clipname"), currentName);
                     }
                     QString id;
                     m_itemModel->requestAddBinClip(id, xml, item->parent()->clipId(), i18n("Duplicate clip"));
                     selectClipById(id);
                 }
             }
         } else if (item->itemType() == AbstractProjectItem::SubClipItem) {
             auto currentItem = std::static_pointer_cast<ProjectSubClip>(item);
             QString id;
             QPoint clipZone = currentItem->zone();
             m_itemModel->requestAddBinSubClip(id, clipZone.x(), clipZone.y(), QString(), currentItem->getMasterClip()->clipId());
             selectClipById(id);
         }
     }
 }
 
 void Bin::setMonitor(Monitor *monitor)
 {
     m_monitor = monitor;
     connect(m_monitor, &Monitor::addClipToProject, this, &Bin::slotAddClipToProject);
     connect(m_monitor, &Monitor::refreshCurrentClip, this, &Bin::slotOpenCurrent);
     connect(this, &Bin::openClip, [&](std::shared_ptr<ProjectClip> clip, int in, int out) { m_monitor->slotOpenClip(clip, in, out); });
 }
 
 void Bin::setDocument(KdenliveDoc *project)
 {
     blockSignals(true);
     if (m_proxyModel) {
         m_proxyModel->selectionModel()->blockSignals(true);
     }
     setEnabled(false);
 
     // Cleanup previous project
     m_itemModel->clean();
     delete m_itemView;
     m_itemView = nullptr;
     m_doc = project;
     m_infoLabel->slotSetJobCount(0);
     int iconHeight = QFontInfo(font()).pixelSize() * 3.5;
     m_iconSize = QSize(iconHeight * pCore->getCurrentDar(), iconHeight);
     setEnabled(true);
     blockSignals(false);
     if (m_proxyModel) {
         m_proxyModel->selectionModel()->blockSignals(false);
     }
     connect(m_proxyAction, SIGNAL(toggled(bool)), m_doc, SLOT(slotProxyCurrentItem(bool)));
 
     // connect(m_itemModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), m_itemView
     // connect(m_itemModel, SIGNAL(updateCurrentItem()), this, SLOT(autoSelect()));
     slotInitView(nullptr);
     bool binEffectsDisabled = getDocumentProperty(QStringLiteral("disablebineffects")).toInt() == 1;
     setBinEffectsEnabled(!binEffectsDisabled);
 }
 
 void Bin::createClip(const QDomElement &xml)
 {
     // Check if clip should be in a folder
     QString groupId = ProjectClip::getXmlProperty(xml, QStringLiteral("kdenlive:folderid"));
     std::shared_ptr<ProjectFolder> parentFolder = m_itemModel->getFolderByBinId(groupId);
     if (!parentFolder) {
         parentFolder = m_itemModel->getRootFolder();
     }
     QString path = Xml::getXmlProperty(xml, QStringLiteral("resource"));
     if (path.endsWith(QStringLiteral(".mlt")) || path.endsWith(QStringLiteral(".kdenlive"))) {
         QFile f(path);
         QDomDocument doc;
         doc.setContent(&f, false);
         f.close();
         DocumentChecker d(QUrl::fromLocalFile(path), doc);
         if (!d.hasErrorInClips() && doc.documentElement().hasAttribute(QStringLiteral("modified"))) {
             QString backupFile = path + QStringLiteral(".backup");
             KIO::FileCopyJob *copyjob = KIO::file_copy(QUrl::fromLocalFile(path), QUrl::fromLocalFile(backupFile));
             if (copyjob->exec()) {
                 if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
                     KMessageBox::sorry(this, i18n("Unable to write to file %1", path));
                 } else {
                     QTextStream out(&f);
                     out << doc.toString();
                     f.close();
                     KMessageBox::information(
                         this, i18n("Your project file was modified by Kdenlive.\nTo make sure you do not lose data, a backup copy called %1 was created.",
                                    backupFile));
                 }
             }
         }
     }
     QString id = Xml::getTagContentByAttribute(xml, QStringLiteral("property"), QStringLiteral("name"), QStringLiteral("kdenlive:id"));
     if (id.isEmpty()) {
         id = QString::number(m_itemModel->getFreeClipId());
     }
     auto newClip = ProjectClip::construct(id, xml, m_blankThumb, m_itemModel);
     parentFolder->appendChild(newClip);
 }
 
 void Bin::slotAddFolder()
 {
     auto parentFolder = m_itemModel->getFolderByBinId(getCurrentFolder());
     qDebug() << "pranteforder id" << parentFolder->clipId();
     QString newId;
     Fun undo = []() { return true; };
     Fun redo = []() { return true; };
     m_itemModel->requestAddFolder(newId, i18n("Folder"), parentFolder->clipId(), undo, redo);
     pCore->pushUndo(undo, redo, i18n("Create bin folder"));
 
     // Edit folder name
     auto folder = m_itemModel->getFolderByBinId(newId);
     auto ix = m_itemModel->getIndexFromItem(folder);
     qDebug() << "selecting" << ix;
     if (ix.isValid()) {
         qDebug() << "ix valid";
         m_proxyModel->selectionModel()->clearSelection();
         int row = ix.row();
         const QModelIndex id = m_itemModel->index(row, 0, ix.parent());
         const QModelIndex id2 = m_itemModel->index(row, m_itemModel->columnCount() - 1, ix.parent());
         if (id.isValid() && id2.isValid()) {
             m_proxyModel->selectionModel()->select(QItemSelection(m_proxyModel->mapFromSource(id), m_proxyModel->mapFromSource(id2)),
                                                    QItemSelectionModel::Select);
         }
         m_itemView->edit(m_proxyModel->mapFromSource(ix));
     }
 }
 
 QModelIndex Bin::getIndexForId(const QString &id, bool folderWanted) const
 {
     QModelIndexList items = m_itemModel->match(m_itemModel->index(0, 0), AbstractProjectItem::DataId, QVariant::fromValue(id), 1, Qt::MatchRecursive);
     for (int i = 0; i < items.count(); i++) {
         std::shared_ptr<AbstractProjectItem> currentItem = m_itemModel->getBinItemByIndex(items.at(i));
         AbstractProjectItem::PROJECTITEMTYPE type = currentItem->itemType();
         if (folderWanted && type == AbstractProjectItem::FolderItem) {
             // We found our folder
             return items.at(i);
         }
         if (!folderWanted && type == AbstractProjectItem::ClipItem) {
             // We found our clip
             return items.at(i);
         }
     }
     return {};
 }
 
 void Bin::selectClipById(const QString &clipId, int frame, const QPoint &zone)
 {
     if (m_monitor->activeClipId() == clipId) {
         std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(clipId);
         if (clip) {
             QModelIndex ix = m_itemModel->getIndexFromItem(clip);
             int row = ix.row();
             const QModelIndex id = m_itemModel->index(row, 0, ix.parent());
             const QModelIndex id2 = m_itemModel->index(row, m_itemModel->columnCount() - 1, ix.parent());
             if (id.isValid() && id2.isValid()) {
                 m_proxyModel->selectionModel()->select(QItemSelection(m_proxyModel->mapFromSource(id), m_proxyModel->mapFromSource(id2)), QItemSelectionModel::SelectCurrent);
             }
             m_itemView->scrollTo(m_proxyModel->mapFromSource(ix), QAbstractItemView::PositionAtCenter);
         }
     } else {
         m_proxyModel->selectionModel()->clearSelection();
         std::shared_ptr<ProjectClip> clip = getBinClip(clipId);
         if (clip == nullptr) {
             return;
         }
         selectClip(clip);
     }
     if (frame > -1) {
         m_monitor->slotSeek(frame);
     } else {
         m_monitor->slotActivateMonitor();
     }
     if (!zone.isNull()) {
         m_monitor->slotLoadClipZone(zone);
     }
 }
 
 void Bin::selectProxyModel(const QModelIndex &id)
 {
     if (isLoading) {
         // return;
     }
     if (id.isValid()) {
         if (id.column() != 0) {
             return;
         }
         std::shared_ptr<AbstractProjectItem> currentItem = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(id));
         if (currentItem) {
             // Set item as current so that it displays its content in clip monitor
             setCurrent(currentItem);
             if (currentItem->itemType() == AbstractProjectItem::ClipItem) {
                 m_reloadAction->setEnabled(true);
                 m_locateAction->setEnabled(true);
                 m_duplicateAction->setEnabled(true);
                 std::shared_ptr<ProjectClip> clip = std::static_pointer_cast<ProjectClip>(currentItem);
                 ClipType::ProducerType type = clip->clipType();
                 m_openAction->setEnabled(type == ClipType::Image || type == ClipType::Audio || type == ClipType::Text || type == ClipType::TextTemplate);
                 showClipProperties(clip, false);
                 m_deleteAction->setText(i18n("Delete Clip"));
                 m_proxyAction->setText(i18n("Proxy Clip"));
             } else if (currentItem->itemType() == AbstractProjectItem::FolderItem) {
                 // A folder was selected, disable editing clip
                 m_openAction->setEnabled(false);
                 m_reloadAction->setEnabled(false);
                 m_locateAction->setEnabled(false);
                 m_duplicateAction->setEnabled(false);
                 m_deleteAction->setText(i18n("Delete Folder"));
                 m_proxyAction->setText(i18n("Proxy Folder"));
             } else if (currentItem->itemType() == AbstractProjectItem::SubClipItem) {
                 showClipProperties(std::static_pointer_cast<ProjectClip>(currentItem->parent()), false);
                 m_openAction->setEnabled(false);
                 m_reloadAction->setEnabled(false);
                 m_locateAction->setEnabled(false);
                 m_duplicateAction->setEnabled(false);
                 m_deleteAction->setText(i18n("Delete Clip"));
                 m_proxyAction->setText(i18n("Proxy Clip"));
             }
             m_deleteAction->setEnabled(true);
         } else {
             m_reloadAction->setEnabled(false);
             m_locateAction->setEnabled(false);
             m_duplicateAction->setEnabled(false);
             m_openAction->setEnabled(false);
             m_deleteAction->setEnabled(false);
         }
     } else {
         // No item selected in bin
         m_openAction->setEnabled(false);
         m_deleteAction->setEnabled(false);
         showClipProperties(nullptr);
         emit requestClipShow(nullptr);
         // clear effect stack
         emit requestShowEffectStack(QString(), nullptr, QSize(), false);
         // Display black bg in clip monitor
         emit openClip(std::shared_ptr<ProjectClip>());
     }
 }
 
 std::vector<QString> Bin::selectedClipsIds()
 {
     const QModelIndexList indexes = m_proxyModel->selectionModel()->selectedIndexes();
     std::vector<QString> ids;
     // We define the lambda that will be executed on each item of the subset of nodes of the tree that are selected
     auto itemAdder = [&ids](std::vector<QString> &ids_vec, std::shared_ptr<TreeItem> item) {
         auto binItem = std::static_pointer_cast<AbstractProjectItem>(item);
         if (binItem->itemType() == AbstractProjectItem::ClipItem) {
             ids.push_back(binItem->clipId());
         }
         return ids_vec;
     };
     for (const QModelIndex &ix : indexes) {
         if (!ix.isValid() || ix.column() != 0) {
             continue;
         }
         std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(ix));
         item->accumulate(ids, itemAdder);
     }
     return ids;
 }
 
 QList<std::shared_ptr<ProjectClip>> Bin::selectedClips()
 {
     auto ids = selectedClipsIds();
     QList<std::shared_ptr<ProjectClip>> ret;
     for (const auto &id : ids) {
         ret.push_back(m_itemModel->getClipByBinID(id));
     }
     return ret;
 }
 
 void Bin::slotInitView(QAction *action)
 {
     if (action) {
         if (m_proxyModel) {
             m_proxyModel->selectionModel()->clearSelection();
         }
         int viewType = action->data().toInt();
         KdenliveSettings::setBinMode(viewType);
         if (viewType == m_listType) {
             return;
         }
         if (m_listType == BinTreeView) {
             // save current treeview state (column width)
             auto *view = static_cast<QTreeView *>(m_itemView);
             m_headerInfo = view->header()->saveState();
             m_showDate->setEnabled(true);
             m_showDesc->setEnabled(true);
             m_upAction->setVisible(true);
             m_upAction->setEnabled(false);
         } else {
             // remove the current folderUp item if any
             m_upAction->setVisible(false);
         }
         m_listType = static_cast<BinViewType>(viewType);
     }
     if (m_itemView) {
         delete m_itemView;
     }
 
     switch (m_listType) {
     case BinIconView:
         m_itemView = new MyListView(this);
         m_showDate->setEnabled(false);
         m_showDesc->setEnabled(false);
         break;
     default:
         m_itemView = new MyTreeView(this);
         m_showDate->setEnabled(true);
         m_showDesc->setEnabled(true);
         break;
     }
     m_itemView->setMouseTracking(true);
     m_itemView->viewport()->installEventFilter(this);
     QSize zoom = m_iconSize * (m_slider->value() / 4.0);
     m_itemView->setIconSize(zoom);
     QPixmap pix(zoom);
     pix.fill(Qt::lightGray);
     m_blankThumb.addPixmap(pix);
     m_binTreeViewDelegate->setDar(pCore->getCurrentDar());
     m_binListViewDelegate->setDar(pCore->getCurrentDar());
     m_proxyModel.reset(new ProjectSortProxyModel(this));
     // Connect models
     m_proxyModel->setSourceModel(m_itemModel.get());
     connect(m_itemModel.get(), &QAbstractItemModel::dataChanged, m_proxyModel.get(), &ProjectSortProxyModel::slotDataChanged);
     connect(m_proxyModel.get(), &ProjectSortProxyModel::selectModel, this, &Bin::selectProxyModel);
     connect(m_proxyModel.get(), &QAbstractItemModel::layoutAboutToBeChanged, this, &Bin::slotSetSorting);
     connect(m_searchLine, &QLineEdit::textChanged, m_proxyModel.get(), &ProjectSortProxyModel::slotSetSearchString);
     m_itemView->setModel(m_proxyModel.get());
     m_itemView->setSelectionModel(m_proxyModel->selectionModel());
     m_proxyModel->setDynamicSortFilter(true);
     m_layout->insertWidget(1, m_itemView);
     // Reset drag type to normal
     m_itemModel->setDragType(PlaylistState::Disabled);
 
     // setup some default view specific parameters
     if (m_listType == BinTreeView) {
         m_itemView->setItemDelegate(m_binTreeViewDelegate);
         auto *view = static_cast<MyTreeView *>(m_itemView);
         view->setSortingEnabled(true);
         view->setWordWrap(true);
         connect(view, &MyTreeView::updateDragMode, m_itemModel.get(), &ProjectItemModel::setDragType, Qt::DirectConnection);
         connect(view, &MyTreeView::displayBinFrame, this, &Bin::showBinFrame);
         if (!m_headerInfo.isEmpty()) {
             view->header()->restoreState(m_headerInfo);
+            m_sortDescend->setChecked(view->header()->sortIndicatorOrder() == Qt::DescendingOrder);
         } else {
             view->header()->resizeSections(QHeaderView::ResizeToContents);
             view->resizeColumnToContents(0);
             view->setColumnHidden(1, true);
             view->setColumnHidden(2, true);
         }
+        view->setColumnHidden(3, true);
         m_showDate->setChecked(!view->isColumnHidden(1));
         m_showDesc->setChecked(!view->isColumnHidden(2));
         connect(view->header(), &QHeaderView::sectionResized, this, &Bin::slotSaveHeaders);
         connect(view->header(), &QHeaderView::sectionClicked, this, &Bin::slotSaveHeaders);
         connect(view, &MyTreeView::focusView, this, &Bin::slotGotFocus);
     } else if (m_listType == BinIconView) {
         m_itemView->setItemDelegate(m_binListViewDelegate);
         auto *view = static_cast<MyListView *>(m_itemView);
         connect(view, &MyListView::updateDragMode, m_itemModel.get(), &ProjectItemModel::setDragType, Qt::DirectConnection);
         view->setGridSize(QSize(zoom.width() * 1.2, zoom.width()));
         connect(view, &MyListView::focusView, this, &Bin::slotGotFocus);
         connect(view, &MyListView::displayBinFrame, this, &Bin::showBinFrame);
     }
     m_itemView->setEditTriggers(QAbstractItemView::NoEditTriggers); // DoubleClicked);
     m_itemView->setSelectionMode(QAbstractItemView::ExtendedSelection);
     m_itemView->setDragDropMode(QAbstractItemView::DragDrop);
     m_itemView->setAlternatingRowColors(true);
     m_itemView->setAcceptDrops(true);
     m_itemView->setFocus();
 }
 
 void Bin::slotSetIconSize(int size)
 {
     if (!m_itemView) {
         return;
     }
     KdenliveSettings::setBin_zoom(size);
     QSize zoom = m_iconSize;
     zoom = zoom * (size / 4.0);
     m_itemView->setIconSize(zoom);
     if (m_listType == BinIconView) {
         auto *view = static_cast<MyListView *>(m_itemView);
         view->setGridSize(QSize(zoom.width() * 1.2, zoom.width()));
     }
     QPixmap pix(zoom);
     pix.fill(Qt::lightGray);
     m_blankThumb.addPixmap(pix);
 }
 
 void Bin::rebuildMenu()
 {
     m_transcodeAction = static_cast<QMenu *>(pCore->window()->factory()->container(QStringLiteral("transcoders"), pCore->window()));
     m_extractAudioAction = static_cast<QMenu *>(pCore->window()->factory()->container(QStringLiteral("extract_audio"), pCore->window()));
     m_clipsActionsMenu = static_cast<QMenu *>(pCore->window()->factory()->container(QStringLiteral("clip_actions"), pCore->window()));
     m_menu->insertMenu(m_reloadAction, m_extractAudioAction);
     m_menu->insertMenu(m_reloadAction, m_transcodeAction);
     m_menu->insertMenu(m_reloadAction, m_clipsActionsMenu);
 }
 
 void Bin::contextMenuEvent(QContextMenuEvent *event)
 {
     bool enableClipActions = false;
     ClipType::ProducerType type = ClipType::Unknown;
     bool isFolder = false;
     bool isImported = false;
     AbstractProjectItem::PROJECTITEMTYPE itemType = AbstractProjectItem::FolderItem;
     QString clipService;
     QString audioCodec;
     if (m_itemView) {
         QModelIndex idx = m_itemView->indexAt(m_itemView->viewport()->mapFromGlobal(event->globalPos()));
         if (idx.isValid()) {
             // User right clicked on a clip
             std::shared_ptr<AbstractProjectItem> currentItem = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(idx));
             itemType = currentItem->itemType();
             if (currentItem) {
                 enableClipActions = true;
                 if (itemType == AbstractProjectItem::ClipItem) {
                     auto clip = std::static_pointer_cast<ProjectClip>(currentItem);
                     if (clip) {
                         m_proxyAction->blockSignals(true);
                         emit findInTimeline(clip->clipId(), clip->timelineInstances());
                         clipService = clip->getProducerProperty(QStringLiteral("mlt_service"));
                         m_proxyAction->setChecked(clip->hasProxy());
                         QList<QAction *> transcodeActions;
                         if (m_transcodeAction) {
                             transcodeActions = m_transcodeAction->actions();
                         }
                         QStringList dataList;
                         QString condition;
                         audioCodec = clip->codec(true);
                         QString videoCodec = clip->codec(false);
                         type = clip->clipType();
                         if (clip->hasUrl()) {
                             isImported = true;
                         }
                         bool noCodecInfo = false;
                         if (audioCodec.isEmpty() && videoCodec.isEmpty()) {
                             noCodecInfo = true;
                         }
                         for (int i = 0; i < transcodeActions.count(); ++i) {
                             dataList = transcodeActions.at(i)->data().toStringList();
                             if (dataList.count() > 4) {
                                 condition = dataList.at(4);
                                 if (condition.isEmpty()) {
                                     transcodeActions.at(i)->setEnabled(true);
                                     continue;
                                 }
                                 if (noCodecInfo) {
                                     // No audio / video codec, this is an MLT clip, disable conditionnal transcoding
                                     transcodeActions.at(i)->setEnabled(false);
                                     continue;
                                 }
                                 if (condition.startsWith(QLatin1String("vcodec"))) {
                                     transcodeActions.at(i)->setEnabled(condition.section(QLatin1Char('='), 1, 1) == videoCodec);
                                 } else if (condition.startsWith(QLatin1String("acodec"))) {
                                     transcodeActions.at(i)->setEnabled(condition.section(QLatin1Char('='), 1, 1) == audioCodec);
                                 }
                             }
                         }
                     }
                     m_proxyAction->blockSignals(false);
                 } else {
                     // Disable find in timeline option
                     emit findInTimeline(QString());
                 }
             }
         }
     }
     // Enable / disable clip actions
     m_proxyAction->setEnabled((m_doc->getDocumentProperty(QStringLiteral("enableproxy")).toInt() != 0) && enableClipActions);
     m_openAction->setEnabled(type == ClipType::Image || type == ClipType::Audio || type == ClipType::TextTemplate || type == ClipType::Text);
     m_reloadAction->setEnabled(enableClipActions);
     m_locateAction->setEnabled(enableClipActions);
     m_duplicateAction->setEnabled(enableClipActions);
     m_renameAction->setEnabled(true);
 
     m_editAction->setVisible(!isFolder);
     m_clipsActionsMenu->setEnabled(enableClipActions);
     m_extractAudioAction->setEnabled(enableClipActions);
     m_openAction->setVisible(itemType != AbstractProjectItem::FolderItem);
     m_reloadAction->setVisible(itemType != AbstractProjectItem::FolderItem);
     m_duplicateAction->setVisible(itemType != AbstractProjectItem::FolderItem);
     m_inTimelineAction->setVisible(itemType != AbstractProjectItem::FolderItem);
     m_renameAction->setVisible(true);
 
     if (m_transcodeAction) {
         m_transcodeAction->setEnabled(enableClipActions);
         m_transcodeAction->menuAction()->setVisible(itemType != AbstractProjectItem::FolderItem && (type == ClipType::Playlist || type == ClipType::Text || clipService.contains(QStringLiteral("avformat"))));
     }
     m_clipsActionsMenu->menuAction()->setVisible(
         itemType != AbstractProjectItem::FolderItem &&
         (clipService.contains(QStringLiteral("avformat")) || clipService.contains(QStringLiteral("xml")) || clipService.contains(QStringLiteral("consumer"))));
     m_extractAudioAction->menuAction()->setVisible(!isFolder && !audioCodec.isEmpty());
     m_locateAction->setVisible(itemType != AbstractProjectItem::FolderItem && (isImported));
 
     // Show menu
     event->setAccepted(true);
     if (enableClipActions) {
         m_menu->exec(event->globalPos());
     } else {
         // Clicked in empty area
         m_addButton->menu()->exec(event->globalPos());
     }
 }
 
 void Bin::slotItemDoubleClicked(const QModelIndex &ix, const QPoint &pos)
 {
     std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(ix));
     if (m_listType == BinIconView) {
         if (item->childCount() > 0 || item->itemType() == AbstractProjectItem::FolderItem) {
             m_itemView->setRootIndex(ix);
             m_upAction->setEnabled(true);
             return;
         }
     } else {
         if (ix.column() == 0 && item->childCount() > 0) {
             QRect IconRect = m_itemView->visualRect(ix);
             IconRect.setWidth((double)IconRect.height() / m_itemView->iconSize().height() * m_itemView->iconSize().width());
             if (!pos.isNull() && (IconRect.contains(pos) || pos.y() > (IconRect.y() + IconRect.height() / 2))) {
                 auto *view = static_cast<QTreeView *>(m_itemView);
                 view->setExpanded(ix, !view->isExpanded(ix));
                 return;
             }
         }
     }
     if (ix.isValid()) {
         QRect IconRect = m_itemView->visualRect(ix);
         IconRect.setWidth((double)IconRect.height() / m_itemView->iconSize().height() * m_itemView->iconSize().width());
         if (!pos.isNull() && ((ix.column() == 2 && item->itemType() == AbstractProjectItem::ClipItem) ||
                               (!IconRect.contains(pos) && pos.y() < (IconRect.y() + IconRect.height() / 2)))) {
             // User clicked outside icon, trigger rename
             m_itemView->edit(ix);
             return;
         }
         if (item->itemType() == AbstractProjectItem::ClipItem) {
             std::shared_ptr<ProjectClip> clip = std::static_pointer_cast<ProjectClip>(item);
             if (clip) {
                 if (clip->clipType() == ClipType::Text || clip->clipType() == ClipType::TextTemplate) {
                     // m_propertiesPanel->setEnabled(false);
                     showTitleWidget(clip);
                 } else {
                     slotSwitchClipProperties(clip);
                 }
             }
         }
     }
 }
 
 void Bin::slotEditClip()
 {
     QString panelId = m_propertiesPanel->property("clipId").toString();
     QModelIndex current = m_proxyModel->selectionModel()->currentIndex();
     std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(current));
     if (item->clipId() != panelId) {
         // wrong clip
         return;
     }
     auto clip = std::static_pointer_cast<ProjectClip>(item);
     QString parentFolder = getCurrentFolder();
     switch (clip->clipType()) {
     case ClipType::Text:
     case ClipType::TextTemplate:
         showTitleWidget(clip);
         break;
     case ClipType::SlideShow:
         showSlideshowWidget(clip);
         break;
     case ClipType::QText:
         ClipCreationDialog::createQTextClip(m_doc, parentFolder, this, clip.get());
         break;
     default:
         break;
     }
 }
 
 void Bin::slotSwitchClipProperties()
 {
     QModelIndex current = m_proxyModel->selectionModel()->currentIndex();
     if (current.isValid()) {
         // User clicked in the icon, open clip properties
         std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(current));
         std::shared_ptr<ProjectClip> currentItem = nullptr;
         if (item->itemType() == AbstractProjectItem::ClipItem) {
             currentItem = std::static_pointer_cast<ProjectClip>(item);
         } else if (item->itemType() == AbstractProjectItem::SubClipItem) {
             currentItem = std::static_pointer_cast<ProjectSubClip>(item)->getMasterClip();
         }
         if (currentItem) {
             slotSwitchClipProperties(currentItem);
             return;
         }
     }
     slotSwitchClipProperties(nullptr);
 }
 
 void Bin::slotSwitchClipProperties(const std::shared_ptr<ProjectClip> &clip)
 {
     if (clip == nullptr) {
         m_propertiesPanel->setEnabled(false);
         return;
     }
     if (clip->clipType() == ClipType::SlideShow) {
         m_propertiesPanel->setEnabled(false);
         showSlideshowWidget(clip);
     } else if (clip->clipType() == ClipType::QText) {
         m_propertiesPanel->setEnabled(false);
         QString parentFolder = getCurrentFolder();
         ClipCreationDialog::createQTextClip(m_doc, parentFolder, this, clip.get());
     } else {
         m_propertiesPanel->setEnabled(true);
         showClipProperties(clip);
         m_propertiesDock->show();
         m_propertiesDock->raise();
     }
     // Check if properties panel is not tabbed under Bin
     // if (!pCore->window()->isTabbedWith(m_propertiesDock, QStringLiteral("project_bin"))) {
 }
 
 void Bin::doRefreshPanel(const QString &id)
 {
     std::shared_ptr<ProjectClip> currentItem = getFirstSelectedClip();
     if ((currentItem != nullptr) && currentItem->AbstractProjectItem::clipId() == id) {
         showClipProperties(currentItem, true);
     }
 }
 
 QAction *Bin::addAction(const QString &name, const QString &text, const QIcon &icon)
 {
     auto *action = new QAction(text, this);
     if (!icon.isNull()) {
         action->setIcon(icon);
     }
     pCore->window()->addAction(name, action);
     return action;
 }
 
 void Bin::setupAddClipAction(QMenu *addClipMenu, ClipType::ProducerType type, const QString &name, const QString &text, const QIcon &icon)
 {
     QAction *action = addAction(name, text, icon);
     action->setData(static_cast<QVariant>(type));
     addClipMenu->addAction(action);
     connect(action, &QAction::triggered, this, &Bin::slotCreateProjectClip);
 }
 
 void Bin::showClipProperties(const std::shared_ptr<ProjectClip> &clip, bool forceRefresh)
 {
     if ((clip == nullptr) || !clip->isReady()) {
         for (QWidget *w : m_propertiesPanel->findChildren<ClipPropertiesController *>()) {
             delete w;
         }
         m_propertiesPanel->setProperty("clipId", QString());
         m_propertiesPanel->setEnabled(false);
         emit setupTargets(false, {});
         return;
     }
     m_propertiesPanel->setEnabled(true);
     QString panelId = m_propertiesPanel->property("clipId").toString();
     if (!forceRefresh && panelId == clip->AbstractProjectItem::clipId()) {
         // the properties panel is already displaying current clip, do nothing
         return;
     }
     // Cleanup widget for new content
     for (QWidget *w : m_propertiesPanel->findChildren<ClipPropertiesController *>()) {
         delete w;
     }
     m_propertiesPanel->setProperty("clipId", clip->AbstractProjectItem::clipId());
     // Setup timeline targets
     emit setupTargets(clip->hasVideo(), clip->audioStreams());
     auto *lay = static_cast<QVBoxLayout *>(m_propertiesPanel->layout());
     if (lay == nullptr) {
         lay = new QVBoxLayout(m_propertiesPanel);
         m_propertiesPanel->setLayout(lay);
     }
     ClipPropertiesController *panel = clip->buildProperties(m_propertiesPanel);
     connect(this, &Bin::refreshTimeCode, panel, &ClipPropertiesController::slotRefreshTimeCode);
     connect(panel, &ClipPropertiesController::updateClipProperties, this, &Bin::slotEditClipCommand);
     connect(panel, &ClipPropertiesController::seekToFrame, m_monitor, static_cast<void (Monitor::*)(int)>(&Monitor::slotSeek));
     connect(panel, &ClipPropertiesController::editClip, this, &Bin::slotEditClip);
     connect(panel, SIGNAL(editAnalysis(QString, QString, QString)), this, SLOT(slotAddClipExtraData(QString, QString, QString)));
 
     lay->addWidget(panel);
 }
 
 void Bin::slotEditClipCommand(const QString &id, const QMap<QString, QString> &oldProps, const QMap<QString, QString> &newProps)
 {
     auto *command = new EditClipCommand(this, id, oldProps, newProps, true);
     m_doc->commandStack()->push(command);
 }
 
 void Bin::reloadClip(const QString &id, bool reloadAudio)
 {
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(id);
     if (!clip) {
         return;
     }
     clip->reloadProducer(false, false, reloadAudio);
 }
 
 void Bin::reloadMonitorIfActive(const QString &id)
 {
     if (m_monitor->activeClipId() == id) {
         slotOpenCurrent();
     }
 }
 
 QStringList Bin::getBinFolderClipIds(const QString &id) const
 {
     QStringList ids;
     std::shared_ptr<ProjectFolder> folder = m_itemModel->getFolderByBinId(id);
     if (folder) {
         for (int i = 0; i < folder->childCount(); i++) {
             std::shared_ptr<AbstractProjectItem> child = std::static_pointer_cast<AbstractProjectItem>(folder->child(i));
             if (child->itemType() == AbstractProjectItem::ClipItem) {
                 ids << child->clipId();
             }
         }
     }
     return ids;
 }
 
 std::shared_ptr<ProjectClip> Bin::getBinClip(const QString &id)
 {
     std::shared_ptr<ProjectClip> clip = nullptr;
     if (id.contains(QLatin1Char('_'))) {
         clip = m_itemModel->getClipByBinID(id.section(QLatin1Char('_'), 0, 0));
     } else if (!id.isEmpty()) {
         clip = m_itemModel->getClipByBinID(id);
     }
     return clip;
 }
 
 void Bin::setWaitingStatus(const QString &id)
 {
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(id);
     if (clip) {
         clip->setClipStatus(AbstractProjectItem::StatusWaiting);
     }
 }
 
 void Bin::slotRemoveInvalidClip(const QString &id, bool replace, const QString &errorMessage)
 {
     Q_UNUSED(replace);
 
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(id);
     if (!clip) {
         return;
     }
     emit requesteInvalidRemoval(id, clip->url(), errorMessage);
 }
 
 void Bin::selectClip(const std::shared_ptr<ProjectClip> &clip)
 {
     QModelIndex ix = m_itemModel->getIndexFromItem(clip);
     int row = ix.row();
     const QModelIndex id = m_itemModel->index(row, 0, ix.parent());
     const QModelIndex id2 = m_itemModel->index(row, m_itemModel->columnCount() - 1, ix.parent());
     if (id.isValid() && id2.isValid()) {
         m_proxyModel->selectionModel()->select(QItemSelection(m_proxyModel->mapFromSource(id), m_proxyModel->mapFromSource(id2)), QItemSelectionModel::SelectCurrent);
     }
     m_itemView->scrollTo(m_proxyModel->mapFromSource(ix), QAbstractItemView::PositionAtCenter);
 }
 
 void Bin::slotOpenCurrent()
 {
     std::shared_ptr<ProjectClip> currentItem = getFirstSelectedClip();
     if (currentItem) {
         emit openClip(currentItem);
     }
 }
 
 void Bin::openProducer(std::shared_ptr<ProjectClip> controller)
 {
     emit openClip(std::move(controller));
 }
 
 void Bin::openProducer(std::shared_ptr<ProjectClip> controller, int in, int out)
 {
     emit openClip(std::move(controller), in, out);
 }
 
 void Bin::emitItemUpdated(std::shared_ptr<AbstractProjectItem> item)
 {
     emit itemUpdated(std::move(item));
 }
 
 void Bin::emitRefreshPanel(const QString &id)
 {
     emit refreshPanel(id);
 }
 
 void Bin::setupGeneratorMenu()
 {
     if (!m_menu) {
         qCDebug(KDENLIVE_LOG) << "Warning, menu was not created, something is wrong";
         return;
     }
 
     auto *addMenu = qobject_cast<QMenu *>(pCore->window()->factory()->container(QStringLiteral("generators"), pCore->window()));
     if (addMenu) {
         QMenu *menu = m_addButton->menu();
         menu->addMenu(addMenu);
         addMenu->setEnabled(!addMenu->isEmpty());
         m_addButton->setMenu(menu);
     }
 
     addMenu = qobject_cast<QMenu *>(pCore->window()->factory()->container(QStringLiteral("extract_audio"), pCore->window()));
     if (addMenu) {
         m_menu->addMenu(addMenu);
         addMenu->setEnabled(!addMenu->isEmpty());
         m_extractAudioAction = addMenu;
     }
 
     addMenu = qobject_cast<QMenu *>(pCore->window()->factory()->container(QStringLiteral("transcoders"), pCore->window()));
     if (addMenu) {
         m_menu->addMenu(addMenu);
         addMenu->setEnabled(!addMenu->isEmpty());
         m_transcodeAction = addMenu;
     }
 
     addMenu = qobject_cast<QMenu *>(pCore->window()->factory()->container(QStringLiteral("clip_actions"), pCore->window()));
     if (addMenu) {
         m_menu->addMenu(addMenu);
         addMenu->setEnabled(!addMenu->isEmpty());
         m_clipsActionsMenu = addMenu;
     }
 
     addMenu = qobject_cast<QMenu *>(pCore->window()->factory()->container(QStringLiteral("clip_in_timeline"), pCore->window()));
     if (addMenu) {
         m_inTimelineAction = m_menu->addMenu(addMenu);
     }
 
     if (m_locateAction) {
         m_menu->addAction(m_locateAction);
     }
     if (m_reloadAction) {
         m_menu->addAction(m_reloadAction);
     }
     if (m_duplicateAction) {
         m_menu->addAction(m_duplicateAction);
     }
     if (m_proxyAction) {
         m_menu->addAction(m_proxyAction);
     }
 
     addMenu = qobject_cast<QMenu *>(pCore->window()->factory()->container(QStringLiteral("clip_timeline"), pCore->window()));
     if (addMenu) {
         m_menu->addMenu(addMenu);
         addMenu->setEnabled(false);
     }
     m_menu->addAction(m_editAction);
     m_menu->addAction(m_openAction);
     m_menu->addAction(m_renameAction);
     m_menu->addAction(m_deleteAction);
     m_menu->insertSeparator(m_deleteAction);
 }
 
 void Bin::setupMenu()
 {
     auto *addClipMenu = new QMenu(this);
 
     QAction *addClip =
         addAction(QStringLiteral("add_clip"), i18n("Add Clip or Folder"), QIcon::fromTheme(QStringLiteral("kdenlive-add-clip")));
     addClipMenu->addAction(addClip);
     connect(addClip, &QAction::triggered, this, &Bin::slotAddClip);
 
     setupAddClipAction(addClipMenu, ClipType::Color, QStringLiteral("add_color_clip"), i18n("Add Color Clip"), QIcon::fromTheme(QStringLiteral("kdenlive-add-color-clip")));
     setupAddClipAction(addClipMenu, ClipType::SlideShow, QStringLiteral("add_slide_clip"), i18n("Add Slideshow Clip"), QIcon::fromTheme(QStringLiteral("kdenlive-add-slide-clip")));
     setupAddClipAction(addClipMenu, ClipType::Text, QStringLiteral("add_text_clip"), i18n("Add Title Clip"), QIcon::fromTheme(QStringLiteral("kdenlive-add-text-clip")));
     setupAddClipAction(addClipMenu, ClipType::TextTemplate, QStringLiteral("add_text_template_clip"), i18n("Add Template Title"), QIcon::fromTheme(QStringLiteral("kdenlive-add-text-clip")));
 
     QAction *downloadResourceAction =
         addAction(QStringLiteral("download_resource"), i18n("Online Resources"), QIcon::fromTheme(QStringLiteral("edit-download")));
     addClipMenu->addAction(downloadResourceAction);
     connect(downloadResourceAction, &QAction::triggered, pCore->window(), &MainWindow::slotDownloadResources);
 
     m_locateAction =
         addAction(QStringLiteral("locate_clip"), i18n("Locate Clip..."), QIcon::fromTheme(QStringLiteral("edit-file")));
     m_locateAction->setData("locate_clip");
     m_locateAction->setEnabled(false);
     connect(m_locateAction, &QAction::triggered, this, &Bin::slotLocateClip);
 
     m_reloadAction =
         addAction(QStringLiteral("reload_clip"), i18n("Reload Clip"), QIcon::fromTheme(QStringLiteral("view-refresh")));
     m_reloadAction->setData("reload_clip");
     m_reloadAction->setEnabled(false);
     connect(m_reloadAction, &QAction::triggered, this, &Bin::slotReloadClip);
 
     m_duplicateAction =
         addAction(QStringLiteral("duplicate_clip"), i18n("Duplicate Clip"), QIcon::fromTheme(QStringLiteral("edit-copy")));
     m_duplicateAction->setData("duplicate_clip");
     m_duplicateAction->setEnabled(false);
     connect(m_duplicateAction, &QAction::triggered, this, &Bin::slotDuplicateClip);
 
     m_proxyAction = new QAction(i18n("Proxy Clip"), pCore->window());
     pCore->window()->addAction(QStringLiteral("proxy_clip"), m_proxyAction);
     m_proxyAction->setData(QStringList() << QString::number(static_cast<int>(AbstractClipJob::PROXYJOB)));
     m_proxyAction->setCheckable(true);
     m_proxyAction->setChecked(false);
 
     m_editAction =
         addAction(QStringLiteral("clip_properties"), i18n("Clip Properties"), QIcon::fromTheme(QStringLiteral("document-edit")));
     m_editAction->setData("clip_properties");
     connect(m_editAction, &QAction::triggered, this, static_cast<void (Bin::*)()>(&Bin::slotSwitchClipProperties));
 
     m_openAction =
         addAction(QStringLiteral("edit_clip"), i18n("Edit Clip"), QIcon::fromTheme(QStringLiteral("document-open")));
     m_openAction->setData("edit_clip");
     m_openAction->setEnabled(false);
     connect(m_openAction, &QAction::triggered, this, &Bin::slotOpenClip);
 
     m_renameAction =
         addAction(QStringLiteral("rename_clip"), i18n("Rename Clip"), QIcon::fromTheme(QStringLiteral("document-edit")));
     m_renameAction->setData("rename_clip");
     m_renameAction->setEnabled(false);
     connect(m_renameAction, &QAction::triggered, this, &Bin::slotRenameItem);
 
     m_deleteAction =
         addAction(QStringLiteral("delete_clip"), i18n("Delete Clip"), QIcon::fromTheme(QStringLiteral("edit-delete")));
     m_deleteAction->setData("delete_clip");
     m_deleteAction->setEnabled(false);
     connect(m_deleteAction, &QAction::triggered, this, &Bin::slotDeleteClip);
 
     QAction *createFolder =
         addAction(QStringLiteral("create_folder"), i18n("Create Folder"), QIcon::fromTheme(QStringLiteral("folder-new")));
     connect(createFolder, &QAction::triggered, this, &Bin::slotAddFolder);
     m_upAction = KStandardAction::up(this, SLOT(slotBack()), pCore->window()->actionCollection());
 
     // Setup actions
     QAction *first = m_toolbar->actions().at(0);
     m_toolbar->insertAction(first, m_deleteAction);
     m_toolbar->insertAction(m_deleteAction, createFolder);
     m_toolbar->insertAction(createFolder, m_upAction);
 
     auto *m = new QMenu(this);
     m->addActions(addClipMenu->actions());
     m_addButton = new QToolButton(this);
     m_addButton->setMenu(m);
     m_addButton->setDefaultAction(addClip);
     m_addButton->setPopupMode(QToolButton::MenuButtonPopup);
     m_toolbar->insertWidget(m_upAction, m_addButton);
     m_menu = new QMenu(this);
     m_propertiesDock = pCore->window()->addDock(i18n("Clip Properties"), QStringLiteral("clip_properties"), m_propertiesPanel);
     m_propertiesDock->close();
 }
 
 const QString Bin::getDocumentProperty(const QString &key)
 {
     return m_doc->getDocumentProperty(key);
 }
 
 void Bin::slotUpdateJobStatus(const QString &id, int jobType, int status, const QString &label, const QString &actionName, const QString &details)
 {
     Q_UNUSED(id)
     Q_UNUSED(jobType)
     Q_UNUSED(status)
     Q_UNUSED(label)
     Q_UNUSED(actionName)
     Q_UNUSED(details)
     // TODO refac
     /*
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(id);
     if (clip) {
         clip->setJobStatus((AbstractClipJob::JOBTYPE)jobType, (ClipJobStatus)status);
     }
     if (status == JobCrashed) {
         QList<QAction *> actions = m_infoMessage->actions();
         if (m_infoMessage->isHidden()) {
             if (!details.isEmpty()) {
                 m_infoMessage->setText(label + QStringLiteral(" <a href=\"#\">") + i18n("Show log") + QStringLiteral("</a>"));
             } else {
                 m_infoMessage->setText(label);
             }
             m_infoMessage->setWordWrap(m_infoMessage->text().length() > 35);
             m_infoMessage->setMessageType(KMessageWidget::Warning);
         }
 
         if (!actionName.isEmpty()) {
             QAction *action = nullptr;
             QList<KActionCollection *> collections = KActionCollection::allCollections();
             for (int i = 0; i < collections.count(); ++i) {
                 KActionCollection *coll = collections.at(i);
                 action = coll->action(actionName);
                 if (action) {
                     break;
                 }
             }
             if ((action != nullptr) && !actions.contains(action)) {
                 m_infoMessage->addAction(action);
             }
         }
         if (!details.isEmpty()) {
             m_errorLog.append(details);
         }
         m_infoMessage->setCloseButtonVisible(true);
         m_infoMessage->animatedShow();
     }
     */
 }
 
 void Bin::doDisplayMessage(const QString &text, KMessageWidget::MessageType type, const QList<QAction *> &actions)
 {
     // Remove existing actions if any
     QList<QAction *> acts = m_infoMessage->actions();
     while (!acts.isEmpty()) {
         QAction *a = acts.takeFirst();
         m_infoMessage->removeAction(a);
         delete a;
     }
     m_infoMessage->setText(text);
     m_infoMessage->setWordWrap(text.length() > 35);
     for (QAction *action : actions) {
         m_infoMessage->addAction(action);
         connect(action, &QAction::triggered, this, &Bin::slotMessageActionTriggered);
     }
     m_infoMessage->setCloseButtonVisible(actions.isEmpty());
     m_infoMessage->setMessageType(type);
     m_infoMessage->animatedShow();
 }
 
 void Bin::doDisplayMessage(const QString &text, KMessageWidget::MessageType type, const QString &logInfo)
 {
     // Remove existing actions if any
     QList<QAction *> acts = m_infoMessage->actions();
     while (!acts.isEmpty()) {
         QAction *a = acts.takeFirst();
         m_infoMessage->removeAction(a);
         delete a;
     }
     m_infoMessage->setText(text);
     m_infoMessage->setWordWrap(text.length() > 35);
     QAction *ac = new QAction(i18n("Show log"), this);
     m_infoMessage->addAction(ac);
     connect(ac, &QAction::triggered, [this, logInfo](bool) {
         KMessageBox::sorry(this, logInfo, i18n("Detailed log"));
         slotMessageActionTriggered();
     });
     m_infoMessage->setCloseButtonVisible(false);
     m_infoMessage->setMessageType(type);
     m_infoMessage->animatedShow();
 }
 
 void Bin::refreshClip(const QString &id)
 {
     if (m_monitor->activeClipId() == id) {
         m_monitor->refreshMonitorIfActive();
     }
 }
 
 void Bin::slotCreateProjectClip()
 {
     auto *act = qobject_cast<QAction *>(sender());
     if (act == nullptr) {
         // Cannot access triggering action, something is wrong
         qCDebug(KDENLIVE_LOG) << "// Error in clip creation action";
         return;
     }
     ClipType::ProducerType type = (ClipType::ProducerType)act->data().toInt();
     QString parentFolder = getCurrentFolder();
     switch (type) {
     case ClipType::Color:
         ClipCreationDialog::createColorClip(m_doc, parentFolder, m_itemModel);
         break;
     case ClipType::SlideShow:
         ClipCreationDialog::createSlideshowClip(m_doc, parentFolder, m_itemModel);
         break;
     case ClipType::Text:
         ClipCreationDialog::createTitleClip(m_doc, parentFolder, QString(), m_itemModel);
         break;
     case ClipType::TextTemplate:
         ClipCreationDialog::createTitleTemplateClip(m_doc, parentFolder, m_itemModel);
         break;
     case ClipType::QText:
         ClipCreationDialog::createQTextClip(m_doc, parentFolder, this);
         break;
     default:
         break;
     }
 }
 
 void Bin::slotItemDropped(const QStringList &ids, const QModelIndex &parent)
 {
     std::shared_ptr<AbstractProjectItem> parentItem;
     if (parent.isValid()) {
         parentItem = m_itemModel->getBinItemByIndex(parent);
         parentItem = parentItem->getEnclosingFolder(false);
     } else {
         parentItem = m_itemModel->getRootFolder();
     }
     auto *moveCommand = new QUndoCommand();
     moveCommand->setText(i18np("Move Clip", "Move Clips", ids.count()));
     QStringList folderIds;
     for (const QString &id : ids) {
         if (id.contains(QLatin1Char('/'))) {
             // trying to move clip zone, not allowed. Ignore
             continue;
         }
         if (id.startsWith(QLatin1Char('#'))) {
             // moving a folder, keep it for later
             folderIds << id;
             continue;
         }
         std::shared_ptr<ProjectClip> currentItem = m_itemModel->getClipByBinID(id);
         if (!currentItem) {
             continue;
         }
         std::shared_ptr<AbstractProjectItem> currentParent = currentItem->parent();
         if (currentParent != parentItem) {
             // Item was dropped on a different folder
             new MoveBinClipCommand(this, id, currentParent->clipId(), parentItem->clipId(), moveCommand);
         }
     }
     if (!folderIds.isEmpty()) {
         for (QString id : folderIds) {
             id.remove(0, 1);
             std::shared_ptr<ProjectFolder> currentItem = m_itemModel->getFolderByBinId(id);
             if (!currentItem) {
                 continue;
             }
             std::shared_ptr<AbstractProjectItem> currentParent = currentItem->parent();
             if (currentParent != parentItem) {
                 // Item was dropped on a different folder
                 new MoveBinFolderCommand(this, id, currentParent->clipId(), parentItem->clipId(), moveCommand);
             }
         }
     }
     if (moveCommand->childCount() == 0) {
         pCore->displayMessage(i18n("No valid clip to insert"), InformationMessage, 500);
     } else {
         m_doc->commandStack()->push(moveCommand);
     }
 }
 
 void Bin::slotAddEffect(QString id, const QStringList &effectData)
 {
     if (id.isEmpty()) {
         id = m_monitor->activeClipId();
     }
     if (!id.isEmpty()) {
         std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(id);
         if (clip) {
             if (effectData.count() == 4) {
                 // Paste effect from another stack
                 std::shared_ptr<EffectStackModel> sourceStack = pCore->getItemEffectStack(effectData.at(1).toInt(), effectData.at(2).toInt());
                 clip->copyEffect(sourceStack, effectData.at(3).toInt());
             } else {
                 clip->addEffect(effectData.constFirst());
             }
             return;
         }
     }
     pCore->displayMessage(i18n("Select a clip to apply an effect"), InformationMessage, 500);
 }
 
 void Bin::slotEffectDropped(const QStringList &effectData, const QModelIndex &parent)
 {
     if (parent.isValid()) {
         std::shared_ptr<AbstractProjectItem> parentItem = m_itemModel->getBinItemByIndex(parent);
         if (parentItem->itemType() != AbstractProjectItem::ClipItem) {
             // effect only supported on clip items
             return;
         }
         m_proxyModel->selectionModel()->clearSelection();
         int row = parent.row();
         const QModelIndex id = m_itemModel->index(row, 0, parent.parent());
         const QModelIndex id2 = m_itemModel->index(row, m_itemModel->columnCount() - 1, parent.parent());
         if (id.isValid() && id2.isValid()) {
             m_proxyModel->selectionModel()->select(QItemSelection(m_proxyModel->mapFromSource(id), m_proxyModel->mapFromSource(id2)),
                                                    QItemSelectionModel::Select);
         }
         setCurrent(parentItem);
         bool res = false;
         if (effectData.count() == 4) {
             // Paste effect from another stack
             std::shared_ptr<EffectStackModel> sourceStack = pCore->getItemEffectStack(effectData.at(1).toInt(), effectData.at(2).toInt());
             res = std::static_pointer_cast<ProjectClip>(parentItem)->copyEffect(sourceStack, effectData.at(3).toInt());
         } else {
             res = std::static_pointer_cast<ProjectClip>(parentItem)->addEffect(effectData.constFirst());
         }
         if (!res) {
             pCore->displayMessage(i18n("Cannot add effect to clip"), InformationMessage);
         }
     }
 }
 
 void Bin::editMasterEffect(const std::shared_ptr<AbstractProjectItem> &clip)
 {
     if (m_gainedFocus) {
         // Widget just gained focus, updating stack is managed in the eventfilter event, not from item
         return;
     }
     if (clip) {
         if (clip->itemType() == AbstractProjectItem::ClipItem) {
             std::shared_ptr<ProjectClip> clp = std::static_pointer_cast<ProjectClip>(clip);
             emit requestShowEffectStack(clp->clipName(), clp->m_effectStack, clp->getFrameSize(), false);
             return;
         }
         if (clip->itemType() == AbstractProjectItem::SubClipItem) {
             if (auto ptr = clip->parentItem().lock()) {
                 std::shared_ptr<ProjectClip> clp = std::static_pointer_cast<ProjectClip>(ptr);
                 emit requestShowEffectStack(clp->clipName(), clp->m_effectStack, clp->getFrameSize(), false);
             }
             return;
         }
     }
     emit requestShowEffectStack(QString(), nullptr, QSize(), false);
 }
 
 void Bin::slotGotFocus()
 {
     m_gainedFocus = true;
 }
 
 void Bin::doMoveClip(const QString &id, const QString &newParentId)
 {
     std::shared_ptr<ProjectClip> currentItem = m_itemModel->getClipByBinID(id);
     if (!currentItem) {
         return;
     }
     std::shared_ptr<AbstractProjectItem> currentParent = currentItem->parent();
     std::shared_ptr<ProjectFolder> newParent = m_itemModel->getFolderByBinId(newParentId);
     currentItem->changeParent(newParent);
 }
 
 void Bin::doMoveFolder(const QString &id, const QString &newParentId)
 {
     std::shared_ptr<ProjectFolder> currentItem = m_itemModel->getFolderByBinId(id);
     std::shared_ptr<AbstractProjectItem> currentParent = currentItem->parent();
     std::shared_ptr<ProjectFolder> newParent = m_itemModel->getFolderByBinId(newParentId);
     currentParent->removeChild(currentItem);
     currentItem->changeParent(newParent);
 }
 
 void Bin::droppedUrls(const QList<QUrl> &urls, const QString &folderInfo)
 {
     QModelIndex current;
     if (folderInfo.isEmpty()) {
         current = m_proxyModel->mapToSource(m_proxyModel->selectionModel()->currentIndex());
     } else {
         // get index for folder
         std::shared_ptr<ProjectFolder> folder = m_itemModel->getFolderByBinId(folderInfo);
         if (!folder) {
             folder = m_itemModel->getRootFolder();
         }
         current = m_itemModel->getIndexFromItem(folder);
     }
     slotItemDropped(urls, current);
 }
 
 void Bin::slotAddClipToProject(const QUrl &url)
 {
     QList<QUrl> urls;
     urls << url;
     QModelIndex current = m_proxyModel->mapToSource(m_proxyModel->selectionModel()->currentIndex());
     slotItemDropped(urls, current);
 }
 
 void Bin::slotItemDropped(const QList<QUrl> &urls, const QModelIndex &parent)
 {
     QString parentFolder = m_itemModel->getRootFolder()->clipId();
     if (parent.isValid()) {
         // Check if drop occurred on a folder
         std::shared_ptr<AbstractProjectItem> parentItem = m_itemModel->getBinItemByIndex(parent);
         while (parentItem->itemType() != AbstractProjectItem::FolderItem) {
             parentItem = parentItem->parent();
         }
         parentFolder = parentItem->clipId();
     }
     ClipCreator::createClipsFromList(urls, true, parentFolder, m_itemModel);
 }
 
 void Bin::slotExpandUrl(const ItemInfo &info, const QString &url, QUndoCommand *command)
 {
     Q_UNUSED(info)
     Q_UNUSED(url)
     Q_UNUSED(command)
     // TODO reimplement this
     /*
     // Create folder to hold imported clips
     QString folderName = QFileInfo(url).fileName().section(QLatin1Char('.'), 0, 0);
     QString folderId = QString::number(getFreeFolderId());
     new AddBinFolderCommand(this, folderId, folderName.isEmpty() ? i18n("Folder") : folderName, m_itemModel->getRootFolder()->clipId(), false, command);
 
     // Parse playlist clips
     QDomDocument doc;
     QFile file(url);
     doc.setContent(&file, false);
     file.close();
     bool invalid = false;
     if (doc.documentElement().isNull()) {
         invalid = true;
     }
     QDomNodeList producers = doc.documentElement().elementsByTagName(QStringLiteral("producer"));
     QDomNodeList tracks = doc.documentElement().elementsByTagName(QStringLiteral("track"));
     if (invalid || producers.isEmpty()) {
         doDisplayMessage(i18n("Playlist clip %1 is invalid.", QFileInfo(url).fileName()), KMessageWidget::Warning);
         delete command;
         return;
     }
     if (tracks.count() > pCore->projectManager()->currentTimeline()->visibleTracksCount() + 1) {
         doDisplayMessage(
             i18n("Playlist clip %1 has too many tracks (%2) to be imported. Add new tracks to your project.", QFileInfo(url).fileName(), tracks.count()),
             KMessageWidget::Warning);
         delete command;
         return;
     }
     // Maps playlist producer IDs to (project) bin producer IDs.
     QMap<QString, QString> idMap;
     // Maps hash IDs to (project) first playlist producer instance ID. This is
     // necessary to detect duplicate producer serializations produced by MLT.
     // This covers, for instance, images and titles.
     QMap<QString, QString> hashToIdMap;
     QDir mltRoot(doc.documentElement().attribute(QStringLiteral("root")));
     for (int i = 0; i < producers.count(); i++) {
         QDomElement prod = producers.at(i).toElement();
         QString originalId = prod.attribute(QStringLiteral("id"));
         // track producer
         if (originalId.contains(QLatin1Char('_'))) {
             originalId = originalId.section(QLatin1Char('_'), 0, 0);
         }
         // slowmotion producer
         if (originalId.contains(QLatin1Char(':'))) {
             originalId = originalId.section(QLatin1Char(':'), 1, 1);
         }
 
         // We already have seen and mapped this producer.
         if (idMap.contains(originalId)) {
             continue;
         }
 
         // Check for duplicate producers, based on hash value of producer.
         // Be careful as to the kdenlive:file_hash! It is not unique for
         // title clips, nor color clips. Also not sure about image sequences.
         // So we use mlt service-specific hashes to identify duplicate producers.
         QString hash;
         QString mltService = Xml::getXmlProperty(prod, QStringLiteral("mlt_service"));
         if (mltService == QLatin1String("pixbuf") || mltService == QLatin1String("qimage") || mltService == QLatin1String("kdenlivetitle") ||
             mltService == QLatin1String("color") || mltService == QLatin1String("colour")) {
             hash = mltService + QLatin1Char(':') + Xml::getXmlProperty(prod, QStringLiteral("kdenlive:clipname")) + QLatin1Char(':') +
                    Xml::getXmlProperty(prod, QStringLiteral("kdenlive:folderid")) + QLatin1Char(':');
             if (mltService == QLatin1String("kdenlivetitle")) {
                 // Calculate hash based on title contents.
                 hash.append(
                     QString(QCryptographicHash::hash(Xml::getXmlProperty(prod, QStringLiteral("xmldata")).toUtf8(), QCryptographicHash::Md5).toHex()));
             } else if (mltService == QLatin1String("pixbuf") || mltService == QLatin1String("qimage") || mltService == QLatin1String("color") ||
                        mltService == QLatin1String("colour")) {
                 hash.append(Xml::getXmlProperty(prod, QStringLiteral("resource")));
             }
 
             QString singletonId = hashToIdMap.value(hash, QString());
             if (singletonId.length() != 0) {
                 // map duplicate producer ID to single bin clip producer ID.
                 qCDebug(KDENLIVE_LOG) << "found duplicate producer:" << hash << ", reusing newID:" << singletonId;
                 idMap.insert(originalId, singletonId);
                 continue;
             }
         }
 
         // First occurrence of a producer, so allocate new bin clip producer ID.
         QString newId = QString::number(getFreeClipId());
         idMap.insert(originalId, newId);
         qCDebug(KDENLIVE_LOG) << "originalId: " << originalId << ", newId: " << newId;
 
         // Ensure to register new bin clip producer ID in hash hashmap for
         // those clips that MLT likes to serialize multiple times. This is
         // indicated by having a hash "value" unqual "". See also above.
         if (hash.length() != 0) {
             hashToIdMap.insert(hash, newId);
         }
 
         // Add clip
         QDomElement clone = prod.cloneNode(true).toElement();
         EffectsList::setProperty(clone, QStringLiteral("kdenlive:folderid"), folderId);
         // Do we have a producer that uses a resource property that contains a path?
         if (mltService == QLatin1String("avformat-novalidate") // av clip
             || mltService == QLatin1String("avformat")         // av clip
             || mltService == QLatin1String("pixbuf")           // image (sequence) clip
             || mltService == QLatin1String("qimage")           // image (sequence) clip
             || mltService == QLatin1String("xml")              // MLT playlist clip, someone likes recursion :)
             ) {
             // Make sure to correctly resolve relative resource paths based on
             // the playlist's root, not on this project's root
             QString resource = Xml::getXmlProperty(clone, QStringLiteral("resource"));
             if (QFileInfo(resource).isRelative()) {
                 QFileInfo rootedResource(mltRoot, resource);
                 qCDebug(KDENLIVE_LOG) << "fixed resource path for producer, newId:" << newId << "resource:" << rootedResource.absoluteFilePath();
                 EffectsList::setProperty(clone, QStringLiteral("resource"), rootedResource.absoluteFilePath());
             }
         }
 
         ClipCreationDialog::createClipsCommand(this, clone, newId, command);
     }
     pCore->projectManager()->currentTimeline()->importPlaylist(info, idMap, doc, command);
     */
 }
 
 void Bin::slotItemEdited(const QModelIndex &ix, const QModelIndex &, const QVector<int> &roles)
 {
     if (ix.isValid() && roles.contains(AbstractProjectItem::DataName)) {
         // Clip renamed
         std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(ix);
         auto clip = std::static_pointer_cast<ProjectClip>(item);
         if (clip) {
             emit clipNameChanged(clip->AbstractProjectItem::clipId());
         }
     }
 }
 
 void Bin::renameSubClipCommand(const QString &id, const QString &newName, const QString &oldName, int in, int out)
 {
     auto *command = new RenameBinSubClipCommand(this, id, newName, oldName, in, out);
     m_doc->commandStack()->push(command);
 }
 
 void Bin::renameSubClip(const QString &id, const QString &newName, int in, int out)
 {
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(id);
     if (!clip) {
         return;
     }
     std::shared_ptr<ProjectSubClip> sub = clip->getSubClip(in, out);
     if (!sub) {
         return;
     }
     sub->setName(newName);
     clip->updateZones();
     emit itemUpdated(sub);
 }
 
 Timecode Bin::projectTimecode() const
 {
     return m_doc->timecode();
 }
 
 void Bin::slotStartFilterJob(const ItemInfo &info, const QString &id, QMap<QString, QString> &filterParams, QMap<QString, QString> &consumerParams,
                              QMap<QString, QString> &extraParams)
 {
     Q_UNUSED(info)
     Q_UNUSED(id)
     Q_UNUSED(filterParams)
     Q_UNUSED(consumerParams)
     Q_UNUSED(extraParams)
     // TODO refac
     /*
     std::shared_ptr<ProjectClip> clip = getBinClip(id);
     if (!clip) {
         return;
     }
 
     QMap<QString, QString> producerParams = QMap<QString, QString>();
     producerParams.insert(QStringLiteral("producer"), clip->url());
     if (info.cropDuration != GenTime()) {
         producerParams.insert(QStringLiteral("in"), QString::number((int)info.cropStart.frames(pCore->getCurrentFps())));
         producerParams.insert(QStringLiteral("out"), QString::number((int)(info.cropStart + info.cropDuration).frames(pCore->getCurrentFps())));
         extraParams.insert(QStringLiteral("clipStartPos"), QString::number((int)info.startPos.frames(pCore->getCurrentFps())));
         extraParams.insert(QStringLiteral("clipTrack"), QString::number(info.track));
     } else {
         // We want to process whole clip
         producerParams.insert(QStringLiteral("in"), QString::number(0));
         producerParams.insert(QStringLiteral("out"), QString::number(-1));
     }
     */
 }
 
 void Bin::focusBinView() const
 {
     m_itemView->setFocus();
 }
 
 void Bin::slotOpenClip()
 {
     std::shared_ptr<ProjectClip> clip = getFirstSelectedClip();
     if (!clip) {
         return;
     }
     switch (clip->clipType()) {
     case ClipType::Text:
     case ClipType::TextTemplate:
         showTitleWidget(clip);
         break;
     case ClipType::Image:
         if (KdenliveSettings::defaultimageapp().isEmpty()) {
             KMessageBox::sorry(QApplication::activeWindow(), i18n("Please set a default application to open images in the Settings dialog"));
         } else {
             QProcess::startDetached(KdenliveSettings::defaultimageapp(), QStringList() << clip->url());
         }
         break;
     case ClipType::Audio:
         if (KdenliveSettings::defaultaudioapp().isEmpty()) {
             KMessageBox::sorry(QApplication::activeWindow(), i18n("Please set a default application to open audio files in the Settings dialog"));
         } else {
             QProcess::startDetached(KdenliveSettings::defaultaudioapp(), QStringList() << clip->url());
         }
         break;
     default:
         break;
     }
 }
 
 void Bin::updateTimecodeFormat()
 {
     emit refreshTimeCode();
 }
 
 /*
 void Bin::slotGotFilterJobResults(const QString &id, int startPos, int track, const stringMap &results, const stringMap &filterInfo)
 {
     if (filterInfo.contains(QStringLiteral("finalfilter"))) {
         if (filterInfo.contains(QStringLiteral("storedata"))) {
             // Store returned data as clip extra data
             std::shared_ptr<ProjectClip> clip = getBinClip(id);
             if (clip) {
                 QString key = filterInfo.value(QStringLiteral("key"));
                 QStringList newValue = clip->updatedAnalysisData(key, results.value(key), filterInfo.value(QStringLiteral("offset")).toInt());
                 slotAddClipExtraData(id, newValue.at(0), newValue.at(1));
             }
         }
         if (startPos == -1) {
             // Processing bin clip
             std::shared_ptr<ProjectClip> currentItem = m_itemModel->getClipByBinID(id);
             if (!currentItem) {
                 return;
             }
             std::shared_ptr<ClipController> ctl = std::static_pointer_cast<ClipController>(currentItem);
             EffectsList list = ctl->effectList();
             QDomElement effect = list.effectById(filterInfo.value(QStringLiteral("finalfilter")));
             QDomDocument doc;
             QDomElement e = doc.createElement(QStringLiteral("test"));
             doc.appendChild(e);
             e.appendChild(doc.importNode(effect, true));
             if (!effect.isNull()) {
                 QDomElement newEffect = effect.cloneNode().toElement();
                 QMap<QString, QString>::const_iterator i = results.constBegin();
                 while (i != results.constEnd()) {
                     EffectsList::setParameter(newEffect, i.key(), i.value());
                     ++i;
                 }
                 ctl->updateEffect(newEffect, effect.attribute(QStringLiteral("kdenlive_ix")).toInt());
                 emit requestClipShow(currentItem);
                 // TODO use undo / redo for bin clip edit effect
                 //
                 EditEffectCommand *command = new EditEffectCommand(this, clip->track(), clip->startPos(), effect, newEffect, clip->selectedEffectIndex(),
                 true, true);
                 m_commandStack->push(command);
                 emit clipItemSelected(clip);
             }
 
             // emit gotFilterJobResults(id, startPos, track, results, filterInfo);
             return;
         }
         // This is a timeline filter, forward results
         emit gotFilterJobResults(id, startPos, track, results, filterInfo);
         return;
     }
     // Currently, only the first value of results is used
     std::shared_ptr<ProjectClip> clip = getBinClip(id);
     if (!clip) {
         return;
     }
     // Check for return value
     int markersType = -1;
     if (filterInfo.contains(QStringLiteral("addmarkers"))) {
         markersType = filterInfo.value(QStringLiteral("addmarkers")).toInt();
     }
     if (results.isEmpty()) {
         emit displayBinMessage(i18n("No data returned from clip analysis"), KMessageWidget::Warning);
         return;
     }
     bool dataProcessed = false;
     QString label = filterInfo.value(QStringLiteral("label"));
     QString key = filterInfo.value(QStringLiteral("key"));
     int offset = filterInfo.value(QStringLiteral("offset")).toInt();
     QStringList value = results.value(key).split(QLatin1Char(';'), QString::SkipEmptyParts);
     // qCDebug(KDENLIVE_LOG)<<"// RESULT; "<<key<<" = "<<value;
     if (filterInfo.contains(QStringLiteral("resultmessage"))) {
         QString mess = filterInfo.value(QStringLiteral("resultmessage"));
         mess.replace(QLatin1String("%count"), QString::number(value.count()));
         emit displayBinMessage(mess, KMessageWidget::Information);
     } else {
         emit displayBinMessage(i18n("Processing data analysis"), KMessageWidget::Information);
     }
     if (filterInfo.contains(QStringLiteral("cutscenes"))) {
         // Check if we want to cut scenes from returned data
         dataProcessed = true;
         int cutPos = 0;
         auto *command = new QUndoCommand();
         command->setText(i18n("Auto Split Clip"));
         for (const QString &pos : value) {
             if (!pos.contains(QLatin1Char('='))) {
                 continue;
             }
             int newPos = pos.section(QLatin1Char('='), 0, 0).toInt();
             // Don't use scenes shorter than 1 second
             if (newPos - cutPos < 24) {
                 continue;
             }
             new AddBinClipCutCommand(this, id, cutPos + offset, newPos + offset, true, command);
             cutPos = newPos;
         }
         if (command->childCount() == 0) {
             delete command;
         } else {
             m_doc->commandStack()->push(command);
         }
     }
     if (markersType >= 0) {
         // Add markers from returned data
         dataProcessed = true;
         int cutPos = 0;
         int index = 1;
         bool simpleList = false;
         double sourceFps = clip->getOriginalFps();
         if (qFuzzyIsNull(sourceFps)) {
             sourceFps = pCore->getCurrentFps();
         }
         if (filterInfo.contains(QStringLiteral("simplelist"))) {
             // simple list
             simpleList = true;
         }
         for (const QString &pos : value) {
             if (simpleList) {
                 clip->getMarkerModel()->addMarker(GenTime((int)(pos.toInt() * pCore->getCurrentFps() / sourceFps), pCore->getCurrentFps()), label + pos,
                                                   markersType);
                 index++;
                 continue;
             }
             if (!pos.contains(QLatin1Char('='))) {
                 continue;
             }
             int newPos = pos.section(QLatin1Char('='), 0, 0).toInt();
             // Don't use scenes shorter than 1 second
             if (newPos - cutPos < 24) {
                 continue;
             }
             clip->getMarkerModel()->addMarker(GenTime(newPos + offset, pCore->getCurrentFps()), label + QString::number(index), markersType);
             index++;
             cutPos = newPos;
         }
     }
     if (!dataProcessed || filterInfo.contains(QStringLiteral("storedata"))) {
         // Store returned data as clip extra data
         QStringList newValue = clip->updatedAnalysisData(key, results.value(key), offset);
         slotAddClipExtraData(id, newValue.at(0), newValue.at(1));
     }
 }
 */
 
 // TODO: move title editing into a better place...
 void Bin::showTitleWidget(const std::shared_ptr<ProjectClip> &clip)
 {
     QString path = clip->getProducerProperty(QStringLiteral("resource"));
     QDir titleFolder(m_doc->projectDataFolder() + QStringLiteral("/titles"));
     titleFolder.mkpath(QStringLiteral("."));
     TitleWidget dia_ui(QUrl(), m_doc->timecode(), titleFolder.absolutePath(), pCore->monitorManager()->projectMonitor(), pCore->window());
     QDomDocument doc;
     QString xmldata = clip->getProducerProperty(QStringLiteral("xmldata"));
     if (xmldata.isEmpty() && QFile::exists(path)) {
         QFile file(path);
         doc.setContent(&file, false);
         file.close();
     } else {
         doc.setContent(xmldata);
     }
     dia_ui.setXml(doc, clip->AbstractProjectItem::clipId());
     if (dia_ui.exec() == QDialog::Accepted) {
         QMap<QString, QString> newprops;
         newprops.insert(QStringLiteral("xmldata"), dia_ui.xml().toString());
         if (dia_ui.duration() != clip->duration().frames(pCore->getCurrentFps())) {
             // duration changed, we need to update duration
             newprops.insert(QStringLiteral("out"), clip->framesToTime(dia_ui.duration() - 1));
             int currentLength = clip->getProducerDuration();
             if (currentLength != dia_ui.duration()) {
                 newprops.insert(QStringLiteral("kdenlive:duration"), clip->framesToTime(dia_ui.duration()));
             }
         }
         // trigger producer reload
         newprops.insert(QStringLiteral("force_reload"), QStringLiteral("2"));
         if (!path.isEmpty()) {
             // we are editing an external file, asked if we want to detach from that file or save the result to that title file.
             if (KMessageBox::questionYesNo(pCore->window(),
                                            i18n("You are editing an external title clip (%1). Do you want to save your changes to the title "
                                                 "file or save the changes for this project only?",
                                                 path),
                                            i18n("Save Title"), KGuiItem(i18n("Save to title file")),
                                            KGuiItem(i18n("Save in project only"))) == KMessageBox::Yes) {
                 // save to external file
                 dia_ui.saveTitle(QUrl::fromLocalFile(path));
                 return;
             } else {
                 newprops.insert(QStringLiteral("resource"), QString());
             }
         }
         slotEditClipCommand(clip->AbstractProjectItem::clipId(), clip->currentProperties(newprops), newprops);
     }
 }
 
 void Bin::slotResetInfoMessage()
 {
     m_errorLog.clear();
     QList<QAction *> actions = m_infoMessage->actions();
     for (int i = 0; i < actions.count(); ++i) {
         m_infoMessage->removeAction(actions.at(i));
     }
 }
 
 
 void Bin::slotSetSorting()
 {
     if (m_listType == BinIconView) {
         m_proxyModel->setFilterKeyColumn(0);
         return;
     }
     auto *view = qobject_cast<QTreeView *>(m_itemView);
     if (view) {
         int ix = view->header()->sortIndicatorSection();
         m_proxyModel->setFilterKeyColumn(ix);
     }
 }
 
 void Bin::slotShowDateColumn(bool show)
 {
     auto *view = qobject_cast<QTreeView *>(m_itemView);
     if (view) {
         view->setColumnHidden(1, !show);
     }
 }
 
 void Bin::slotShowDescColumn(bool show)
 {
     auto *view = qobject_cast<QTreeView *>(m_itemView);
     if (view) {
         view->setColumnHidden(2, !show);
     }
 }
 
 void Bin::slotQueryRemoval(const QString &id, const QString &url, const QString &errorMessage)
 {
     if (m_invalidClipDialog) {
         if (!url.isEmpty()) {
             m_invalidClipDialog->addClip(id, url);
         }
         return;
     }
     QString message = i18n("Clip is invalid, will be removed from project.");
     if (!errorMessage.isEmpty()) {
         message.append("\n" + errorMessage);
     }
     m_invalidClipDialog = new InvalidDialog(i18n("Invalid clip"), message, true, this);
     m_invalidClipDialog->addClip(id, url);
     int result = m_invalidClipDialog->exec();
     if (result == QDialog::Accepted) {
         const QStringList ids = m_invalidClipDialog->getIds();
         Fun undo = []() { return true; };
         Fun redo = []() { return true; };
         for (const QString &i : ids) {
             auto item = m_itemModel->getClipByBinID(i);
             m_itemModel->requestBinClipDeletion(item, undo, redo);
         }
     }
     delete m_invalidClipDialog;
     m_invalidClipDialog = nullptr;
 }
 
 void Bin::slotRefreshClipThumbnail(const QString &id)
 {
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(id);
     if (!clip) {
         return;
     }
     clip->reloadProducer(true);
 }
 
 void Bin::slotAddClipExtraData(const QString &id, const QString &key, const QString &clipData, QUndoCommand *groupCommand)
 {
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(id);
     if (!clip) {
         return;
     }
     QString oldValue = clip->getProducerProperty(key);
     QMap<QString, QString> oldProps;
     oldProps.insert(key, oldValue);
     QMap<QString, QString> newProps;
     newProps.insert(key, clipData);
     auto *command = new EditClipCommand(this, id, oldProps, newProps, true, groupCommand);
     if (!groupCommand) {
         m_doc->commandStack()->push(command);
     }
 }
 
 void Bin::slotUpdateClipProperties(const QString &id, const QMap<QString, QString> &properties, bool refreshPropertiesPanel)
 {
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(id);
     if (clip) {
         clip->setProperties(properties, refreshPropertiesPanel);
     }
 }
 
 void Bin::showSlideshowWidget(const std::shared_ptr<ProjectClip> &clip)
 {
     QString folder = QFileInfo(clip->url()).absolutePath();
     qCDebug(KDENLIVE_LOG) << " ** * CLIP ABS PATH: " << clip->url() << " = " << folder;
     SlideshowClip *dia = new SlideshowClip(m_doc->timecode(), folder, clip.get(), this);
     if (dia->exec() == QDialog::Accepted) {
         // edit clip properties
         QMap<QString, QString> properties;
         properties.insert(QStringLiteral("out"), clip->framesToTime(m_doc->getFramePos(dia->clipDuration()) * dia->imageCount() - 1));
         properties.insert(QStringLiteral("kdenlive:duration"), clip->framesToTime(m_doc->getFramePos(dia->clipDuration()) * dia->imageCount()));
         properties.insert(QStringLiteral("kdenlive:clipname"), dia->clipName());
         properties.insert(QStringLiteral("ttl"), QString::number(m_doc->getFramePos(dia->clipDuration())));
         properties.insert(QStringLiteral("loop"), QString::number(static_cast<int>(dia->loop())));
         properties.insert(QStringLiteral("crop"), QString::number(static_cast<int>(dia->crop())));
         properties.insert(QStringLiteral("fade"), QString::number(static_cast<int>(dia->fade())));
         properties.insert(QStringLiteral("luma_duration"), QString::number(m_doc->getFramePos(dia->lumaDuration())));
         properties.insert(QStringLiteral("luma_file"), dia->lumaFile());
         properties.insert(QStringLiteral("softness"), QString::number(dia->softness()));
         properties.insert(QStringLiteral("animation"), dia->animation());
 
         QMap<QString, QString> oldProperties;
         oldProperties.insert(QStringLiteral("out"), clip->getProducerProperty(QStringLiteral("out")));
         oldProperties.insert(QStringLiteral("kdenlive:duration"), clip->getProducerProperty(QStringLiteral("kdenlive:duration")));
         oldProperties.insert(QStringLiteral("kdenlive:clipname"), clip->name());
         oldProperties.insert(QStringLiteral("ttl"), clip->getProducerProperty(QStringLiteral("ttl")));
         oldProperties.insert(QStringLiteral("loop"), clip->getProducerProperty(QStringLiteral("loop")));
         oldProperties.insert(QStringLiteral("crop"), clip->getProducerProperty(QStringLiteral("crop")));
         oldProperties.insert(QStringLiteral("fade"), clip->getProducerProperty(QStringLiteral("fade")));
         oldProperties.insert(QStringLiteral("luma_duration"), clip->getProducerProperty(QStringLiteral("luma_duration")));
         oldProperties.insert(QStringLiteral("luma_file"), clip->getProducerProperty(QStringLiteral("luma_file")));
         oldProperties.insert(QStringLiteral("softness"), clip->getProducerProperty(QStringLiteral("softness")));
         oldProperties.insert(QStringLiteral("animation"), clip->getProducerProperty(QStringLiteral("animation")));
         slotEditClipCommand(clip->AbstractProjectItem::clipId(), oldProperties, properties);
     }
     delete dia;
 }
 
 void Bin::setBinEffectsEnabled(bool enabled)
 {
     QAction *disableEffects = pCore->window()->actionCollection()->action(QStringLiteral("disable_bin_effects"));
     if (disableEffects) {
         if (enabled == disableEffects->isChecked()) {
             return;
         }
         disableEffects->blockSignals(true);
         disableEffects->setChecked(!enabled);
         disableEffects->blockSignals(false);
     }
     m_itemModel->setBinEffectsEnabled(enabled);
     pCore->projectManager()->disableBinEffects(!enabled);
 }
 
 void Bin::slotRenameItem()
 {
     const QModelIndexList indexes = m_proxyModel->selectionModel()->selectedRows(0);
     for (const QModelIndex &ix : indexes) {
         if (!ix.isValid()) {
             continue;
         }
         m_itemView->setCurrentIndex(ix);
         m_itemView->edit(ix);
         return;
     }
 }
 
 void Bin::refreshProxySettings()
 {
     QList<std::shared_ptr<ProjectClip>> clipList = m_itemModel->getRootFolder()->childClips();
     auto *masterCommand = new QUndoCommand();
     masterCommand->setText(m_doc->useProxy() ? i18n("Enable proxies") : i18n("Disable proxies"));
     // en/disable proxy option in clip properties
     for (QWidget *w : m_propertiesPanel->findChildren<ClipPropertiesController *>()) {
         static_cast<ClipPropertiesController *>(w)->enableProxy(m_doc->useProxy());
     }
     if (!m_doc->useProxy()) {
         // Disable all proxies
         m_doc->slotProxyCurrentItem(false, clipList, false, masterCommand);
     } else {
         QList<std::shared_ptr<ProjectClip>> toProxy;
         for (const std::shared_ptr<ProjectClip> &clp : clipList) {
             ClipType::ProducerType t = clp->clipType();
             if (t == ClipType::Playlist) {
                 toProxy << clp;
                 continue;
             } else if ((t == ClipType::AV || t == ClipType::Video) &&
                        m_doc->autoGenerateProxy(clp->getProducerIntProperty(QStringLiteral("meta.media.width")))) {
                 // Start proxy
                 toProxy << clp;
                 continue;
             } else if (t == ClipType::Image && m_doc->autoGenerateImageProxy(clp->getProducerIntProperty(QStringLiteral("meta.media.width")))) {
                 // Start proxy
                 toProxy << clp;
                 continue;
             }
         }
         if (!toProxy.isEmpty()) {
             m_doc->slotProxyCurrentItem(true, toProxy, false, masterCommand);
         }
     }
     if (masterCommand->childCount() > 0) {
         m_doc->commandStack()->push(masterCommand);
     } else {
         delete masterCommand;
     }
 }
 
 QStringList Bin::getProxyHashList()
 {
     QStringList list;
     QList<std::shared_ptr<ProjectClip>> clipList = m_itemModel->getRootFolder()->childClips();
     for (const std::shared_ptr<ProjectClip> &clp : clipList) {
         if (clp->clipType() == ClipType::AV || clp->clipType() == ClipType::Video || clp->clipType() == ClipType::Playlist) {
             list << clp->hash();
         }
     }
     return list;
 }
 
 bool Bin::isEmpty() const
 {
     if (m_itemModel->getRootFolder() == nullptr) {
         return true;
     }
     return !m_itemModel->getRootFolder()->hasChildClips();
 }
 
 void Bin::reloadAllProducers()
 {
     if (m_itemModel->getRootFolder() == nullptr || m_itemModel->getRootFolder()->childCount() == 0 || !isEnabled()) {
         return;
     }
     QList<std::shared_ptr<ProjectClip>> clipList = m_itemModel->getRootFolder()->childClips();
     emit openClip(std::shared_ptr<ProjectClip>());
     for (const std::shared_ptr<ProjectClip> &clip : clipList) {
         QDomDocument doc;
         QDomElement xml = clip->toXml(doc, false, false);
         // Make sure we reload clip length
         if (clip->clipType() == ClipType::AV || clip->clipType() == ClipType::Video || clip->clipType() == ClipType::Audio || clip->clipType() == ClipType::Playlist) {
             xml.removeAttribute(QStringLiteral("out"));
             Xml::removeXmlProperty(xml, QStringLiteral("length"));
         }
         if (clip->isValid()) {
             clip->resetProducerProperty(QStringLiteral("kdenlive:duration"));
             clip->resetProducerProperty(QStringLiteral("length"));
         }
         if (!xml.isNull()) {
             clip->setClipStatus(AbstractProjectItem::StatusWaiting);
             pCore->jobManager()->slotDiscardClipJobs(clip->clipId());
             clip->discardAudioThumb();
             // We need to set a temporary id before all outdated producers are replaced;
             int jobId = pCore->jobManager()->startJob<LoadJob>({clip->clipId()}, -1, QString(), xml);
             ThumbnailCache::get()->invalidateThumbsForClip(clip->clipId(), true);
             pCore->jobManager()->startJob<ThumbJob>({clip->clipId()}, jobId, QString(), 150, -1, true, true);
             pCore->jobManager()->startJob<AudioThumbJob>({clip->clipId()}, jobId, QString());
         }
     }
 }
 
 void Bin::slotMessageActionTriggered()
 {
     m_infoMessage->animatedHide();
 }
 
 void Bin::resetUsageCount()
 {
     const QList<std::shared_ptr<ProjectClip>> clipList = m_itemModel->getRootFolder()->childClips();
     for (const std::shared_ptr<ProjectClip> &clip : clipList) {
         clip->setRefCount(0);
     }
 }
 
 void Bin::getBinStats(uint *used, uint *unused, qint64 *usedSize, qint64 *unusedSize)
 {
     QList<std::shared_ptr<ProjectClip>> clipList = m_itemModel->getRootFolder()->childClips();
     for (const std::shared_ptr<ProjectClip> &clip : clipList) {
         if (clip->refCount() == 0) {
             *unused += 1;
             *unusedSize += clip->getProducerInt64Property(QStringLiteral("kdenlive:file_size"));
         } else {
             *used += 1;
             *usedSize += clip->getProducerInt64Property(QStringLiteral("kdenlive:file_size"));
         }
     }
 }
 
 QDir Bin::getCacheDir(CacheType type, bool *ok) const
 {
     return m_doc->getCacheDir(type, ok);
 }
 
 void Bin::rebuildProxies()
 {
     QList<std::shared_ptr<ProjectClip>> clipList = m_itemModel->getRootFolder()->childClips();
     QList<std::shared_ptr<ProjectClip>> toProxy;
     for (const std::shared_ptr<ProjectClip> &clp : clipList) {
         if (clp->hasProxy()) {
             toProxy << clp;
             // Abort all pending jobs
             pCore->jobManager()->discardJobs(clp->clipId(), AbstractClipJob::PROXYJOB);
             clp->deleteProxy();
         }
     }
     if (toProxy.isEmpty()) {
         return;
     }
     auto *masterCommand = new QUndoCommand();
     masterCommand->setText(i18n("Rebuild proxies"));
     m_doc->slotProxyCurrentItem(true, toProxy, true, masterCommand);
     if (masterCommand->childCount() > 0) {
         m_doc->commandStack()->push(masterCommand);
     } else {
         delete masterCommand;
     }
 }
 
 void Bin::showClearButton(bool show)
 {
     m_searchLine->setClearButtonEnabled(show);
 }
 
 void Bin::saveZone(const QStringList &info, const QDir &dir)
 {
     if (info.size() != 3) {
         return;
     }
     std::shared_ptr<ProjectClip> clip = getBinClip(info.constFirst());
     if (clip) {
         QPoint zone(info.at(1).toInt(), info.at(2).toInt());
         clip->saveZone(zone, dir);
     }
 }
 
 void Bin::setCurrent(const std::shared_ptr<AbstractProjectItem> &item)
 {
     switch (item->itemType()) {
     case AbstractProjectItem::ClipItem: {
         openProducer(std::static_pointer_cast<ProjectClip>(item));
         std::shared_ptr<ProjectClip> clp = std::static_pointer_cast<ProjectClip>(item);
         emit requestShowEffectStack(clp->clipName(), clp->m_effectStack, clp->getFrameSize(), false);
         break;
     }
     case AbstractProjectItem::SubClipItem: {
         auto subClip = std::static_pointer_cast<ProjectSubClip>(item);
         QPoint zone = subClip->zone();
         openProducer(subClip->getMasterClip(), zone.x(), zone.y());
         break;
     }
     case AbstractProjectItem::FolderItem:
     default:
         break;
     }
 }
 
 void Bin::cleanup()
 {
     m_itemModel->requestCleanup();
 }
 
 std::shared_ptr<EffectStackModel> Bin::getClipEffectStack(int itemId)
 {
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(QString::number(itemId));
     Q_ASSERT(clip != nullptr);
     std::shared_ptr<EffectStackModel> effectStack = std::static_pointer_cast<ClipController>(clip)->m_effectStack;
     return effectStack;
 }
 
 size_t Bin::getClipDuration(int itemId) const
 {
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(QString::number(itemId));
     Q_ASSERT(clip != nullptr);
     return clip->frameDuration();
 }
 
 PlaylistState::ClipState Bin::getClipState(int itemId) const
 {
     std::shared_ptr<ProjectClip> clip = m_itemModel->getClipByBinID(QString::number(itemId));
     Q_ASSERT(clip != nullptr);
     bool audio = clip->hasAudio();
     bool video = clip->hasVideo();
     return audio ? (video ? PlaylistState::Disabled : PlaylistState::AudioOnly) : PlaylistState::VideoOnly;
 }
 
 QString Bin::getCurrentFolder()
 {
     // Check parent item
     QModelIndex ix = m_proxyModel->selectionModel()->currentIndex();
     std::shared_ptr<ProjectFolder> parentFolder = m_itemModel->getRootFolder();
     if (ix.isValid() && m_proxyModel->selectionModel()->isSelected(ix)) {
         std::shared_ptr<AbstractProjectItem> currentItem = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(ix));
         parentFolder = std::static_pointer_cast<ProjectFolder>(currentItem->getEnclosingFolder());
     }
     return parentFolder->clipId();
 }
 
 void Bin::adjustProjectProfileToItem()
 {
     QModelIndex current = m_proxyModel->selectionModel()->currentIndex();
     if (current.isValid()) {
         // User clicked in the icon, open clip properties
         std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(current));
         auto clip = std::static_pointer_cast<ProjectClip>(item);
         if (clip) {
             QDomDocument doc;
             LoadJob::checkProfile(clip->clipId(), clip->toXml(doc, false), clip->originalProducer());
         }
     }
 }
 
 void Bin::showBinFrame(QModelIndex ix, int frame)
 {
     std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(ix));
     if (item) {
         ClipType::ProducerType type = item->clipType();
             if (type != ClipType::AV && type != ClipType::Video && type != ClipType::Playlist && type != ClipType::SlideShow) {
             return;
         }
         if (item->itemType() == AbstractProjectItem::ClipItem) {
             auto clip = std::static_pointer_cast<ProjectClip>(item);
             if (clip && (clip->clipType() == ClipType::AV || clip->clipType() == ClipType::Video || clip->clipType() == ClipType::Playlist)) {
                 clip->getThumbFromPercent(frame);
             }
         } else if (item->itemType() == AbstractProjectItem::SubClipItem) {
             auto clip = std::static_pointer_cast<ProjectSubClip>(item);
             if (clip && (clip->clipType() == ClipType::AV || clip->clipType() == ClipType::Video || clip->clipType() == ClipType::Playlist)) {
                 clip->getThumbFromPercent(frame);
             }
         }
     }
 }
 
 void Bin::invalidateClip(const QString &binId)
 {
     std::shared_ptr<ProjectClip> clip = getBinClip(binId);
     if (clip && clip->clipType() != ClipType::Audio) {
         QList<int> ids = clip->timelineInstances();
         for (int i : ids) {
             pCore->invalidateItem({ObjectType::TimelineClip,i});
         }
     }
 }
 
 QSize Bin::sizeHint() const
 {
     return QSize(350, pCore->window()->height() / 2);
 }
 
 void Bin::slotBack()
 {
     QModelIndex currentRootIx = m_itemView->rootIndex();
     if (!currentRootIx.isValid()) {
         return;
     }
     std::shared_ptr<AbstractProjectItem> item = m_itemModel->getBinItemByIndex(m_proxyModel->mapToSource(currentRootIx));
     if (!item) {
         qDebug()<<"=== ERRO CANNOT FIND ROOT FOR CURRENT VIEW";
         return;
     }
     std::shared_ptr<AbstractProjectItem> parentItem = item->parent();
     if (!parentItem) {
         qDebug()<<"=== ERRO CANNOT FIND PARENT FOR CURRENT VIEW";
         return;
     }
     if (parentItem != m_itemModel->getRootFolder()) {
         // We are entering a parent folder
         QModelIndex parentId = getIndexForId(parentItem->clipId(), parentItem->itemType() == AbstractProjectItem::FolderItem);
         if (parentId.isValid()) {
             m_itemView->setRootIndex(m_proxyModel->mapFromSource(parentId));
         }
     } else {
         m_itemView->setRootIndex(QModelIndex());
         m_upAction->setEnabled(false);
     }
 }
 
diff --git a/src/bin/bin.h b/src/bin/bin.h
index 612b582e9..4bc3729a0 100644
--- a/src/bin/bin.h
+++ b/src/bin/bin.h
@@ -1,471 +1,475 @@
 /*
 Copyright (C) 2012  Till Theato <root@ttill.de>
 Copyright (C) 2014  Jean-Baptiste Mardelle <jb@kdenlive.org>
 This file is part of Kdenlive. See www.kdenlive.org.
 
 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) version 3 or any later version
 accepted by the membership of KDE e.V. (or its successor approved
 by the membership of KDE e.V.), which shall act as a proxy
 defined in Section 14 of version 3 of the license.
 
 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, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef KDENLIVE_BIN_H
 #define KDENLIVE_BIN_H
 
 #include "abstractprojectitem.h"
 #include "timecode.h"
 
 #include <KMessageWidget>
 
 #include <QDir>
 #include <QDomElement>
 #include <QFuture>
 #include <QLineEdit>
 #include <QListView>
 #include <QMutex>
 #include <QPushButton>
 #include <QTreeView>
 #include <QUrl>
 #include <QWidget>
 
 class AbstractProjectItem;
 class BinItemDelegate;
 class BinListItemDelegate;
 class ClipController;
 class EffectStackModel;
 class InvalidDialog;
 class KdenliveDoc;
 class Monitor;
 class ProjectClip;
 class ProjectFolder;
 class ProjectItemModel;
 class ProjectSortProxyModel;
 class QDockWidget;
 class QMenu;
 class QScrollArea;
 class QTimeLine;
 class QToolBar;
 class QToolButton;
 class QUndoCommand;
 class QVBoxLayout;
+class QActionGroup;
 class SmallJobLabel;
 
 namespace Mlt {
 class Producer;
 }
 
 class MyListView : public QListView
 {
     Q_OBJECT
 public:
     explicit MyListView(QWidget *parent = nullptr);
 
 protected:
     void mousePressEvent(QMouseEvent *event) override;
     void focusInEvent(QFocusEvent *event) override;
     void mouseMoveEvent(QMouseEvent *event) override;
 signals:
     void focusView();
     void updateDragMode(PlaylistState::ClipState type);
     void displayBinFrame(QModelIndex ix, int frame);
 private:
     QPoint m_startPos;
     PlaylistState::ClipState m_dragType;
 };
 
 class MyTreeView : public QTreeView
 {
     Q_OBJECT
     Q_PROPERTY(bool editing READ isEditing WRITE setEditing)
 public:
     explicit MyTreeView(QWidget *parent = nullptr);
     void setEditing(bool edit);
 
 protected:
     void mousePressEvent(QMouseEvent *event) override;
     void mouseMoveEvent(QMouseEvent *event) override;
     void focusInEvent(QFocusEvent *event) override;
 
 protected slots:
     void closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHint hint) override;
     void editorDestroyed(QObject *editor) override;
 
 private:
     QPoint m_startPos;
     PlaylistState::ClipState m_dragType;
     bool m_editing;
     bool performDrag();
     bool isEditing() const;
 
 signals:
     void focusView();
     void updateDragMode(PlaylistState::ClipState type);
     void displayBinFrame(QModelIndex ix, int frame);
 };
 
 class SmallJobLabel : public QPushButton
 {
     Q_OBJECT
 public:
     explicit SmallJobLabel(QWidget *parent = nullptr);
     static const QString getStyleSheet(const QPalette &p);
     void setAction(QAction *action);
 
 private:
     enum ItemRole { NameRole = Qt::UserRole, DurationRole, UsageRole };
 
     QTimeLine *m_timeLine;
     QAction *m_action{nullptr};
     QMutex m_locker;
 
 public slots:
     void slotSetJobCount(int jobCount);
 
 private slots:
     void slotTimeLineChanged(qreal value);
     void slotTimeLineFinished();
 };
 
 class LineEventEater : public QObject
 {
     Q_OBJECT
 public:
     explicit LineEventEater(QObject *parent = nullptr);
 
 protected:
     bool eventFilter(QObject *obj, QEvent *event) override;
 
 signals:
     void clearSearchLine();
     void showClearButton(bool);
 };
 
 /**
  * @class Bin
  * @brief The bin widget takes care of both item model and view upon project opening.
  */
 
 class Bin : public QWidget
 {
     Q_OBJECT
 
     /** @brief Defines the view types (icon view, tree view,...)  */
     enum BinViewType { BinTreeView, BinIconView };
 
 public:
     explicit Bin(std::shared_ptr<ProjectItemModel> model, QWidget *parent = nullptr);
     ~Bin() override;
 
     bool isLoading;
 
     /** @brief Sets the document for the bin and initialize some stuff  */
     void setDocument(KdenliveDoc *project);
 
     /** @brief Create a clip item from its xml description  */
     void createClip(const QDomElement &xml);
 
     /** @brief Used to notify the Model View that an item was updated */
     void emitItemUpdated(std::shared_ptr<AbstractProjectItem> item);
 
     /** @brief Set monitor associated with this bin (clipmonitor) */
     void setMonitor(Monitor *monitor);
 
     /** @brief Returns the clip monitor */
     Monitor *monitor();
 
     /** @brief Open a producer in the clip monitor */
     void openProducer(std::shared_ptr<ProjectClip> controller);
     void openProducer(std::shared_ptr<ProjectClip> controller, int in, int out);
 
     /** @brief Get a clip from it's id */
     std::shared_ptr<ProjectClip> getBinClip(const QString &id);
 
     /** @brief Returns a list of selected clip ids
      */
     std::vector<QString> selectedClipsIds();
 
     // Returns the selected clips
     QList<std::shared_ptr<ProjectClip>> selectedClips();
 
     /** @brief Current producer has changed, refresh monitor and timeline*/
     void refreshClip(const QString &id);
 
     void setupMenu();
 
     /** @brief The source file was modified, we will reload it soon, disable item in the meantime */
     void setWaitingStatus(const QString &id);
 
     const QString getDocumentProperty(const QString &key);
 
     /** @brief Ask MLT to reload this clip's producer  */
     void reloadClip(const QString &id, bool reloadAudio = true);
 
     /** @brief refresh monitor (if clip changed)  */
     void reloadMonitorIfActive(const QString &id);
 
     void doMoveClip(const QString &id, const QString &newParentId);
     void doMoveFolder(const QString &id, const QString &newParentId);
     void setupGeneratorMenu();
 
     /** @brief Set focus to the Bin view. */
     void focusBinView() const;
     /** @brief Get a string list of all clip ids that are inside a folder defined by id. */
     QStringList getBinFolderClipIds(const QString &id) const;
     /** @brief Build a rename subclip command. */
     void renameSubClipCommand(const QString &id, const QString &newName, const QString &oldName, int in, int out);
     /** @brief Rename a clip zone (subclip). */
     void renameSubClip(const QString &id, const QString &newName, int in, int out);
     /** @brief Returns current project's timecode. */
     Timecode projectTimecode() const;
     /** @brief Trigger timecode format refresh where needed. */
     void updateTimecodeFormat();
     /** @brief Edit an effect settings to a bin clip. */
     void editMasterEffect(const std::shared_ptr<AbstractProjectItem> &clip);
     /** @brief An effect setting was changed, update stack if displayed. */
     void updateMasterEffect(ClipController *ctl);
     void rebuildMenu();
     void refreshIcons();
 
     /** @brief This function change the global enabled state of the bin effects
      */
     void setBinEffectsEnabled(bool enabled);
 
     void requestAudioThumbs(const QString &id, long duration);
     /** @brief Proxy status for the project changed, update. */
     void refreshProxySettings();
     /** @brief A clip is ready, update its info panel if displayed. */
     void emitRefreshPanel(const QString &id);
     /** @brief Returns true if there is no clip. */
     bool isEmpty() const;
     /** @brief Trigger reload of all clips. */
     void reloadAllProducers();
     /** @brief Get usage stats for project bin. */
     void getBinStats(uint *used, uint *unused, qint64 *usedSize, qint64 *unusedSize);
     /** @brief Returns the clip properties dockwidget. */
     QDockWidget *clipPropertiesDock();
     /** @brief Returns a document's cache dir. ok is set to false if folder does not exist */
     QDir getCacheDir(CacheType type, bool *ok) const;
     void rebuildProxies();
     /** @brief Return a list of all clips hashes used in this project */
     QStringList getProxyHashList();
     /** @brief Get binId of the current selected folder */
     QString getCurrentFolder();
     /** @brief Save a clip zone as MLT playlist */
     void saveZone(const QStringList &info, const QDir &dir);
     /** @brief A bin clip changed (its effects), invalidate preview */
     void invalidateClip(const QString &binId);
 
     // TODO refac: remove this and call directly the function in ProjectItemModel
     void cleanup();
 
 private slots:
     void slotAddClip();
     void slotReloadClip();
     /** @brief Set sorting column */
     void slotSetSorting();
     /** @brief Show/hide date column */
     void slotShowDateColumn(bool show);
     void slotShowDescColumn(bool show);
     /** @brief Go to parent folder */
     void slotBack();
     /** @brief Setup the bin view type (icon view, tree view, ...).
      * @param action The action whose data defines the view type or nullptr to keep default view */
     void slotInitView(QAction *action);
 
     /** @brief Update status for clip jobs  */
     void slotUpdateJobStatus(const QString &, int, int, const QString &label = QString(), const QString &actionName = QString(),
                              const QString &details = QString());
     void slotSetIconSize(int size);
     void selectProxyModel(const QModelIndex &id);
     void slotSaveHeaders();
     void slotItemDropped(const QStringList &ids, const QModelIndex &parent);
     void slotItemDropped(const QList<QUrl> &urls, const QModelIndex &parent);
     void slotEffectDropped(const QStringList &effectData, const QModelIndex &parent);
     void slotItemEdited(const QModelIndex &, const QModelIndex &, const QVector<int> &);
 
     /** @brief Reset all text and log data from info message widget. */
     void slotResetInfoMessage();
     /** @brief Show dialog prompting for removal of invalid clips. */
     void slotQueryRemoval(const QString &id, const QString &url, const QString &errorMessage);
     /** @brief Request display of current clip in monitor. */
     void slotOpenCurrent();
     void slotZoomView(bool zoomIn);
     /** @brief Widget gained focus, make sure we display effects for master clip. */
     void slotGotFocus();
     /** @brief Rename a Bin Item. */
     void slotRenameItem();
     void doRefreshPanel(const QString &id);
     /** @brief Enable item view and hide message */
     void slotMessageActionTriggered();
     /** @brief Request editing of title or slideshow clip */
     void slotEditClip();
     /** @brief Enable / disable clear button on search line
      *  this is a workaround foq Qt bug 54676
      */
     void showClearButton(bool show);
     /** @brief Display a defined frame in bin clip thumbnail
      */
     void showBinFrame(QModelIndex ix, int frame);
 
 public slots:
     void slotRemoveInvalidClip(const QString &id, bool replace, const QString &errorMessage);
     /** @brief Reload clip thumbnail - when frame for thumbnail changed */
     void slotRefreshClipThumbnail(const QString &id);
     void slotDeleteClip();
     void slotItemDoubleClicked(const QModelIndex &ix, const QPoint &pos);
     void slotSwitchClipProperties(const std::shared_ptr<ProjectClip> &clip);
     void slotSwitchClipProperties();
     /** @brief Creates a new folder with optional name, and returns new folder's id */
     void slotAddFolder();
     void slotCreateProjectClip();
     void slotEditClipCommand(const QString &id, const QMap<QString, QString> &oldProps, const QMap<QString, QString> &newProps);
     /** @brief Start a filter job requested by a filter applied in timeline */
     void slotStartFilterJob(const ItemInfo &info, const QString &id, QMap<QString, QString> &filterParams, QMap<QString, QString> &consumerParams,
                             QMap<QString, QString> &extraParams);
     /** @brief Open current clip in an external editing application */
     void slotOpenClip();
     void slotDuplicateClip();
     void slotLocateClip();
     /** @brief Add extra data to a clip. */
     void slotAddClipExtraData(const QString &id, const QString &key, const QString &data = QString(), QUndoCommand *groupCommand = nullptr);
     void slotUpdateClipProperties(const QString &id, const QMap<QString, QString> &properties, bool refreshPropertiesPanel);
     /** @brief Add effect to active Bin clip (used when double clicking an effect in list). */
     void slotAddEffect(QString id, const QStringList &effectData);
     void slotExpandUrl(const ItemInfo &info, const QString &url, QUndoCommand *command);
     /** @brief Abort all ongoing operations to prepare close. */
     void abortOperations();
     void doDisplayMessage(const QString &text, KMessageWidget::MessageType type, const QList<QAction *> &actions = QList<QAction *>());
     void doDisplayMessage(const QString &text, KMessageWidget::MessageType type, const QString &logInfo);
     /** @brief Reset all clip usage to 0 */
     void resetUsageCount();
     /** @brief Select a clip in the Bin from its id. */
     void selectClipById(const QString &id, int frame = -1, const QPoint &zone = QPoint());
     void slotAddClipToProject(const QUrl &url);
     void droppedUrls(const QList<QUrl> &urls, const QString &folderInfo = QString());
     /** @brief Returns the effectstack of a given clip. */
     std::shared_ptr<EffectStackModel> getClipEffectStack(int itemId);
     /** @brief Returns the duration of a given clip. */
     size_t getClipDuration(int itemId) const;
     /** @brief Returns the state of a given clip: AudioOnly, VideoOnly, Disabled (Disabled means it has audio and video capabilities */
     PlaylistState::ClipState getClipState(int itemId) const;
     /** @brief Adjust project profile to current clip. */
     void adjustProjectProfileToItem();
 
 protected:
     /* This function is called whenever an item is selected to propagate signals
        (for ex request to show the clip in the monitor)
     */
     void setCurrent(const std::shared_ptr<AbstractProjectItem> &item);
     void selectClip(const std::shared_ptr<ProjectClip> &clip);
     void contextMenuEvent(QContextMenuEvent *event) override;
     bool eventFilter(QObject *obj, QEvent *event) override;
     QSize sizeHint() const override;
 
 private:
     std::shared_ptr<ProjectItemModel> m_itemModel;
     QAbstractItemView *m_itemView;
     BinItemDelegate *m_binTreeViewDelegate;
     BinListItemDelegate *m_binListViewDelegate;
     std::unique_ptr<ProjectSortProxyModel> m_proxyModel;
     QToolBar *m_toolbar;
     KdenliveDoc *m_doc;
     QLineEdit *m_searchLine;
     QToolButton *m_addButton;
     QMenu *m_extractAudioAction;
     QMenu *m_transcodeAction;
     QMenu *m_clipsActionsMenu;
     QAction *m_inTimelineAction;
     QAction *m_showDate;
     QAction *m_showDesc;
+    QAction *m_sortDescend;
     /** @brief Default view type (icon, tree, ...) */
     BinViewType m_listType;
     /** @brief Default icon size for the views. */
     QSize m_iconSize;
     /** @brief Keeps the column width info of the tree view. */
     QByteArray m_headerInfo;
     QVBoxLayout *m_layout;
     QDockWidget *m_propertiesDock;
     QScrollArea *m_propertiesPanel;
     QSlider *m_slider;
     Monitor *m_monitor;
     QIcon m_blankThumb;
     QMenu *m_menu;
     QAction *m_openAction;
     QAction *m_editAction;
     QAction *m_reloadAction;
     QAction *m_duplicateAction;
     QAction *m_locateAction;
     QAction *m_proxyAction;
     QAction *m_deleteAction;
     QAction *m_renameAction;
     QMenu *m_jobsMenu;
     QAction *m_cancelJobs;
     QAction *m_discardCurrentClipJobs;
     QAction *m_discardPendingJobs;
     QAction *m_upAction;
+    QActionGroup *m_sortGroup;
     SmallJobLabel *m_infoLabel;
     /** @brief The info widget for failed jobs. */
     KMessageWidget *m_infoMessage;
     QStringList m_errorLog;
     InvalidDialog *m_invalidClipDialog;
     /** @brief Set to true if widget just gained focus (means we have to update effect stack . */
     bool m_gainedFocus;
     /** @brief List of Clip Ids that want an audio thumb. */
     QStringList m_audioThumbsList;
     QString m_processingAudioThumb;
     QMutex m_audioThumbMutex;
     /** @brief Total number of milliseconds to process for audio thumbnails */
     long m_audioDuration;
     /** @brief Total number of milliseconds already processed for audio thumbnails */
     long m_processedAudio;
     /** @brief Indicates whether audio thumbnail creation is running. */
     QFuture<void> m_audioThumbsThread;
     QAction *addAction(const QString &name, const QString &text, const QIcon &icon);
     void setupAddClipAction(QMenu *addClipMenu, ClipType::ProducerType type, const QString &name, const QString &text, const QIcon &icon);
     void showClipProperties(const std::shared_ptr<ProjectClip> &clip, bool forceRefresh = false);
     /** @brief Get the QModelIndex value for an item in the Bin. */
     QModelIndex getIndexForId(const QString &id, bool folderWanted) const;
     std::shared_ptr<ProjectClip> getFirstSelectedClip();
     void showTitleWidget(const std::shared_ptr<ProjectClip> &clip);
     void showSlideshowWidget(const std::shared_ptr<ProjectClip> &clip);
     void processAudioThumbs();
+    void updateSortingAction(int ix);
     int wheelAccumulatedDelta;
 
 signals:
     void itemUpdated(std::shared_ptr<AbstractProjectItem>);
     void producerReady(const QString &id);
     /** @brief Save folder info into MLT. */
     void storeFolder(const QString &folderId, const QString &parentId, const QString &oldParentId, const QString &folderName);
     void gotFilterJobResults(const QString &, int, int, stringMap, stringMap);
     /** @brief Trigger timecode format refresh where needed. */
     void refreshTimeCode();
     /** @brief Request display of effect stack for a Bin clip. */
     void requestShowEffectStack(const QString &clipName, std::shared_ptr<EffectStackModel>, QSize frameSize, bool showKeyframes);
     /** @brief Request that the given clip is displayed in the clip monitor */
     void requestClipShow(std::shared_ptr<ProjectClip>);
     void displayBinMessage(const QString &, KMessageWidget::MessageType);
     void requesteInvalidRemoval(const QString &, const QString &, const QString &);
     /** @brief Analysis data changed, refresh panel. */
     void updateAnalysisData(const QString &);
     void openClip(std::shared_ptr<ProjectClip> c, int in = -1, int out = -1);
     /** @brief Fill context menu with occurrences of this clip in timeline. */
     void findInTimeline(const QString &, QList<int> ids = QList<int>());
     void clipNameChanged(const QString &);
     /** @brief A clip was updated, request panel update. */
     void refreshPanel(const QString &id);
     /** @brief Upon selection, activate timeline target tracks. */
     void setupTargets(bool hasVideo, QList <int> audioStreams);
 };
 
 #endif
diff --git a/src/bin/projectitemmodel.cpp b/src/bin/projectitemmodel.cpp
index fe03c5545..5012569d2 100644
--- a/src/bin/projectitemmodel.cpp
+++ b/src/bin/projectitemmodel.cpp
@@ -1,1045 +1,1051 @@
 /*
 Copyright (C) 2012  Till Theato <root@ttill.de>
 Copyright (C) 2014  Jean-Baptiste Mardelle <jb@kdenlive.org>
 Copyright (C) 2017  Nicolas Carion
 This file is part of Kdenlive. See www.kdenlive.org.
 
 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) version 3 or any later version
 accepted by the membership of KDE e.V. (or its successor approved
 by the membership of KDE e.V.), which shall act as a proxy
 defined in Section 14 of version 3 of the license.
 
 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, see <http://www.gnu.org/licenses/>.
 */
 
 #include "projectitemmodel.h"
 #include "abstractprojectitem.h"
 #include "binplaylist.hpp"
 #include "core.h"
 #include "doc/kdenlivedoc.h"
 #include "filewatcher.hpp"
 #include "jobs/audiothumbjob.hpp"
 #include "jobs/jobmanager.h"
 #include "jobs/loadjob.hpp"
 #include "jobs/thumbjob.hpp"
 #include "jobs/cachejob.hpp"
 #include "kdenlivesettings.h"
 #include "macros.hpp"
 #include "profiles/profilemodel.hpp"
 #include "project/projectmanager.h"
 #include "projectclip.h"
 #include "projectfolder.h"
 #include "projectsubclip.h"
 #include "xml/xml.hpp"
 
 #include <KLocalizedString>
 #include <QIcon>
 #include <QMimeData>
 #include <QProgressDialog>
 #include <mlt++/Mlt.h>
 #include <queue>
 #include <qvarlengtharray.h>
 #include <utility>
 
 ProjectItemModel::ProjectItemModel(QObject *parent)
     : AbstractTreeModel(parent)
     , m_lock(QReadWriteLock::Recursive)
     , m_binPlaylist(new BinPlaylist())
     , m_fileWatcher(new FileWatcher())
     , m_nextId(1)
     , m_blankThumb()
     , m_dragType(PlaylistState::Disabled)
 {
     QPixmap pix(QSize(160, 90));
     pix.fill(Qt::lightGray);
     m_blankThumb.addPixmap(pix);
     connect(m_fileWatcher.get(), &FileWatcher::binClipModified, this, &ProjectItemModel::reloadClip);
     connect(m_fileWatcher.get(), &FileWatcher::binClipWaiting, this, &ProjectItemModel::setClipWaiting);
     connect(m_fileWatcher.get(), &FileWatcher::binClipMissing, this, &ProjectItemModel::setClipInvalid);
 }
 
 std::shared_ptr<ProjectItemModel> ProjectItemModel::construct(QObject *parent)
 {
     std::shared_ptr<ProjectItemModel> self(new ProjectItemModel(parent));
     self->rootItem = ProjectFolder::construct(self);
     return self;
 }
 
 ProjectItemModel::~ProjectItemModel() = default;
 
 int ProjectItemModel::mapToColumn(int column) const
 {
     switch (column) {
     case 0:
         return AbstractProjectItem::DataName;
         break;
     case 1:
         return AbstractProjectItem::DataDate;
         break;
     case 2:
         return AbstractProjectItem::DataDescription;
         break;
+    case 3:
+        return AbstractProjectItem::ClipType;
+        break;
     default:
         return AbstractProjectItem::DataName;
     }
 }
 
 QVariant ProjectItemModel::data(const QModelIndex &index, int role) const
 {
     READ_LOCK();
     if (!index.isValid()) {
         return QVariant();
     }
     if (role == Qt::DisplayRole || role == Qt::EditRole) {
         std::shared_ptr<AbstractProjectItem> item = getBinItemByIndex(index);
         auto type = static_cast<AbstractProjectItem::DataType>(mapToColumn(index.column()));
         QVariant ret = item->getData(type);
         return ret;
     }
     if (role == Qt::DecorationRole) {
         if (index.column() != 0) {
             return QVariant();
         }
         // Data has to be returned as icon to allow the view to scale it
         std::shared_ptr<AbstractProjectItem> item = getBinItemByIndex(index);
         QVariant thumb = item->getData(AbstractProjectItem::DataThumbnail);
         QIcon icon;
         if (thumb.canConvert<QIcon>()) {
             icon = thumb.value<QIcon>();
         } else {
             qDebug() << "ERROR: invalid icon found";
         }
         return icon;
     }
     std::shared_ptr<AbstractProjectItem> item = getBinItemByIndex(index);
     return item->getData(static_cast<AbstractProjectItem::DataType>(role));
 }
 
 bool ProjectItemModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     QWriteLocker locker(&m_lock);
     std::shared_ptr<AbstractProjectItem> item = getBinItemByIndex(index);
     if (item->rename(value.toString(), index.column())) {
         emit dataChanged(index, index, {role});
         return true;
     }
     // Item name was not changed
     return false;
 }
 
 Qt::ItemFlags ProjectItemModel::flags(const QModelIndex &index) const
 {
     /*return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsEditable;*/
     READ_LOCK();
     if (!index.isValid()) {
         return Qt::ItemIsDropEnabled;
     }
     std::shared_ptr<AbstractProjectItem> item = getBinItemByIndex(index);
     AbstractProjectItem::PROJECTITEMTYPE type = item->itemType();
     switch (type) {
     case AbstractProjectItem::FolderItem:
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsEditable;
         break;
     case AbstractProjectItem::ClipItem:
         if (!item->statusReady()) {
             return Qt::ItemIsSelectable;
         }
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsEditable;
         break;
     case AbstractProjectItem::SubClipItem:
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled;
         break;
     default:
         return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
     }
 }
 
 // cppcheck-suppress unusedFunction
 bool ProjectItemModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
     Q_UNUSED(row)
     Q_UNUSED(column)
     QWriteLocker locker(&m_lock);
     if (action == Qt::IgnoreAction) {
         return true;
     }
 
     if (data->hasUrls()) {
         emit itemDropped(data->urls(), parent);
         return true;
     }
 
     if (data->hasFormat(QStringLiteral("kdenlive/producerslist"))) {
         // Dropping an Bin item
         const QStringList ids = QString(data->data(QStringLiteral("kdenlive/producerslist"))).split(QLatin1Char(';'));
         if (ids.constFirst().contains(QLatin1Char('/'))) {
             // subclip zone
             QStringList clipData = ids.constFirst().split(QLatin1Char('/'));
             if (clipData.length() >= 3) {
                 QString id;
                 return requestAddBinSubClip(id, clipData.at(1).toInt(), clipData.at(2).toInt(), QString(), clipData.at(0));
             } else {
                 // error, malformed clip zone, abort
                 return false;
             }
         } else {
             emit itemDropped(ids, parent);
         }
         return true;
     }
 
     if (data->hasFormat(QStringLiteral("kdenlive/effect"))) {
         // Dropping effect on a Bin item
         QStringList effectData;
         effectData << QString::fromUtf8(data->data(QStringLiteral("kdenlive/effect")));
         QStringList source = QString::fromUtf8(data->data(QStringLiteral("kdenlive/effectsource"))).split(QLatin1Char('-'));
         effectData << source;
         emit effectDropped(effectData, parent);
         return true;
     }
 
     if (data->hasFormat(QStringLiteral("kdenlive/clip"))) {
         const QStringList list = QString(data->data(QStringLiteral("kdenlive/clip"))).split(QLatin1Char(';'));
         QString id;
         return requestAddBinSubClip(id, list.at(1).toInt(), list.at(2).toInt(), QString(), list.at(0));
     }
 
     return false;
 }
 
 QVariant ProjectItemModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     READ_LOCK();
     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
         QVariant columnName;
         switch (section) {
         case 0:
             columnName = i18n("Name");
             break;
         case 1:
             columnName = i18n("Date");
             break;
         case 2:
             columnName = i18n("Description");
             break;
+        case 3:
+            columnName = i18n("Type");
+            break;
         default:
             columnName = i18n("Unknown");
             break;
         }
         return columnName;
     }
     return QAbstractItemModel::headerData(section, orientation, role);
 }
 
 int ProjectItemModel::columnCount(const QModelIndex &parent) const
 {
     READ_LOCK();
     if (parent.isValid()) {
         return getBinItemByIndex(parent)->supportedDataCount();
     }
     return std::static_pointer_cast<ProjectFolder>(rootItem)->supportedDataCount();
 }
 
 // cppcheck-suppress unusedFunction
 Qt::DropActions ProjectItemModel::supportedDropActions() const
 {
     return Qt::CopyAction | Qt::MoveAction;
 }
 
 QStringList ProjectItemModel::mimeTypes() const
 {
     QStringList types;
     types << QStringLiteral("kdenlive/producerslist") << QStringLiteral("text/uri-list") << QStringLiteral("kdenlive/clip")
           << QStringLiteral("kdenlive/effect");
     return types;
 }
 
 QMimeData *ProjectItemModel::mimeData(const QModelIndexList &indices) const
 {
     READ_LOCK();
     // Mime data is a list of id's separated by ';'.
     // Clip ids are represented like:  2 (where 2 is the clip's id)
     // Clip zone ids are represented like:  2/10/200 (where 2 is the clip's id, 10 and 200 are in and out points)
     // Folder ids are represented like:  #2 (where 2 is the folder's id)
     auto *mimeData = new QMimeData();
     QStringList list;
     size_t duration = 0;
     for (int i = 0; i < indices.count(); i++) {
         QModelIndex ix = indices.at(i);
         if (!ix.isValid() || ix.column() != 0) {
             continue;
         }
         std::shared_ptr<AbstractProjectItem> item = getBinItemByIndex(ix);
         AbstractProjectItem::PROJECTITEMTYPE type = item->itemType();
         if (type == AbstractProjectItem::ClipItem) {
             ClipType::ProducerType cType = item->clipType();
             QString dragId = item->clipId();
             if ((cType == ClipType::AV || cType == ClipType::Playlist)) {
                 switch (m_dragType) {
                 case PlaylistState::AudioOnly:
                     dragId.prepend(QLatin1Char('A'));
                     break;
                 case PlaylistState::VideoOnly:
                     dragId.prepend(QLatin1Char('V'));
                     break;
                 default:
                     break;
                 }
             }
             list << dragId;
             duration += (std::static_pointer_cast<ProjectClip>(item))->frameDuration();
         } else if (type == AbstractProjectItem::SubClipItem) {
             QPoint p = item->zone();
             list << std::static_pointer_cast<ProjectSubClip>(item)->getMasterClip()->clipId() + QLatin1Char('/') + QString::number(p.x()) + QLatin1Char('/') +
                         QString::number(p.y());
         } else if (type == AbstractProjectItem::FolderItem) {
             list << "#" + item->clipId();
         }
     }
     if (!list.isEmpty()) {
         QByteArray data;
         data.append(list.join(QLatin1Char(';')).toUtf8());
         mimeData->setData(QStringLiteral("kdenlive/producerslist"), data);
         mimeData->setText(QString::number(duration));
     }
     return mimeData;
 }
 
 void ProjectItemModel::onItemUpdated(const std::shared_ptr<AbstractProjectItem> &item, int role)
 {
     QWriteLocker locker(&m_lock);
     auto tItem = std::static_pointer_cast<TreeItem>(item);
     auto ptr = tItem->parentItem().lock();
     if (ptr) {
         auto index = getIndexFromItem(tItem);
         emit dataChanged(index, index, {role});
     }
 }
 
 void ProjectItemModel::onItemUpdated(const QString &binId, int role)
 {
     QWriteLocker locker(&m_lock);
     std::shared_ptr<AbstractProjectItem> item = getItemByBinId(binId);
     if (item) {
         onItemUpdated(item, role);
     }
 }
 std::shared_ptr<ProjectClip> ProjectItemModel::getClipByBinID(const QString &binId)
 {
     READ_LOCK();
     if (binId.contains(QLatin1Char('_'))) {
         return getClipByBinID(binId.section(QLatin1Char('_'), 0, 0));
     }
     for (const auto &clip : m_allItems) {
         auto c = std::static_pointer_cast<AbstractProjectItem>(clip.second.lock());
         if (c->itemType() == AbstractProjectItem::ClipItem && c->clipId() == binId) {
             return std::static_pointer_cast<ProjectClip>(c);
         }
     }
     return nullptr;
 }
 
 const QVector<double> ProjectItemModel::getAudioLevelsByBinID(const QString &binId)
 {
     READ_LOCK();
     if (binId.contains(QLatin1Char('_'))) {
         return getAudioLevelsByBinID(binId.section(QLatin1Char('_'), 0, 0));
     }
     for (const auto &clip : m_allItems) {
         auto c = std::static_pointer_cast<AbstractProjectItem>(clip.second.lock());
         if (c->itemType() == AbstractProjectItem::ClipItem && c->clipId() == binId) {
             return std::static_pointer_cast<ProjectClip>(c)->audioFrameCache;
         }
     }
     return QVector<double>();
 }
 
 bool ProjectItemModel::hasClip(const QString &binId)
 {
     READ_LOCK();
     return getClipByBinID(binId) != nullptr;
 }
 
 std::shared_ptr<ProjectFolder> ProjectItemModel::getFolderByBinId(const QString &binId)
 {
     READ_LOCK();
     for (const auto &clip : m_allItems) {
         auto c = std::static_pointer_cast<AbstractProjectItem>(clip.second.lock());
         if (c->itemType() == AbstractProjectItem::FolderItem && c->clipId() == binId) {
             return std::static_pointer_cast<ProjectFolder>(c);
         }
     }
     return nullptr;
 }
 
 const QString ProjectItemModel::getFolderIdByName(const QString &folderName)
 {
     READ_LOCK();
     for (const auto &clip : m_allItems) {
         auto c = std::static_pointer_cast<AbstractProjectItem>(clip.second.lock());
         if (c->itemType() == AbstractProjectItem::FolderItem && c->name() == folderName) {
             return c->clipId();
         }
     }
     return QString();
 }
 
 std::shared_ptr<AbstractProjectItem> ProjectItemModel::getItemByBinId(const QString &binId)
 {
     READ_LOCK();
     for (const auto &clip : m_allItems) {
         auto c = std::static_pointer_cast<AbstractProjectItem>(clip.second.lock());
         if (c->clipId() == binId) {
             return c;
         }
     }
     return nullptr;
 }
 
 void ProjectItemModel::setBinEffectsEnabled(bool enabled)
 {
     QWriteLocker locker(&m_lock);
     return std::static_pointer_cast<AbstractProjectItem>(rootItem)->setBinEffectsEnabled(enabled);
 }
 
 QStringList ProjectItemModel::getEnclosingFolderInfo(const QModelIndex &index) const
 {
     READ_LOCK();
     QStringList noInfo;
     noInfo << QString::number(-1);
     noInfo << QString();
     if (!index.isValid()) {
         return noInfo;
     }
 
     std::shared_ptr<AbstractProjectItem> currentItem = getBinItemByIndex(index);
     auto folder = currentItem->getEnclosingFolder(true);
     if ((folder == nullptr) || folder == rootItem) {
         return noInfo;
     }
     QStringList folderInfo;
     folderInfo << currentItem->clipId();
     folderInfo << currentItem->name();
     return folderInfo;
 }
 
 void ProjectItemModel::clean()
 {
     QWriteLocker locker(&m_lock);
     std::vector<std::shared_ptr<AbstractProjectItem>> toDelete;
     toDelete.reserve((size_t)rootItem->childCount());
     for (int i = 0; i < rootItem->childCount(); ++i) {
         toDelete.push_back(std::static_pointer_cast<AbstractProjectItem>(rootItem->child(i)));
     }
     Fun undo = []() { return true; };
     Fun redo = []() { return true; };
     for (const auto &child : toDelete) {
         requestBinClipDeletion(child, undo, redo);
     }
     Q_ASSERT(rootItem->childCount() == 0);
     m_nextId = 1;
     m_fileWatcher->clear();
 }
 
 std::shared_ptr<ProjectFolder> ProjectItemModel::getRootFolder() const
 {
     READ_LOCK();
     return std::static_pointer_cast<ProjectFolder>(rootItem);
 }
 
 void ProjectItemModel::loadSubClips(const QString &id, const QString &clipData)
 {
     QWriteLocker locker(&m_lock);
     Fun undo = []() { return true; };
     Fun redo = []() { return true; };
     loadSubClips(id, clipData, undo, redo);
 }
 
 void ProjectItemModel::loadSubClips(const QString &id, const QString &dataMap, Fun &undo, Fun &redo)
 {
     if (dataMap.isEmpty()) {
         return;
     }
     QWriteLocker locker(&m_lock);
     std::shared_ptr<ProjectClip> clip = getClipByBinID(id);
     if (!clip) {
         qDebug()<<" = = = = = CLIP NOT LOADED";
         return;
     }
     auto json = QJsonDocument::fromJson(dataMap.toUtf8());
     if (!json.isArray()) {
         qDebug() << "Error loading zones : Json file should be an array";
         return;
     }
     int maxFrame = clip->duration().frames(pCore->getCurrentFps()) - 1;
     auto list = json.array();
     for (const auto &entry : list) {
         if (!entry.isObject()) {
             qDebug() << "Warning : Skipping invalid marker data";
             continue;
         }
         auto entryObj = entry.toObject();
         if (!entryObj.contains(QLatin1String("name"))) {
             qDebug() << "Warning : Skipping invalid zone(does not contain name)";
             continue;
         }
         int in = entryObj[QLatin1String("in")].toInt();
         int out = entryObj[QLatin1String("out")].toInt();
         QString name = entryObj[QLatin1String("name")].toString(i18n("Zone"));
         if (in >= out) {
             qDebug() << "Warning : Invalid zone: "<<name<<", "<<in<<"-"<<out;
             continue;
         }
         if (maxFrame > 0) {
             out = qMin(out, maxFrame);
         }
         QString subId;
         requestAddBinSubClip(subId, in, out, name, id, undo, redo);
     }
 }
 
 std::shared_ptr<AbstractProjectItem> ProjectItemModel::getBinItemByIndex(const QModelIndex &index) const
 {
     READ_LOCK();
     return std::static_pointer_cast<AbstractProjectItem>(getItemById((int)index.internalId()));
 }
 
 bool ProjectItemModel::requestBinClipDeletion(const std::shared_ptr<AbstractProjectItem> &clip, Fun &undo, Fun &redo)
 {
     QWriteLocker locker(&m_lock);
     Q_ASSERT(clip);
     if (!clip) return false;
     int parentId = -1;
     QString binId;
     if (auto ptr = clip->parent()) {
         parentId = ptr->getId();
         binId = ptr->clipId();
     }
     bool isSubClip = clip->itemType() == AbstractProjectItem::SubClipItem;
     clip->selfSoftDelete(undo, redo);
     int id = clip->getId();
     Fun operation = removeItem_lambda(id);
     Fun reverse = addItem_lambda(clip, parentId);
     bool res = operation();
     if (res) {
         if (isSubClip) {
             Fun update_doc = [this, binId]() {
                 std::shared_ptr<AbstractProjectItem> parentItem = getItemByBinId(binId);
                 if (parentItem && parentItem->itemType() == AbstractProjectItem::ClipItem) {
                     auto clipItem = std::static_pointer_cast<ProjectClip>(parentItem);
                     clipItem->updateZones();
                 }
                 return true;
             };
             update_doc();
             PUSH_LAMBDA(update_doc, operation);
             PUSH_LAMBDA(update_doc, reverse);
         }
         UPDATE_UNDO_REDO(operation, reverse, undo, redo);
     }
     return res;
 }
 
 void ProjectItemModel::registerItem(const std::shared_ptr<TreeItem> &item)
 {
     QWriteLocker locker(&m_lock);
     auto clip = std::static_pointer_cast<AbstractProjectItem>(item);
     m_binPlaylist->manageBinItemInsertion(clip);
     AbstractTreeModel::registerItem(item);
     if (clip->itemType() == AbstractProjectItem::ClipItem) {
         auto clipItem = std::static_pointer_cast<ProjectClip>(clip);
         updateWatcher(clipItem);
     }
 }
 void ProjectItemModel::deregisterItem(int id, TreeItem *item)
 {
     QWriteLocker locker(&m_lock);
     auto clip = static_cast<AbstractProjectItem *>(item);
     m_binPlaylist->manageBinItemDeletion(clip);
     // TODO : here, we should suspend jobs belonging to the item we delete. They can be restarted if the item is reinserted by undo
     AbstractTreeModel::deregisterItem(id, item);
     if (clip->itemType() == AbstractProjectItem::ClipItem) {
         auto clipItem = static_cast<ProjectClip *>(clip);
         m_fileWatcher->removeFile(clipItem->clipId());
     }
 }
 
 int ProjectItemModel::getFreeFolderId()
 {
     while (!isIdFree(QString::number(++m_nextId))) {
     };
     return m_nextId;
 }
 
 int ProjectItemModel::getFreeClipId()
 {
     while (!isIdFree(QString::number(++m_nextId))) {
     };
     return m_nextId;
 }
 
 bool ProjectItemModel::addItem(const std::shared_ptr<AbstractProjectItem> &item, const QString &parentId, Fun &undo, Fun &redo)
 {
     QWriteLocker locker(&m_lock);
     std::shared_ptr<AbstractProjectItem> parentItem = getItemByBinId(parentId);
     if (!parentItem) {
         qCDebug(KDENLIVE_LOG) << "  / / ERROR IN PARENT FOLDER";
         return false;
     }
     if (item->itemType() == AbstractProjectItem::ClipItem && parentItem->itemType() != AbstractProjectItem::FolderItem) {
         qCDebug(KDENLIVE_LOG) << "  / / ERROR when inserting clip: a clip should be inserted in a folder";
         return false;
     }
     if (item->itemType() == AbstractProjectItem::SubClipItem && parentItem->itemType() != AbstractProjectItem::ClipItem) {
         qCDebug(KDENLIVE_LOG) << "  / / ERROR when inserting subclip: a subclip should be inserted in a clip";
         return false;
     }
     Fun operation = addItem_lambda(item, parentItem->getId());
 
     int itemId = item->getId();
     Fun reverse = removeItem_lambda(itemId);
     bool res = operation();
     Q_ASSERT(item->isInModel());
     if (res) {
         UPDATE_UNDO_REDO(operation, reverse, undo, redo);
     }
     return res;
 }
 
 bool ProjectItemModel::requestAddFolder(QString &id, const QString &name, const QString &parentId, Fun &undo, Fun &redo)
 {
     QWriteLocker locker(&m_lock);
     if (!id.isEmpty() && !isIdFree(id)) {
         id = QString();
     }
     if (id.isEmpty()) {
         id = QString::number(getFreeFolderId());
     }
     std::shared_ptr<ProjectFolder> new_folder = ProjectFolder::construct(id, name, std::static_pointer_cast<ProjectItemModel>(shared_from_this()));
     return addItem(new_folder, parentId, undo, redo);
 }
 
 bool ProjectItemModel::requestAddBinClip(QString &id, const QDomElement &description, const QString &parentId, Fun &undo, Fun &redo,
                                          const std::function<void(const QString &)> &readyCallBack)
 {
     qDebug() << "/////////// requestAddBinClip" << parentId;
     QWriteLocker locker(&m_lock);
     if (id.isEmpty()) {
         id =
             Xml::getTagContentByAttribute(description, QStringLiteral("property"), QStringLiteral("name"), QStringLiteral("kdenlive:id"), QStringLiteral("-1"));
         if (id == QStringLiteral("-1") || !isIdFree(id)) {
             id = QString::number(getFreeClipId());
         }
     }
     Q_ASSERT(!id.isEmpty() && isIdFree(id));
     qDebug() << "/////////// found id" << id;
     std::shared_ptr<ProjectClip> new_clip =
         ProjectClip::construct(id, description, m_blankThumb, std::static_pointer_cast<ProjectItemModel>(shared_from_this()));
     qDebug() << "/////////// constructed ";
     bool res = addItem(new_clip, parentId, undo, redo);
     qDebug() << "/////////// added " << res;
     if (res) {
         int loadJob = pCore->jobManager()->startJob<LoadJob>({id}, -1, QString(), description, std::bind(readyCallBack, id));
         int thumbJob = pCore->jobManager()->startJob<ThumbJob>({id}, loadJob, QString(), 150, 0, true);
         ClipType::ProducerType type = new_clip->clipType();
         if (type == ClipType::AV || type == ClipType::Audio || type == ClipType::Playlist || type == ClipType::Unknown) {
             pCore->jobManager()->startJob<AudioThumbJob>({id}, loadJob, QString());
         }
         if (type == ClipType::AV || type == ClipType::Video || type == ClipType::Playlist || type == ClipType::Unknown) {
             pCore->jobManager()->startJob<CacheJob>({id}, thumbJob, QString(), 150);
         }
     }
     return res;
 }
 
 bool ProjectItemModel::requestAddBinClip(QString &id, const QDomElement &description, const QString &parentId, const QString &undoText)
 {
     QWriteLocker locker(&m_lock);
     Fun undo = []() { return true; };
     Fun redo = []() { return true; };
     bool res = requestAddBinClip(id, description, parentId, undo, redo);
     if (res) {
         pCore->pushUndo(undo, redo, undoText.isEmpty() ? i18n("Add bin clip") : undoText);
     }
     return res;
 }
 
 bool ProjectItemModel::requestAddBinClip(QString &id, const std::shared_ptr<Mlt::Producer> &producer, const QString &parentId, Fun &undo, Fun &redo)
 {
     QWriteLocker locker(&m_lock);
     if (id.isEmpty()) {
         id = QString::number(producer->get_int("kdenlive:id"));
         if (!isIdFree(id)) {
             id = QString::number(getFreeClipId());
         }
     }
     Q_ASSERT(!id.isEmpty() && isIdFree(id));
     std::shared_ptr<ProjectClip> new_clip = ProjectClip::construct(id, m_blankThumb, std::static_pointer_cast<ProjectItemModel>(shared_from_this()), producer);
     bool res = addItem(new_clip, parentId, undo, redo);
     if (res) {
         new_clip->importEffects(producer);
         if (new_clip->sourceExists()) {
             int blocking = pCore->jobManager()->getBlockingJobId(id, AbstractClipJob::LOADJOB);
             pCore->jobManager()->startJob<ThumbJob>({id}, blocking, QString(), 150, -1, true);
             pCore->jobManager()->startJob<AudioThumbJob>({id}, blocking, QString());
         }
     }
     return res;
 }
 
 bool ProjectItemModel::requestAddBinSubClip(QString &id, int in, int out, const QString &zoneName, const QString &parentId, Fun &undo, Fun &redo)
 {
     QWriteLocker locker(&m_lock);
     if (id.isEmpty()) {
         id = QString::number(getFreeClipId());
     }
     Q_ASSERT(!id.isEmpty() && isIdFree(id));
     QString subId = parentId;
     if (subId.startsWith(QLatin1Char('A')) || subId.startsWith(QLatin1Char('V'))) {
         subId.remove(0, 1);
     }
     auto clip = getClipByBinID(subId);
     Q_ASSERT(clip->itemType() == AbstractProjectItem::ClipItem);
     auto tc = pCore->currentDoc()->timecode().getDisplayTimecodeFromFrames(in, KdenliveSettings::frametimecode());
     std::shared_ptr<ProjectSubClip> new_clip =
         ProjectSubClip::construct(id, clip, std::static_pointer_cast<ProjectItemModel>(shared_from_this()), in, out, tc, zoneName);
     bool res = addItem(new_clip, subId, undo, redo);
     if (res) {
         int parentJob = pCore->jobManager()->getBlockingJobId(subId, AbstractClipJob::LOADJOB);
         pCore->jobManager()->startJob<ThumbJob>({id}, parentJob, QString(), 150, -1, true);
     }
     return res;
 }
 bool ProjectItemModel::requestAddBinSubClip(QString &id, int in, int out, const QString &zoneName, const QString &parentId)
 {
     QWriteLocker locker(&m_lock);
     Fun undo = []() { return true; };
     Fun redo = []() { return true; };
     bool res = requestAddBinSubClip(id, in, out, zoneName, parentId, undo, redo);
     if (res) {
         Fun update_doc = [this, parentId]() {
             std::shared_ptr<AbstractProjectItem> parentItem = getItemByBinId(parentId);
             if (parentItem && parentItem->itemType() == AbstractProjectItem::ClipItem) {
                 auto clipItem = std::static_pointer_cast<ProjectClip>(parentItem);
                 clipItem->updateZones();
             }
             return true;
         };
         update_doc();
         PUSH_LAMBDA(update_doc, undo);
         PUSH_LAMBDA(update_doc, redo);
         pCore->pushUndo(undo, redo, i18n("Add a sub clip"));
     }
     return res;
 }
 
 Fun ProjectItemModel::requestRenameFolder_lambda(const std::shared_ptr<AbstractProjectItem> &folder, const QString &newName)
 {
     int id = folder->getId();
     return [this, id, newName]() {
         auto currentFolder = std::static_pointer_cast<AbstractProjectItem>(m_allItems[id].lock());
         if (!currentFolder) {
             return false;
         }
         currentFolder->setName(newName);
         m_binPlaylist->manageBinFolderRename(currentFolder);
         auto index = getIndexFromItem(currentFolder);
         emit dataChanged(index, index, {AbstractProjectItem::DataName});
         return true;
     };
 }
 
 bool ProjectItemModel::requestRenameFolder(const std::shared_ptr<AbstractProjectItem> &folder, const QString &name, Fun &undo, Fun &redo)
 {
     QWriteLocker locker(&m_lock);
     QString oldName = folder->name();
     auto operation = requestRenameFolder_lambda(folder, name);
     if (operation()) {
         auto reverse = requestRenameFolder_lambda(folder, oldName);
         UPDATE_UNDO_REDO(operation, reverse, undo, redo);
         return true;
     }
     return false;
 }
 
 bool ProjectItemModel::requestRenameFolder(std::shared_ptr<AbstractProjectItem> folder, const QString &name)
 {
     QWriteLocker locker(&m_lock);
     Fun undo = []() { return true; };
     Fun redo = []() { return true; };
     bool res = requestRenameFolder(std::move(folder), name, undo, redo);
     if (res) {
         pCore->pushUndo(undo, redo, i18n("Rename Folder"));
     }
     return res;
 }
 
 bool ProjectItemModel::requestCleanup()
 {
     QWriteLocker locker(&m_lock);
     Fun undo = []() { return true; };
     Fun redo = []() { return true; };
     bool res = true;
     std::vector<std::shared_ptr<AbstractProjectItem>> to_delete;
     // Iterate to find clips that are not in timeline
     for (const auto &clip : m_allItems) {
         auto c = std::static_pointer_cast<AbstractProjectItem>(clip.second.lock());
         if (c->itemType() == AbstractProjectItem::ClipItem && !c->isIncludedInTimeline()) {
             to_delete.push_back(c);
         }
     }
     // it is important to execute deletion in a separate loop, because otherwise
     // the iterators of m_allItems get messed up
     for (const auto &c : to_delete) {
         res = requestBinClipDeletion(c, undo, redo);
         if (!res) {
             bool undone = undo();
             Q_ASSERT(undone);
             return false;
         }
     }
     pCore->pushUndo(undo, redo, i18n("Clean Project"));
     return true;
 }
 
 std::vector<QString> ProjectItemModel::getAllClipIds() const
 {
     READ_LOCK();
     std::vector<QString> result;
     for (const auto &clip : m_allItems) {
         auto c = std::static_pointer_cast<AbstractProjectItem>(clip.second.lock());
         if (c->itemType() == AbstractProjectItem::ClipItem) {
             result.push_back(c->clipId());
         }
     }
     return result;
 }
 
 QStringList ProjectItemModel::getClipByUrl(const QFileInfo &url) const
 {
     READ_LOCK();
     QStringList result;
     for (const auto &clip : m_allItems) {
         auto c = std::static_pointer_cast<AbstractProjectItem>(clip.second.lock());
         if (c->itemType() == AbstractProjectItem::ClipItem) {
             if (QFileInfo(std::static_pointer_cast<ProjectClip>(c)->clipUrl()) == url) {
                 result << c->clipId();
             }
         }
     }
     return result;
 }
 
 bool ProjectItemModel::loadFolders(Mlt::Properties &folders)
 {
     QWriteLocker locker(&m_lock);
     // At this point, we expect the folders properties to have a name of the form "x.y" where x is the id of the parent folder and y the id of the child.
     // Note that for root folder, x = -1
     // The value of the property is the name of the child folder
 
     std::unordered_map<int, std::vector<int>> downLinks; // key are parents, value are children
     std::unordered_map<int, int> upLinks;                // key are children, value are parent
     std::unordered_map<int, QString> newIds;             // we store the correspondence to the new ids
     std::unordered_map<int, QString> folderNames;
     newIds[-1] = getRootFolder()->clipId();
 
     if (folders.count() == 0) return true;
 
     for (int i = 0; i < folders.count(); i++) {
         QString folderName = folders.get(i);
         QString id = folders.get_name(i);
 
         int parentId = id.section(QLatin1Char('.'), 0, 0).toInt();
         int folderId = id.section(QLatin1Char('.'), 1, 1).toInt();
         downLinks[parentId].push_back(folderId);
         upLinks[folderId] = parentId;
         folderNames[folderId] = folderName;
         qDebug() << "Found folder " << folderId << "name = " << folderName << "parent=" << parentId;
     }
 
     // In case there are some non-existent parent, we fall back to root
     for (const auto &f : downLinks) {
         if (upLinks.count(f.first) == 0) {
             upLinks[f.first] = -1;
         }
         if (f.first != -1 && downLinks.count(upLinks[f.first]) == 0) {
             qDebug() << "Warning: parent folder " << upLinks[f.first] << "for folder" << f.first << "is invalid. Folder will be placed in topmost directory.";
             upLinks[f.first] = -1;
         }
     }
 
     // We now do a BFS to construct the folders in order
     Q_ASSERT(downLinks.count(-1) > 0);
     Fun undo = []() { return true; };
     Fun redo = []() { return true; };
     std::queue<int> queue;
     std::unordered_set<int> seen;
     queue.push(-1);
     while (!queue.empty()) {
         int current = queue.front();
         seen.insert(current);
         queue.pop();
         if (current != -1) {
             QString id = QString::number(current);
             bool res = requestAddFolder(id, folderNames[current], newIds[upLinks[current]], undo, redo);
             if (!res) {
                 bool undone = undo();
                 Q_ASSERT(undone);
                 return false;
             }
             newIds[current] = id;
         }
         for (int c : downLinks[current]) {
             queue.push(c);
         }
     }
     return true;
 }
 
 bool ProjectItemModel::isIdFree(const QString &id) const
 {
     READ_LOCK();
     for (const auto &clip : m_allItems) {
         auto c = std::static_pointer_cast<AbstractProjectItem>(clip.second.lock());
         if (c->clipId() == id) {
             return false;
         }
     }
     return true;
 }
 
 void ProjectItemModel::loadBinPlaylist(Mlt::Tractor *documentTractor, Mlt::Tractor *modelTractor, std::unordered_map<QString, QString> &binIdCorresp, QProgressDialog *progressDialog)
 {
     QWriteLocker locker(&m_lock);
     clean();
     Mlt::Properties retainList((mlt_properties)documentTractor->get_data("xml_retain"));
     qDebug() << "Loading bin playlist...";
     if (retainList.is_valid()) {
         qDebug() << "retain is valid";
         Mlt::Playlist playlist((mlt_playlist)retainList.get_data(BinPlaylist::binPlaylistId.toUtf8().constData()));
         if (playlist.is_valid() && playlist.type() == playlist_type) {
             qDebug() << "playlist is valid";
 
             // Load bin clips
             qDebug() << "init bin";
             // Load folders
             Mlt::Properties folderProperties;
             Mlt::Properties playlistProps(playlist.get_properties());
             folderProperties.pass_values(playlistProps, "kdenlive:folder.");
             loadFolders(folderProperties);
 
             // Read notes
             QString notes = playlistProps.get("kdenlive:documentnotes");
             pCore->projectManager()->setDocumentNotes(notes);
 
             Fun undo = []() { return true; };
             Fun redo = []() { return true; };
             qDebug() << "Found " << playlist.count() << "clips";
             int max = playlist.count();
             if (progressDialog) {
                 progressDialog->setMaximum(progressDialog->maximum() + max);
             }
             for (int i = 0; i < max; i++) {
                 if (progressDialog) {
                     progressDialog->setValue(i);
                 }
                 QScopedPointer<Mlt::Producer> prod(playlist.get_clip(i));
                 std::shared_ptr<Mlt::Producer> producer(new Mlt::Producer(prod->parent()));
                 qDebug() << "dealing with bin clip" << i;
                 if (producer->is_blank() || !producer->is_valid()) {
                     qDebug() << "producer is not valid or blank";
                     continue;
                 }
                 QString id = qstrdup(producer->get("kdenlive:id"));
                 QString parentId = qstrdup(producer->get("kdenlive:folderid"));
                 if (parentId.isEmpty()) {
                     parentId = QStringLiteral("-1");
                 }
                 qDebug() << "clip id" << id;
                 QString newId = isIdFree(id) ? id : QString::number(getFreeClipId());
                 producer->set("_kdenlive_processed", 1);
                 requestAddBinClip(newId, producer, parentId, undo, redo);
                 binIdCorresp[id] = newId;
                 qDebug() << "Loaded clip " << id << "under id" << newId;
             }
         }
     }
     m_binPlaylist->setRetainIn(modelTractor);
 }
 
 /** @brief Save document properties in MLT's bin playlist */
 void ProjectItemModel::saveDocumentProperties(const QMap<QString, QString> &props, const QMap<QString, QString> &metadata,
                                               std::shared_ptr<MarkerListModel> guideModel)
 {
     m_binPlaylist->saveDocumentProperties(props, metadata, std::move(guideModel));
 }
 
 void ProjectItemModel::saveProperty(const QString &name, const QString &value)
 {
     m_binPlaylist->saveProperty(name, value);
 }
 
 QMap<QString, QString> ProjectItemModel::getProxies(const QString &root)
 {
     READ_LOCK();
     return m_binPlaylist->getProxies(root);
 }
 
 void ProjectItemModel::reloadClip(const QString &binId)
 {
     QWriteLocker locker(&m_lock);
     std::shared_ptr<ProjectClip> clip = getClipByBinID(binId);
     if (clip) {
         clip->reloadProducer();
     }
 }
 
 void ProjectItemModel::setClipWaiting(const QString &binId)
 {
     QWriteLocker locker(&m_lock);
     std::shared_ptr<ProjectClip> clip = getClipByBinID(binId);
     if (clip) {
         clip->setClipStatus(AbstractProjectItem::StatusWaiting);
     }
 }
 
 void ProjectItemModel::setClipInvalid(const QString &binId)
 {
     QWriteLocker locker(&m_lock);
     std::shared_ptr<ProjectClip> clip = getClipByBinID(binId);
     if (clip) {
         clip->setClipStatus(AbstractProjectItem::StatusMissing);
         // TODO: set producer as blank invalid
     }
 }
 
 void ProjectItemModel::updateWatcher(const std::shared_ptr<ProjectClip> &clipItem)
 {
     QWriteLocker locker(&m_lock);
     if (clipItem->clipType() == ClipType::AV || clipItem->clipType() == ClipType::Audio || clipItem->clipType() == ClipType::Image ||
         clipItem->clipType() == ClipType::Video || clipItem->clipType() == ClipType::Playlist || clipItem->clipType() == ClipType::TextTemplate) {
         m_fileWatcher->removeFile(clipItem->clipId());
         m_fileWatcher->addFile(clipItem->clipId(), clipItem->clipUrl());
     }
 }
 
 void ProjectItemModel::setDragType(PlaylistState::ClipState type)
 {
     QWriteLocker locker(&m_lock);
     m_dragType = type;
 }
 
 int ProjectItemModel::clipsCount() const
 {
     READ_LOCK();
     return m_binPlaylist->count();
 }
diff --git a/src/bin/projectsortproxymodel.cpp b/src/bin/projectsortproxymodel.cpp
index 686bcbe84..c6d1fdeee 100644
--- a/src/bin/projectsortproxymodel.cpp
+++ b/src/bin/projectsortproxymodel.cpp
@@ -1,147 +1,147 @@
 /*
 Copyright (C) 2014  Jean-Baptiste Mardelle <jb@kdenlive.org>
 This file is part of Kdenlive. See www.kdenlive.org.
 
 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) version 3 or any later version
 accepted by the membership of KDE e.V. (or its successor approved
 by the membership of KDE e.V.), which shall act as a proxy
 defined in Section 14 of version 3 of the license.
 
 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, see <http://www.gnu.org/licenses/>.
 */
 
 #include "projectsortproxymodel.h"
 #include "abstractprojectitem.h"
 
 #include <QItemSelectionModel>
 
 ProjectSortProxyModel::ProjectSortProxyModel(QObject *parent)
     : QSortFilterProxyModel(parent)
 {
     m_collator.setNumericMode(true);
+    m_collator.setCaseSensitivity(Qt::CaseInsensitive);
     m_selection = new QItemSelectionModel(this);
     connect(m_selection, &QItemSelectionModel::selectionChanged, this, &ProjectSortProxyModel::onCurrentRowChanged);
     setDynamicSortFilter(true);
 }
 
 // Responsible for item sorting!
 bool ProjectSortProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
 {
     if (filterAcceptsRowItself(sourceRow, sourceParent)) {
         return true;
     }
     // accept if any of the children is accepted on it's own merits
     return hasAcceptedChildren(sourceRow, sourceParent);
 }
 
 bool ProjectSortProxyModel::filterAcceptsRowItself(int sourceRow, const QModelIndex &sourceParent) const
 {
     int cols = sourceModel()->columnCount();
     for (int i = 0; i < cols; i++) {
         QModelIndex index0 = sourceModel()->index(sourceRow, i, sourceParent);
         if (!index0.isValid()) {
             return false;
         }
         auto model = sourceModel();
         auto data = model->data(index0);
         if (data.toString().contains(m_searchString, Qt::CaseInsensitive)) {
             return true;
         }
     }
     return false;
 }
 
 bool ProjectSortProxyModel::hasAcceptedChildren(int sourceRow, const QModelIndex &source_parent) const
 {
     QModelIndex item = sourceModel()->index(sourceRow, 0, source_parent);
     if (!item.isValid()) {
         return false;
     }
 
     // check if there are children
     int childCount = item.model()->rowCount(item);
     if (childCount == 0) {
         return false;
     }
 
     for (int i = 0; i < childCount; ++i) {
         if (filterAcceptsRowItself(i, item)) {
             return true;
         }
         // recursive call -> NOTICE that this is depth-first searching, you're probably better off with breadth first search...
         if (hasAcceptedChildren(i, item)) {
             return true;
         }
     }
     return false;
 }
 
 bool ProjectSortProxyModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
 {
     // Check item type (folder or clip) as defined in projectitemmodel
     int leftType = sourceModel()->data(left, AbstractProjectItem::ItemTypeRole).toInt();
     int rightType = sourceModel()->data(right, AbstractProjectItem::ItemTypeRole).toInt();
     if (leftType == rightType) {
-        // Let the normal alphabetical sort happen
         // Let the normal alphabetical sort happen
         QVariant leftData;
         QVariant rightData;
         if (leftType == AbstractProjectItem::SubClipItem) {
             // Subclips, sort by start position
             leftData = sourceModel()->data(left, AbstractProjectItem::DataInPoint);
             rightData = sourceModel()->data(right, AbstractProjectItem::DataInPoint);
         } else {
             leftData = sourceModel()->data(left, Qt::DisplayRole);
             rightData = sourceModel()->data(right, Qt::DisplayRole);
         }
         if (leftData.type() == QVariant::DateTime) {
             return leftData.toDateTime() < rightData.toDateTime();
         }
         return m_collator.compare(leftData.toString(), rightData.toString()) < 0;
     }
     if (sortOrder() == Qt::AscendingOrder) {
         return leftType < rightType;
     }
     return leftType > rightType;
 }
 
 QItemSelectionModel *ProjectSortProxyModel::selectionModel()
 {
     return m_selection;
 }
 
 void ProjectSortProxyModel::slotSetSearchString(const QString &str)
 {
     m_searchString = str;
     invalidateFilter();
 }
 
 void ProjectSortProxyModel::onCurrentRowChanged(const QItemSelection &current, const QItemSelection &previous)
 {
     Q_UNUSED(previous)
     QModelIndexList indexes = current.indexes();
     if (indexes.isEmpty()) {
         emit selectModel(QModelIndex());
         return;
     }
     for (int ix = 0; ix < indexes.count(); ix++) {
         if (indexes.at(ix).column() == 0) {
             emit selectModel(indexes.at(ix));
             break;
         }
     }
 }
 
 void ProjectSortProxyModel::slotDataChanged(const QModelIndex &ix1, const QModelIndex &ix2, const QVector<int> &roles)
 {
     emit dataChanged(ix1, ix2, roles);
 }
diff --git a/src/kdenlivesettings.kcfg b/src/kdenlivesettings.kcfg
index deb62f1cf..e65bdff06 100644
--- a/src/kdenlivesettings.kcfg
+++ b/src/kdenlivesettings.kcfg
@@ -1,1024 +1,1028 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
       http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
   <kcfgfile/>
   <group name="bin">
     <entry name="treeviewheaders" type="String">
       <label>Bin treeview headers state.</label>
       <default></default>
     </entry>
+    <entry name="binSorting" type="Int">
+      <label>Bin sorting column.</label>
+      <default>0</default>
+    </entry>
     <entry name="binMode" type="Int">
       <label>Bin view mode.</label>
       <default>0</default>
     </entry>
     <entry name="bin_zoom" type="Int">
       <label>Bin default zoom.</label>
       <default>4</default>
     </entry>
     <entry name="addedExtensions" type="String">
       <label>User added clip file extensions.</label>
       <default></default>
     </entry>
   </group>
 
   <group name="misc">
     <entry name="openlastproject" type="Bool">
       <label>Open last project on startup.</label>
       <default>false</default>
     </entry>
     <entry name="crashrecovery" type="Bool">
       <label>Enable autosave.</label>
       <default>true</default>
     </entry>
     <entry name="tabposition" type="Int">
       <label>Select tab position in dockwidgets.</label>
       <default>1</default>
     </entry>
     <entry name="checkfirstprojectclip" type="Bool">
       <label>Check if document profile is same as first imported clip.</label>
       <default>true</default>
     </entry>
     <entry name="exportframe_usingsourceres" type="Bool">
       <label>Export image using source resolution.</label>
       <default>true</default>
     </entry>
     <entry name="usekuiserver" type="Bool">
       <label>Use KDE central job management to track render jobs.</label>
       <default>false</default>
     </entry>
 
     <entry name="color_duration" type="String">
       <label>Default color clip duration.</label>
       <default>00:00:05:00</default>
     </entry>
 
     <entry name="image_duration" type="String">
       <label>Default image clip duration.</label>
       <default>00:00:05:00</default>
     </entry>
 
     <entry name="sequence_duration" type="String">
       <label>Default image sequence frame duration.</label>
       <default>00:00:00:01</default>
     </entry>
 
     <entry name="fade_duration" type="String">
       <label>Default image sequence frame duration.</label>
       <default>00:00:03:00</default>
     </entry>
 
     <entry name="autoimagesequence" type="Bool">
       <label>Automatically import image sequences.</label>
       <default>false</default>
     </entry>
 
     <entry name="automultistreams" type="Bool">
       <label>Automatically import all streams in multi streams clips.</label>
       <default>false</default>
     </entry>
 
     <entry name="bypasscodeccheck" type="Bool">
       <label>Ignore libav / ffmpeg codec checking.</label>
       <default>false</default>
     </entry>
 
     <entry name="use_exiftool" type="Bool">
       <label>Get h264 metadata using exiftool.</label>
       <default>false</default>
     </entry>
 
     <entry name="use_magicLantern" type="Bool">
       <label>Get h264 metadata using exiftool.</label>
       <default>false</default>
     </entry>
 
     <entry name="title_duration" type="String">
       <label>Default title clip duration.</label>
       <default>00:00:05:00</default>
     </entry>
 
     <entry name="transition_duration" type="String">
       <label>Default transition duration.</label>
       <default>00:00:01:00</default>
     </entry>
 
     <entry name="disable_effect_parameters" type="Bool">
       <label>Disable parameters when the effect is disabled.</label>
       <default>true</default>
     </entry>
 
     <entry name="profile_fps_filter" type="String">
       <label>Default fps filter for project profile.</label>
       <default></default>
     </entry>
 
     <entry name="profile_scanning_filter" type="String">
       <label>Default scanning filter for project profile.</label>
       <default></default>
     </entry>
 
     <entry name="opengl_backend" type="Int">
       <label>Default OpenGL backend (Qt::AAUseOpenGLES).</label>
       <default>16</default>
     </entry>
   </group>
 
   <group name="project">
     <entry name="videotracks" type="Int">
       <label>Default number of video tracks.</label>
       <default>2</default>
     </entry>
 
     <entry name="audiotracks" type="Int">
       <label>Default number of audio tracks.</label>
       <default>2</default>
     </entry>
 
     <entry name="enableproxy" type="Bool">
       <label>Enable proxy clips.</label>
       <default>false</default>
     </entry>
 
     <entry name="externalproxy" type="Bool">
       <label>Enable proxy clips.</label>
       <default>false</default>
     </entry>
 
     <entry name="generateproxy" type="Bool">
       <label>Auto generate proxy for new clips.</label>
       <default>false</default>
     </entry>
 
     <entry name="external_proxy_profile" type="Int">
       <label>index for the external proxy clips combo.</label>
       <default></default>
     </entry>
 
     <entry name="externalProxyProfile" type="String">
       <label>Pattern to find external proxy clips.</label>
       <default></default>
     </entry>
 
     <entry name="generateimageproxy" type="Bool">
       <label>Auto generate proxy for new image clips.</label>
       <default>false</default>
     </entry>
 
     <entry name="proxyminsize" type="Int">
       <label>Minimum source size for proxy creation.</label>
       <default>1000</default>
     </entry>
 
     <entry name="proxyimageminsize" type="Int">
       <label>Minimum source size for proxy creation.</label>
       <default>2000</default>
     </entry>
     <entry name="proxyimagesize" type="Int">
       <label>Rescale size for image proxy creation.</label>
       <default>800</default>
     </entry>
     <entry name="proxyextension" type="String">
       <label>File extension for proxy clips.</label>
       <default></default>
     </entry>
 
     <entry name="proxy_profile" type="Int">
       <label>default proxy encoding profile.</label>
       <default>0</default>
     </entry>
 
     <entry name="proxyparams" type="String">
       <label>Proxy clips transcoding parameters.</label>
       <default></default>
     </entry>
 
     <entry name="previewextension" type="String">
       <label>File extension for timeline preview.</label>
       <default></default>
     </entry>
 
     <entry name="preview_profile" type="Int">
       <label>default preview encoding profile.</label>
       <default>0</default>
     </entry>
 
     <entry name="previewparams" type="String">
       <label>Timeline preview encoding parameters.</label>
       <default></default>
     </entry>
 
     <entry name="parallelrender" type="Bool">
       <label>Enable parallel processing for rendering.</label>
       <default>true</default>
     </entry>
 
     <entry name="vaapiEnabled" type="Bool">
       <label>Enables vaapi hw accel in encoders.</label>
       <default>false</default>
     </entry>
     <entry name="nvencEnabled" type="Bool">
       <label>Enables nvenc hw accel in encoders.</label>
       <default>false</default>
     </entry>
     <entry name="nvScalingEnabled" type="Bool">
       <label>Enables nvenc hw accel scaling.</label>
       <default>false</default>
     </entry>
     </group>
 
   <group name="timeline">
     <entry name="headerwidth" type="Int">
       <label>Default width for timeline track headers.</label>
       <default>140</default>
     </entry>
     <entry name="defaultkeyframeinterp" type="Int">
       <label>Default interpolation for keyframes.</label>
       <default>1</default>
     </entry>
     <entry name="timelinechunks" type="Int">
       <label>Default size of video chunks for timeline preview.</label>
       <default>25</default>
     </entry>
     <entry name="autopreview" type="Bool">
       <label>Automatically regenerate dirty zones of timeline preview.</label>
       <default>false</default>
     </entry>
 
     <entry name="videothumbnails" type="Bool">
       <label>Display video thumbnails in timeline.</label>
       <default>true</default>
     </entry>
 
     <entry name="audiothumbnails" type="Bool">
       <label>Display audio thumbnails in timeline.</label>
       <default>true</default>
     </entry>
 
     <entry name="ffmpegaudiothumbnails" type="Bool">
       <label>Use FFmpeg to create audio thumbnails (10x faster than MLT).</label>
       <default>true</default>
     </entry>
 
     <entry name="showmarkers" type="Bool">
       <label>Display clip markers comments in timeline.</label>
       <default>false</default>
     </entry>
 
     <entry name="displayallchannels" type="Bool">
       <label>Display all channels in audio thumbnails.</label>
       <default>false</default>
     </entry>
 
     <entry name="autoscroll" type="Bool">
       <label>Auto scroll timeline while playing.</label>
       <default>true</default>
     </entry>
 
     <entry name="verticalzoom" type="Bool">
       <label>Vertical drag in timeline ruler zooms.</label>
       <default>false</default>
     </entry>
 
     <entry name="trackheight" type="Int">
       <label>Tracks height in pixel.</label>
       <default>0</default>
     </entry>
 
     <entry name="audiotracksbelow" type="Int">
         <label>Display audio tracks grouped below video tracks.</label>
         <default>1</default>
     </entry>
 
     <entry name="raisepropsclips" type="Bool">
       <label>Raise property pane when selecting timeline clips.</label>
       <default>true</default>
     </entry>
 
     <entry name="raisepropstransitions" type="Bool">
       <label>Raise property pane when selecting timeline transitions.</label>
       <default>true</default>
     </entry>
 
     <entry name="raisepropstracks" type="Bool">
       <label>Raise property pane when selecting timeline tracks.</label>
       <default>true</default>
     </entry>
 
     </group>
 
     <group name="sdl">
     <entry name="gpu_accel" type="Bool">
       <label>Use Movit for GPU accelerated display and effects.</label>
       <default>false</default>
     </entry>
     <entry name="sdlAudioBackend" type="String">
       <label>Detected audio backed.</label>
       <default>sdl2_audio</default>
     </entry>
     <entry name="audio_backend" type="Int">
       <label>Audio backend index used for sound output.</label>
       <default>0</default>
     </entry>
 
     <entry name="audiobackend" type="String">
       <label>Audio backend used for sound output.</label>
       <default>sdl2_audio</default>
     </entry>
 
     <entry name="audio_driver" type="UInt">
       <label>SDL Audio driver used for sound output.</label>
       <default>0</default>
     </entry>
 
     <entry name="audiodevicename" type="String">
       <label>SDL Audio device used for sound output.</label>
       <default></default>
     </entry>
 
     <entry name="audiodrivername" type="String">
       <label>Audio driver used for sound output.</label>
       <default></default>
     </entry>
 
     <entry name="videodrivername" type="String">
       <label>Video driver used for output.</label>
       <default></default>
     </entry>
 
     <entry name="audio_device" type="Int">
       <label>Audio device for SDL output.</label>
       <default></default>
     </entry>
 
     <entry name="window_background" type="Color">
       <label>Background color for OpenGL monitor.</label>
       <default>#535353</default>
     </entry>
 
     <entry name="volume" type="Int">
       <label>Volume used for SDL output.</label>
       <default>100</default>
     </entry>
 
     <entry name="monitor_dropframes" type="Bool">
       <label>Allow framedropping in monitor playback.</label>
       <default>true</default>
     </entry>
 
     <entry name="monitor_gamma" type="Int">
       <label>Monitor gamma (rbg / rec 709).</label>
       <default>1</default>
     </entry>
 
     <entry name="external_display" type="Bool">
       <label>Use Blackmagic device for video out.</label>
       <default>false</default>
     </entry>
     <entry name="blackmagic_output_device" type="Int">
       <label>Blackmagic video output device.</label>
       <default>0</default>
     </entry>
 </group>
 
   <group name="env">
     <entry name="mltpath" type="Path">
       <label>Mlt framework install path.</label>
       <default></default>
     </entry>
 
     <entry name="rendererpath" type="Path">
       <label>Mlt melt renderer install path.</label>
       <default></default>
     </entry>
 
     <entry name="ffmpegpath" type="Path">
       <label>FFmpeg / Libav binary path.</label>
       <default></default>
     </entry>
 
     <entry name="ffplaypath" type="Path">
       <label>FFplay / avplay binary path.</label>
       <default></default>
     </entry>
 
     <entry name="ffprobepath" type="Path">
       <label>FFprobe / avprobe binary path.</label>
       <default></default>
     </entry>
 
     <entry name="mltthreads" type="Int">
       <label>Mlt processing thread count.</label>
       <default>1</default>
     </entry>
 
     <entry name="proxythreads" type="Int">
       <label>Proxy creation processing thread count.</label>
       <default>2</default>
     </entry>
 
     <entry name="encodethreads" type="Int">
       <label>FFmpeg encoding thread count.</label>
       <default>0</default>
     </entry>
 
     <entry name="currenttmpfolder" type="Path">
       <label>Default folder for tmp files.</label>
       <default>/tmp/</default>
     </entry>
 
     <entry name="defaultprojectfolder" type="Path">
       <label>Default folder for project files.</label>
       <default></default>
     </entry>
 
     <entry name="customprojectfolder" type="Bool">
       <label>Don't use default XDG folders to store project files.</label>
       <default>false</default>
     </entry>
 
     <entry name="capturetoprojectfolder" type="Bool">
       <label>Save captured files to project folder by default.</label>
       <default>true</default>
     </entry>
 
     <entry name="capturefolder" type="Path">
       <label>Default folder for captured files.</label>
       <default>$HOME</default>
     </entry>
 
     <entry name="librarytodefaultfolder" type="Bool">
       <label>Open Library in default system folder.</label>
       <default>true</default>
     </entry>
 
     <entry name="libraryfolder" type="Path">
       <label>Default folder for library.</label>
       <default></default>
     </entry>
 
     <entry name="defaultimageapp" type="String">
       <label>Default image editing application.</label>
       <default></default>
     </entry>
 
     <entry name="defaultaudioapp" type="String">
       <label>Default audio editing application.</label>
       <default></default>
     </entry>
 
   </group>
 
 
   <group name="capture">
     <entry name="defaultaudiocapture" type="String">
       <label>Default audio capture system.</label>
       <default>default:</default>
     </entry>
 
     <entry name="audiocapturevolume" type="Int">
       <label>Audio capture volume</label>
       <default>100</default>
     </entry>
 
     <entry name="audiocapturechannels" type="Int">
       <label>Audio capture channels</label>
       <default>2</default>
     </entry>
 
     <entry name="audiocapturesamplerate" type="Int">
       <label>Audio capture sample rate</label>
       <default>48000</default>
     </entry>
 
     <entry name="defaultcapture" type="Int">
       <label>Default video capture system.</label>
       <default>0</default>
     </entry>
 
     <entry name="detectedv4ldevices" type="UInt">
       <label>Detected v4l devices.</label>
       <default>0</default>
     </entry>
 
     <entry name="video4vdevice" type="String">
       <label>Default video4linux capture format.</label>
       <default>/dev/video0</default>
     </entry>
 
     <entry name="v4l_alsadevice" type="Int">
       <label>Audio device for v4l capture.</label>
       <default></default>
     </entry>
     
     <entry name="alsachannels" type="UInt">
       <label>Number of audio channels.</label>
       <default>2</default>
     </entry>
 
     <entry name="v4l_alsadevicename" type="String">
       <label>Audio device for v4l capture.</label>
       <default>default</default>
     </entry>
 
     <entry name="v4l_parameters" type="String">
       <label>Default video4linux format.</label>
       <default></default>
     </entry>
 
     <entry name="v4l_extension" type="String">
       <label>Default video4linux file extension.</label>
       <default></default>
     </entry>
 
     <entry name="v4l_format" type="UInt">
       <label>Selected capture format.</label>
       <default>0</default>
     </entry>
 
     <entry name="v4l_capturevideo" type="Bool">
       <label>Should we capture video.</label>
       <default>true</default>
     </entry>
     
     <entry name="v4l_captureaudio" type="Bool">
       <label>Should we also capture audio.</label>
       <default>false</default>
     </entry>
     
     <entry name="v4l_profile" type="Int">
       <label>default v4l encoding profile.</label>
       <default>0</default>
     </entry>
     
     <entry name="grab_profile" type="Int">
       <label>default screen grab encoding profile.</label>
       <default>0</default>
     </entry>
     
     <entry name="grab_parameters" type="String">
       <label>Default video4linux format.</label>
       <default></default>
     </entry>
     
     <entry name="grab_extension" type="String">
       <label>Default screen grab file extension.</label>
       <default></default>
     </entry>
 
     <entry name="grab_capture_type" type="Int">
       <label>capture type.</label>
       <default>0</default>
     </entry>
 
     <entry name="grab_follow_mouse" type="Bool">
       <label>follow mouse in region capture.</label>
       <default>false</default>
     </entry>
 
     <entry name="grab_offsetx" type="Int">
       <label>x offset for video capture.</label>
       <default>0</default>
     </entry>
 
     <entry name="grab_offsety" type="Int">
       <label>y offset for video capture.</label>
       <default>0</default>
     </entry>
 
     <entry name="grab_width" type="Int">
       <label>default width for video capture.</label>
       <default>1280</default>
     </entry>
 
     <entry name="grab_height" type="Int">
       <label>default height for video capture.</label>
       <default>720</default>
     </entry>
 
     <entry name="grab_fps" type="Double">
       <label>fps for video rec.</label>
       <default>15.0</default>
     </entry>
 
     <entry name="grab_hide_frame" type="Bool">
       <label>Hide frame around capture zone.</label>
       <default>true</default>
     </entry>
 
     <entry name="grab_hide_mouse" type="Bool">
       <label>Hide mouse cursor.</label>
       <default>false</default>
     </entry>
 
     <entry name="decklink_device_found" type="Bool">
       <label>Enable Blackmagic decklink support.</label>
       <default>false</default>
     </entry>
 
     <entry name="decklink_capturedevice" type="UInt">
       <label>default HDMI capture device.</label>
       <default>0</default>
     </entry>
 
     <entry name="decklink_profile" type="Int">
       <label>default HDMI encoding profile.</label>
       <default>0</default>
     </entry>
 
     <entry name="decklink_filename" type="String">
       <label>default HDMI capture filename.</label>
       <default>capture</default>
     </entry>
   
   <entry name="decklink_parameters" type="String">
       <label>Default Decklink encoding parameters.</label>
       <default></default>
   </entry>
 
   <entry name="decklink_extension" type="String">
       <label>Default Decklink capture file extension.</label>
       <default></default>
   </entry>
   </group>
 
   <group name="shuttle">
     <entry name="enableshuttle" type="Bool">
       <label>Enable jog shuttle device.</label>
       <default>false</default>
     </entry>
 
     <entry name="shuttledevice" type="String">
       <label>Path to shuttle device.</label>
       <default></default>
     </entry>
 
     <entry name="shuttledevicenames" type="StringList">
       <label>Available shuttle device names.</label>
       <default></default>
     </entry>
     
     <entry name="shuttledevicepaths" type="StringList">
       <label>Available shuttle device paths.</label>
       <default></default>
     </entry>
 
     <entry name="shuttlebuttons" type="String">
       <label>JogShuttle button to actions mappings.</label>
       <default></default>
     </entry>
   </group>
   
   <group name="bezier_spline">
     <entry name="bezier_gridlines" type="Int">
       <label>Number of lines to use for the grid.</label>
       <default>3</default>
     </entry>
 
     <entry name="bezier_showpixmap" type="Bool">
       <label>Should a background indicating the changes caused by curve manipulation be shown.</label>
       <default>false</default>
     </entry>
 
     <entry name="bezier_showallhandles" type="Bool">
       <label>Show handles for all points or only for the selected one.</label>
       <default>true</default>
     </entry>
   </group>
 
    <group name="drag_value">
        <entry name="dragvalue_mode" type="Int">
            <label>...</label>
            <default>0</default>
        </entry>
        <entry name="dragvalue_directupdate" type="Bool">
            <label>...</label>
            <default>true</default>
        </entry>
    </group>
 
 
   <group name="unmanaged">
     <entry name="properties_panel_page" type="Int">
            <label>Currently displayed page in properties panel</label>
            <default>0</default>
     </entry>
     <entry name="project_fps" type="Double">
       <label>Current project fps.</label>
       <default>25</default>
     </entry>
     <entry name="default_profile" type="String">
       <label>Default project format.</label>
       <default></default>
     </entry>
 
     <entry name="showdescriptioncolumn" type="Bool">
       <label>Show descriptions in project tree view.</label>
       <default>true</default>
     </entry>
 
     <entry name="showratingcolumn" type="Bool">
       <label>Show ratings in project tree view.</label>
       <default>false</default>
     </entry>
 
     <entry name="showdatecolumn" type="Bool">
       <label>Show dates in project tree view.</label>
       <default>false</default>
     </entry>
 
     <entry name="frametimecode" type="Bool">
       <label>Show timecodes as frame number instead of hh:mm:ss:ff.</label>
       <default>false</default>
     </entry>
 
     <entry name="snaptopoints" type="Bool">
       <label>Snap movements to clips, guides and markers.</label>
       <default>true</default>
     </entry>
 
     <entry name="automatictransitions" type="Bool">
       <label>New transitions are automatic transitions.</label>
       <default>true</default>
     </entry>
 
     <entry name="transitionfollowcursor" type="Bool">
       <label>When editing a composite transition, move timeline cursor for better preview.</label>
       <default>true</default>
     </entry>
 
     <entry name="keyframeseek" type="Bool">
       <label>When editing an effect with position, seek to the keyframe pos.</label>
       <default>false</default>
     </entry>
     <entry name="showbuiltstack" type="Bool">
       <label>Show builtin effect stack.</label>
       <default>false</default>
     </entry>
     <entry name="showeffectinfo" type="Bool">
       <label>Show small effect description in effects list.</label>
       <default>false</default>
     </entry>
 
     <entry name="showrenderparams" type="Bool">
       <label>Show avformat render parameters in rendering dialog.</label>
       <default>false</default>
     </entry>
 
     <entry name="displayClipMonitorInfo" type="Int">
       <label>Show overlay info on monitor (in / out points, markers,...).</label>
       <default>0x15</default>
     </entry>
 
     <entry name="displayProjectMonitorInfo" type="Int">
       <label>Show overlay info on monitor (in / out points, markers,...).</label>
       <default>0x05</default>
     </entry>
 
     <entry name="clipMonitorOverlayGuides" type="Int">
       <label>index of current guides overlay for clip monitor.</label>
       <default>0</default>
     </entry>
     <entry name="projectMonitorOverlayGuides" type="Int">
       <label>index of current guides overlay for project monitor.</label>
       <default>0</default>
     </entry>
 
     <entry name="displayAudioOverlay" type="Bool">
       <label>Show audio overlay info on monitor.</label>
       <default>false</default>
     </entry>
 
     <entry name="monitoraudio" type="Int">
       <label>Show monitor's audio level widget.</label>
       <default>0x07</default>
     </entry>
 
     <entry name="showOnMonitorScene" type="Bool">
       <label>Show on monitor adjustable effect parameter (geometry, ..).</label>
       <default>true</default>
     </entry>
 
     <entry name="autoaudiodrivername" type="String">
       <label>Audio driver selected automatically.</label>
       <default></default>
     </entry>
 
     <entry name="hastitleproducer" type="Bool">
       <label>Is MLT compiled with Qt4 Kdenlive title support.</label>
       <default>true</default>
     </entry>
 
     <entry name="mixerCollapse" type="Bool">
       <label>Collapse audio mixer (only show master channel).</label>
       <default>false</default>
     </entry>
 
     <entry name="producerslist" type="StringList">
       <label>List of available MLT producers.</label>
       <default></default>
     </entry>
 
     <entry name="widgetstyle" type="String">
       <label>Name of the chosen widget style.</label>
       <default></default>
     </entry>
 
     <entry name="showslideshowthumbs" type="Bool">
       <label>Show thumbnails in slideshow dialog.</label>
       <default>false</default>
     </entry>
 
     <entry name="showtitlebars" type="Bool">
       <label>Show dock widget titlebars to allow un/docking.</label>
       <default>true</default>
     </entry>
 
     <entry name="colorclipcolor" type="Color">
       <label>Color to preselect in the color clip dialog.</label>
       <default>#000000</default>
     </entry>
 
     <entry name="rescalekeepratio" type="Bool">
       <label>Keep aspect ratio in render dialog rescale widget.</label>
       <default>true</default>
     </entry>
 
     <entry name="defaultrescalewidth" type="Int">
       <label>default width for rendering rescale.</label>
       <default>320</default>
     </entry>
 
     <entry name="defaultrescaleheight" type="Int">
       <label>default width for rendering rescale.</label>
       <default>240</default>
     </entry>
 
     <entry name="slideshowbymime" type="Bool">
       <label>True if slideshow default method is MIME type.</label>
       <default>true</default>
     </entry>
     
     <entry name="monitorscene_directupdate" type="Bool">
       <label>Update parameters while monitor scene changes.</label>
       <default>false</default>
     </entry>
     <entry name="analyse_stopmotion" type="Bool">
       <label>Send stopmotion frames to scopes for live analysis.</label>
       <default>false</default>
     </entry>
 
     <entry name="enableaudiospectrum" type="Bool">
       <label>Send frames to audiospectrum scope for live analysis.</label>
       <default>false</default>
     </entry>
 
     <entry name="showstopmotionthumbs" type="Bool">
       <label>Show sequence thumbnails in stopmotion widget.</label>
       <default>true</default>
     </entry> 
     
     <entry name="captureinterval" type="Int">
       <label>Interval between each capture (in seconds).</label>
       <default>5</default>
     </entry>
 
     <entry name="sm_notifytime" type="Int">
       <label>Seconds before triggering a capture notification.</label>
       <default>3</default>
     </entry>
 
     <entry name="sm_prenotify" type="Bool">
       <label>Send a notification a few seconds before capture.</label>
       <default>false</default>
     </entry>
 
     <entry name="sm_loop" type="Bool">
       <label>Should we loop in stop motion playback.</label>
       <default>false</default>
     </entry>
 
     <entry name="sm_playsound" type="Bool">
       <label>Should we play a sound to notify of captured frame in stop motion.</label>
       <default>false</default>
     </entry>
     
     <entry name="sm_framesplayback" type="Int">
       <label>Number of frames to play back in stop motion playback.</label>
       <default>10</default>
     </entry>
     
     <entry name="stopmotioneffect" type="Int">
       <label>Effect applied to stopmotion frame overlay.</label>
       <default>0</default>
     </entry>
 
     <entry name="onmonitoreffects_cornersshowlines" type="Bool">
       <label>Connect the corners in the widget for the c0rners effect with lines.</label>
       <default>false</default>
     </entry>
 
     <entry name="onmonitoreffects_geometryshowprevious" type="Bool">
       <label>Show previous keyframe in monitor.</label>
       <default>false</default>
     </entry>
 
     <entry name="onmonitoreffects_geometryshowpath" type="Bool">
       <label>Show keyframe path in monitor.</label>
       <default>true</default>
     </entry>
 
     <entry name="onmonitoreffects_cornersshowcontrols" type="Bool">
       <label>Show additional controls in the c0rners on-monitor widget.</label>
       <default>false</default>
     </entry>
     
     <entry name="projectloading_avformatnovalidate" type="Bool">
       <label>Do not validate the video files when loading a project for the sake of speed.</label>
       <default>false</default>
     </entry>
 
     <entry name="monitor_audio" type="Bool">
       <label>Display audio levels.</label>
       <default>true</default>
     </entry>
     
     <entry name="enable_recording_preview" type="Bool">
       <label>Should we display video frames while capturing.</label>
       <default>true</default>
     </entry>
     
     <entry name="add_new_clip" type="Bool">
       <label>Add cut clips to project after transcoding.</label>
       <default>true</default>
     </entry>
 
     <entry name="default_marker_type" type="Int">
       <label>Default category for newly created clip markers.</label>
       <default>0</default>
     </entry>
 
     <entry name="mltdeinterlacer" type="String">
       <label>Name of the chosen deinterlacer.</label>
       <default>onefield</default>
     </entry>
 
     <entry name="mltinterpolation" type="String">
       <label>Name of the chosen interpol method.</label>
       <default>nearest</default>
     </entry>
     <entry name="favorite_effects" type="StringList">
       <label>List of favorite effects ids.</label>
       <default>volume,lift_gamma_gain,qtblend</default>
     </entry>
     <entry name="favorite_transitions" type="StringList">
       <label>List of favorite transitions ids.</label>
       <default>wipe,qtblend</default>
     </entry>
     <entry name="selected_effecttab" type="Int">
       <label>Last opened tab in effects list.</label>
       <default>0</default>
     </entry>
     <entry name="force_breeze" type="Bool">
       <label>Force breeze icon theme for consistent look.</label>
       <default>false</default>
     </entry>
     <entry name="use_dark_breeze" type="Bool">
       <label>Force breeze icon color theme for consistent look.</label>
       <default>false</default>
     </entry>
     </group>
   <group name="effects">
       <entry name="lock_ratio" type="Bool">
       <label>Lock size ratio in effects.</label>
       <default>true</default>
     </entry>
   </group>
   <group name="titles">
        <entry name="selected_template" type="String">
            <label>Name of last selected title template</label>
            <default></default>
        </entry>
        <entry name="titlerShowGuides" type="Bool">
         <label>Show guides in titler.</label>
         <default>false</default>
         </entry>
         <entry name="titlerHGuides" type="Int">
         <label>Number of horizontal guides in titler.</label>
         <default>2</default>
         </entry>
         <entry name="titlerVGuides" type="Int">
         <label>Number of vertical guides in titler.</label>
         <default>3</default>
         </entry>
         <entry name="titleGuideColor" type="Color">
         <label>color titler guides.</label>
         <default>#ff0000</default>
         </entry>
         <entry name="titlerbg" type="Int">
         <label>Default background for titler.</label>
         <default>0</default>
         </entry>
    </group>
 </kcfg>